XLS is an older spreadsheet file format developed by Microsoft Excel, and it is still used by some users today. Since Excel 2007, Microsoft has adopted the newer XLSX format. Due to differences between these formats, opening an XLS file in a newer version of Excel can sometimes cause compatibility issues, affecting editing and data processing. As a result, performing an XLS to XLSX conversion has become a common task in spreadsheet management. Fortunately, this article introduces three simple and effective methods to help you convert XLS files to XLSX quickly and easily.

• XLS to XLSX Conversion: Manually
• Convert XLS to XLSX Online
• Batch Convert XLS to XLSX Automatically
• FAQs

Perform XLS-to-XLSX Conversion Manually

The first and most straightforward way to convert XLS to XLSX is manual conversion, which works best when you only have a small number of files. This method does not require any special software or programming knowledge, making it ideal for users who need a quick solution. There are two common approaches for manual conversion:

1. Change the file extension

Locate the XLS file you want to convert, right-click it, and select Rename. Replace the file extension from .xls to .xlsx.

1. Save As

Open the source file in Excel, click the File tab in the top menu, then select Save As from the left panel. In the Save as type dropdown, choose XLSX, and finally click Save.

Convert XLS to XLSX Online

If you find manual operations too time-consuming, since they require repeated clicks, you can use an online XLS to XLSX converter instead. One example is CloudConvert, a free online file conversion tool. It not only converts spreadsheet files but also supports text documents, images, audio, and video formats. Using it is straightforward—just follow these steps:

1. Navigate to the website and click the red Select File button to choose the file you want to convert, or simply drag and drop it onto the button.

2. Once the file is uploaded, click the red button on the right to start the conversion.

3. Wait a few seconds. When you see the Finished status, click the green Download button to save the converted XLSX file to your computer.

This method is ideal when you only need to convert a few XLS files to XLSX quickly without installing any software.

Batch Convert XLS to XLSX Safely

If you need to convert hundreds or even thousands of files, manual or online conversion methods are no longer practical. Similarly, if data security is a top priority, the best option is to perform batch conversions locally with code. This approach ensures that your file data remains completely safe, as it does not rely on any online service.

For this purpose, we recommend using Spire.XLS, a professional third-party Excel library that can be integrated into enterprise systems or automated workflows, enabling large-scale XLS to XLSX conversions.

The following example demonstrates how this can be achieved in Python:

from spire.xls import *
from spire.xls.common import *
import os

# Specify the input and output folders
inputFolder = "/input/XLS SAMPLES/"
outputFolder = "/output/TO XLSX/"

# Loop through all .xls files in the input folder
for file in os.listdir(inputFolder):
    if file.endswith(".xls"):
        # Build full file paths
        inputFile = os.path.join(inputFolder, file)
        outputFile = os.path.join(outputFolder, os.path.splitext(file)[0] + ".xlsx")

        # Create a Workbook object
        workbook = Workbook()
        # Load the XLS file
        workbook.LoadFromFile(inputFile)

        # Save as XLSX format
        workbook.SaveToFile(outputFile, ExcelVersion.Version2016)
        workbook.Dispose()

print("Batch conversion completed successfully!")

Here is a preview comparing the source files with the converted ones:

Steps explained:

• Import Spire.XLS and Python modules.
• Loop through all .xls files in the input folder.
• Load each file into a Workbook object.
• Convert XLS to XLSX by saving it in .xlsx format through the Workbook.saveToFile() method.

If you want to convert an XLSX file back to XLS, you can also use the Workbook.saveToFile() method. Spire.XLS also supports using this method to convert Excel files into PDF, images, and more.

FAQs about XLS to XLSX Conversion

1. How do I save my Excel file as XLSX?

You can save an Excel file as XLSX by using the Save As feature in Excel or by using online or programmatic conversion tools, depending on the number of files and your needs.

1. When did Excel switch from XLS to XLSX?

Microsoft introduced the XLSX format starting with Excel 2007 to replace the older XLS format. XLSX offers better performance, reduced file size, and improved compatibility with modern Excel features.

1. Is XLS the same as XLSX?

No. XLS is the older binary file format used in Excel 97-2003, while XLSX is the newer XML-based format introduced in Excel 2007. They differ in structure, compatibility, and supported features.

1. Can online tools convert XLS to XLSX?

Yes, many online tools allow you to convert XLS files to XLSX. They are convenient for small numbers of files but may not be suitable for large batches or sensitive data.

1. What’s the best way to convert a large number of XLS files to XLSX safely?

For hundreds or thousands of files, or when data security is important, using code with a library like Spire.XLS for batch conversion on your local machine is the most efficient and secure method.

The Conclusion

In summary, XLS to XLSX conversion can be handled in different ways depending on your needs. For a handful of files, Excel or online tools may be sufficient. But for large-scale or sensitive files, automation with code is the best choice. By leveraging Spire.XLS, you can integrate bulk conversions directly into your workflow, ensuring both speed and safety. Whether you need to upgrade legacy files, streamline internal processes, or prepare data for modern systems, Spire.XLS offers a professional and flexible solution.

ALSO READ

Convert Excel (XLSX/XLS) to CSV in Python

Python: Convert Excel to PDF Easily and Quickly

Convert CSV to Excel (XLSX) in Python – Single & Batch

Python: Convert Excel to SVG Automatically

Al trabajar con archivos PDF en Java, a menudo es necesario convertir entre datos binarios y formatos basados en texto. La codificación Base64 permite que el contenido de un PDF se represente como texto sin formato, lo cual es útil al transmitir documentos en JSON, enviarlos a través de envíos de formularios o almacenarlos en sistemas basados en texto. La biblioteca estándar de Java proporciona java.util.Base64, lo que facilita la implementación de conversiones tanto de Base64 a PDF como de PDF a Base64 sin dependencias adicionales.

En este tutorial, exploraremos cómo manejar estas conversiones usando solo el JDK, así como cómo trabajar con imágenes Base64 e incrustarlas en archivos PDF. Para operaciones más avanzadas, como editar un PDF recibido como Base64 y exportarlo de nuevo, demostraremos el uso de Free Spire.PDF for Java.

Tabla de contenidos

• Convertir Base64 a PDF en Java (solo JDK)
• Convertir PDF a Base64 en Java (solo JDK)
• Consejos de validación y seguridad
• Guardar imágenes Base64 como PDF en Java
• Cargar PDF Base64, modificar y guardar de nuevo como Base64
• Consideraciones de rendimiento y memoria
• Preguntas frecuentes

Convertir Base64 a PDF en Java (solo JDK)

El enfoque más simple es leer una cadena Base64 en la memoria, eliminar cualquier prefijo opcional (como data:application/pdf;base64,) y luego decodificarla en un PDF. Esto funciona bien para archivos de tamaño pequeño a mediano.

import java.nio.file.*;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Base64ToPdf {
    public static void main(String[] args) throws Exception {
        // Leer texto Base64 de un archivo (o cualquier otra fuente)
        String base64 = Files.readString(Paths.get("sample.pdf.b64"), StandardCharsets.UTF_8);

        // Eliminar prefijos comunes de URI de datos si están presentes
        base64 = stripDataPrefix(base64);

        // Decodificar Base64 en bytes de PDF sin procesar
        // El decodificador MIME tolera saltos de línea y texto ajustado
        byte[] pdfBytes = Base64.getMimeDecoder().decode(base64);

        // Escribir los bytes decodificados en un archivo PDF
        Files.write(Paths.get("output.pdf"), pdfBytes);
    }

    /** Utilidad para eliminar "data:application/pdf;base64," si está incluido */
    private static String stripDataPrefix(String src) {
        String s = src.trim();
        int comma = s.indexOf(',');
        if (comma > 0 && s.substring(0, comma).toLowerCase().contains("base64")) {
            return s.substring(comma + 1).trim();
        }
        return s;
    }
}

Explicación Este ejemplo es sencillo y fiable para contenido Base64 que cabe cómodamente en la memoria. Se elige Base64.getMimeDecoder() porque maneja con elegancia los saltos de línea, que son comunes en el texto Base64 exportado desde sistemas de correo electrónico o API. Si sabe que su cadena Base64 no contiene saltos de línea, también podría usar Base64.getDecoder().

Asegúrese de eliminar cualquier prefijo de URI de datos (data:application/pdf;base64,) antes de decodificar, ya que no forma parte de la carga útil de Base64. El método de ayuda stripDataPrefix() lo hace automáticamente.

Variante de transmisión (sin la cadena completa en memoria)

Para archivos PDF grandes, es mejor procesar Base64 de forma continua. Esto evita cargar toda la cadena Base64 en la memoria de una sola vez.

import java.io.*;
import java.nio.file.*;
import java.util.Base64;

public class Base64ToPdfStreamed {
    public static void main(String[] args) throws Exception {
        // Entrada: archivo de texto que contiene PDF codificado en Base64
        Path in = Paths.get("sample.pdf.b64");

        // Salida: archivo PDF decodificado
        Path out = Paths.get("output.pdf");

        // Envolver el decodificador Base64 alrededor del flujo de entrada
        try (InputStream b64In = Base64.getMimeDecoder().wrap(Files.newInputStream(in));
             OutputStream pdfOut = Files.newOutputStream(out)) {

            // Transmitir los bytes decodificados directamente a la salida del PDF
            b64In.transferTo(pdfOut);
        }
    }
}

Explicación Este enfoque basado en la transmisión es más eficiente en cuanto a la memoria, ya que decodifica los datos sobre la marcha en lugar de almacenar en búfer toda la cadena. Es el método recomendado para archivos grandes o flujos continuos (por ejemplo, sockets de red).

• Se utiliza Base64.getMimeDecoder() para tolerar los saltos de línea en la entrada.
• El método transferTo() copia eficientemente los bytes decodificados de la entrada a la salida sin manejo manual del búfer.
• En el uso en el mundo real, considere agregar manejo de excepciones para gestionar errores de acceso a archivos o escrituras parciales.

Convertir PDF a Base64 en Java (solo JDK)

Codificar un PDF en Base64 es igual de simple. Para archivos más pequeños, leer todo el PDF en la memoria está bien:

import java.nio.file.*;
import java.util.Base64;

public class PdfToBase64 {
    public static void main(String[] args) throws Exception {
        // Leer el archivo PDF en un array de bytes
        byte[] pdfBytes = Files.readAllBytes(Paths.get("input.pdf"));

        // Codificar los bytes del PDF como una cadena Base64
        String base64 = Base64.getEncoder().encodeToString(pdfBytes);

        // Escribir la cadena Base64 en un archivo de texto
        Files.writeString(Paths.get("output.pdf.b64"), base64);
    }
}

Explicación Este enfoque es simple y funciona bien para archivos de tamaño pequeño o mediano. Todo el PDF se lee en un array de bytes y se codifica como una única cadena Base64. Esta cadena se puede almacenar, transmitir en JSON o incrustar en un URI de datos.

Codificador de transmisión (maneja archivos grandes de manera eficiente)

Para archivos PDF grandes, puede evitar la sobrecarga de memoria codificando directamente como un flujo:

import java.io.*;
import java.nio.file.*;
import java.util.Base64;

public class PdfToBase64Streamed {
    public static void main(String[] args) throws Exception {
        // Entrada: archivo PDF binario
        try (InputStream pdfIn = Files.newInputStream(Paths.get("input.pdf"));
             // Flujo de salida sin procesar para el archivo de texto Base64
             OutputStream rawOut = Files.newOutputStream(Paths.get("output.pdf.b64"));
             // Envolver el flujo de salida con el codificador Base64
             OutputStream b64Out = Base64.getEncoder().wrap(rawOut)) {

            // Transmitir los bytes del PDF directamente a la salida codificada en Base64
            pdfIn.transferTo(b64Out);
        }
    }
}

Explicación El codificador de transmisión maneja eficientemente archivos grandes codificando datos de forma incremental en lugar de cargar todo en la memoria. El método Base64.getEncoder().wrap() convierte un flujo de salida regular en uno que escribe texto Base64 automáticamente.

Este diseño se escala mejor para archivos PDF grandes, flujos de red o servicios que deben manejar muchos documentos simultáneamente sin sufrir presión de memoria.

Consejos de validación y seguridad

• Detectar URIs de datos: los usuarios pueden enviar prefijos data:application/pdf;base64,. Elimínelos antes de decodificar.
• Saltos de línea: al decodificar texto que puede contener líneas ajustadas (correos electrónicos, registros), use Base64.getMimeDecoder().
• Comprobación rápida de cordura: después de decodificar, los primeros bytes de un PDF válido generalmente comienzan con %PDF-. Puede afirmar esto para una detección temprana de fallas.
• Codificación de caracteres: trate el texto Base64 como UTF-8 (o US-ASCII) al leer/escribir archivos .b64.
• Manejo de errores: envuelva la decodificación/codificación en try/catch y muestre mensajes procesables (por ejemplo, tamaño, discrepancia de encabezado).

Guardar imágenes Base64 como PDF en Java

A veces recibe imágenes (por ejemplo, PNG o JPEG) como cadenas Base64 y necesita envolverlas en un PDF. Si bien la biblioteca estándar de Java no tiene API de PDF, Free Spire.PDF for Java lo hace sencillo.

Puede descargar Free Spire.PDF for Java y agregarlo a su proyecto o instalar Free Spire.PDF for Java desde el repositorio de Maven.

Conceptos clave de Spire.PDF

• PdfDocument: el contenedor de una o más páginas PDF.
• PdfPageBase: representa una página en la que se puede dibujar.
• PdfImage.fromImage(): carga una BufferedImage o un flujo en una imagen PDF dibujable.
• drawImage(): coloca la imagen en las coordenadas y el tamaño especificados.
• Sistema de coordenadas: Spire.PDF utiliza un sistema de coordenadas donde (0,0) es la esquina superior izquierda.

Ejemplo: Convertir imagen Base64 a PDF usando Java

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.graphics.PdfImage;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.Base64;

public class Base64ImageToPdf {
    public static void main(String[] args) throws Exception {
        // 1) Leer archivo Base64 y decodificar (eliminar prefijo de URI de datos si existe)
        String base64Image = Files.readString(Paths.get("G:/Document/image.b64"), StandardCharsets.UTF_8).trim();
        int comma = base64Image.indexOf(',');
        if (comma > 0 && base64Image.substring(0, comma).toLowerCase().contains("base64")) {
            base64Image = base64Image.substring(comma + 1).trim();
        }
        byte[] imageBytes = Base64.getMimeDecoder().decode(base64Image);

        // 2) Crear PDF e insertar la imagen
        PdfDocument pdf = new PdfDocument();
        try (ByteArrayInputStream in = new ByteArrayInputStream(imageBytes)) {
            PdfImage img = PdfImage.fromStream(in);
            pdf.getPageSettings().setWidth(img.getWidth());
            pdf.getPageSettings().setHeight(img.getHeight());
            pdf.getPageSettings().setMargins(0, 0, 0, 0);
            PdfPageBase page = pdf.getPages().add();
            page.getCanvas().drawImage(img, 0, 0);
        }

        // 3) Guardar archivo PDF
        pdf.saveToFile("output/image.pdf");
    }
}

El siguiente ejemplo decodifica una imagen Base64 y la incrusta en una página PDF. El resultado se ve así:

Este flujo de trabajo es ideal para incrustar documentos escaneados o firmas que llegan como Base64.

Para gráficos vectoriales, también puede consultar nuestra guía sobre conversión de SVG a PDF en Java.

Cargar PDF Base64, modificar y guardar de nuevo como Base64

En muchas API, un PDF llega como Base64. Con Spire.PDF puede cargarlo, dibujar en las páginas (texto/marcas de agua) y devolverlo de nuevo como Base64, ideal para funciones sin servidor o microservicios.

Conceptos clave de Spire.PDF utilizados aquí

• PdfDocument.loadFromBytes(byte[]): construye un documento directamente a partir de bytes decodificados.
• PdfPageBase#getCanvas(): obtiene una superficie de dibujo para colocar texto, formas o imágenes.
• Fuentes y pinceles: por ejemplo, PdfTrueTypeFont o fuentes integradas a través de PdfFont, con PdfSolidBrush para colorear.
• Guardar en memoria: pdf.saveToStream(ByteArrayOutputStream) produce bytes sin procesar, que puede volver a codificar con Base64.

Ejemplo: Cargar, modificar y guardar PDF Base64 en Java

import com.spire.pdf.*;
import com.spire.pdf.graphics.*;

import java.awt.*;
import java.io.*;
import java.util.Base64;

public class EditBase64Pdf {
    public static void main(String[] args) throws Exception {
        String base64Pdf = "..."; // cadena de PDF Base64 entrante

        // Decodificar a bytes
        byte[] pdfBytes = Base64.getDecoder().decode(base64Pdf);

        // Cargar PDF
        PdfDocument pdf = new PdfDocument();
        pdf.loadFromBytes(pdfBytes);

        // Agregar sello en cada página
        for (PdfPageBase page : (Iterable<PdfPageBase>) pdf.getPages()) {
            PdfTrueTypeFont font = new PdfTrueTypeFont(new Font("Arial", Font.BOLD, 36));
            PdfSolidBrush brush = new PdfSolidBrush(new PdfRGBColor(Color.BLUE));
            page.getCanvas().drawString("Procesado", font, brush, 100, 100);
        }

        // Guardar en memoria y volver a codificar a Base64
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        pdf.saveToStream(output);
        pdf.close();

        String resultBase64 = Base64.getEncoder().encodeToString(output.toByteArray());
        System.out.println(resultBase64);
    }
}

En este ejemplo, se agrega una marca de agua azul "Procesado" a cada página del PDF antes de volver a codificarlo en Base64. El resultado se ve así:

Este viaje de ida y vuelta (Base64 → PDF → Base64) es útil para pipelines de documentos, como sellar facturas o agregar firmas dinámicas en un servicio en la nube.

Tutoriales relacionados:
Extraer texto de PDF en Java | Crear documentos PDF en Java

Consideraciones de rendimiento y memoria

• Transmisión frente a E/S de archivos: al tratar con Base64, prefiera ByteArrayInputStream y ByteArrayOutputStream para evitar archivos temporales innecesarios.
• PDF con muchas imágenes: la decodificación de imágenes Base64 puede aumentar el uso de la memoria; considere escalar o comprimir antes de incrustar.
• PDF grandes: Spire.PDF maneja PDF de varios MB, pero para documentos muy grandes considere el procesamiento página por página.
• Funciones sin servidor: los flujos de trabajo de Base64 encajan bien porque se evita la dependencia del sistema de archivos y se devuelven los resultados directamente a través de las respuestas de la API.

Preguntas frecuentes

P: ¿Puedo convertir Base64 a PDF usando solo el JDK?

Sí. Java SE proporciona utilidades de Base64 y E/S de archivos, por lo que puede manejar la conversión sin bibliotecas adicionales.

P: ¿Puedo editar un PDF con la biblioteca estándar de Java?

No. Java SE no admite el análisis ni la representación de la estructura de PDF. Para editar, use una biblioteca dedicada como Spire.PDF for Java.

P: ¿Es suficiente Free Spire.PDF for Java?

Sí. Free Spire.PDF for Java tiene un tamaño de documento limitado, pero es suficiente para pruebas o proyectos a pequeña escala.

P: ¿Necesito guardar los PDF en el disco?

No siempre. La conversión también se puede ejecutar en memoria usando flujos, lo que a menudo se prefiere para API y aplicaciones en la nube.

Véase también

• Convertir HTML a PDF con JavaScript
• Convertir bytes a PDF en Java
• Convertir texto a PDF en Java
• Extraer imágenes de PDF en Java

Ao trabalhar com arquivos PDF em Java, muitas vezes é necessário converter entre dados binários e formatos baseados em texto. A codificação Base64 permite que o conteúdo do PDF seja representado como texto simples, o que é útil ao transmitir documentos em JSON, enviá-los por meio de formulários ou armazená-los em sistemas baseados em texto. A biblioteca padrão do Java fornece java.util.Base64, tornando simples a implementação de conversões de Base64 para PDF e PDF para Base64 sem dependências adicionais.

Neste tutorial, exploraremos como lidar com essas conversões usando apenas o JDK, bem como como trabalhar com imagens Base64 e incorporá-las em PDFs. Para operações mais avançadas, como editar um PDF recebido como Base64 e exportá-lo de volta, demonstraremos o uso do Free Spire.PDF for Java.

Índice

• Converter Base64 para PDF em Java (apenas JDK)
• Converter PDF para Base64 em Java (apenas JDK)
• Dicas de Validação e Segurança
• Salvar Imagens Base64 como PDF em Java
• Carregar PDF Base64, Modificar e Salvar de Volta como Base64
• Considerações de Desempenho e Memória
• FAQ

Converter Base64 para PDF em Java (apenas JDK)

A abordagem mais simples é ler uma string Base64 na memória, remover quaisquer prefixos opcionais (como data:application/pdf;base64,) e, em seguida, decodificá-la em um PDF. Isso funciona bem para arquivos de pequeno a médio porte.

import java.nio.file.*;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Base64ToPdf {
    public static void main(String[] args) throws Exception {
        // Ler texto Base64 de um arquivo (ou qualquer outra fonte)
        String base64 = Files.readString(Paths.get("sample.pdf.b64"), StandardCharsets.UTF_8);

        // Remover prefixos de URI de dados comuns, se presentes
        base64 = stripDataPrefix(base64);

        // Decodificar Base64 em bytes de PDF brutos
        // O decodificador MIME tolera quebras de linha e texto quebrado
        byte[] pdfBytes = Base64.getMimeDecoder().decode(base64);

        // Escrever os bytes decodificados em um arquivo PDF
        Files.write(Paths.get("output.pdf"), pdfBytes);
    }

    /** Utilitário para remover o prefixo "data:application/pdf;base64,", se incluído */
    private static String stripDataPrefix(String src) {
        String s = src.trim();
        int comma = s.indexOf(',');
        if (comma > 0 && s.substring(0, comma).toLowerCase().contains("base64")) {
            return s.substring(comma + 1).trim();
        }
        return s;
    }
}

Explicação Este exemplo é direto e confiável para conteúdo Base64 que cabe confortavelmente na memória. O Base64.getMimeDecoder() é escolhido porque lida elegantemente com quebras de linha, que são comuns em texto Base64 exportado de sistemas de e-mail ou APIs. Se você sabe que sua string Base64 não contém novas linhas, também pode usar Base64.getDecoder().

Certifique-se de remover qualquer prefixo de URI de dados (data:application/pdf;base64,) antes de decodificar, pois não faz parte da carga útil do Base64. O método auxiliar stripDataPrefix() faz isso automaticamente.

Variante de streaming (sem a string completa na memória)

Para PDFs grandes, é melhor processar o Base64 de forma contínua. Isso evita carregar toda a string Base64 na memória de uma vez.

import java.io.*;
import java.nio.file.*;
import java.util.Base64;

public class Base64ToPdfStreamed {
    public static void main(String[] args) throws Exception {
        // Entrada: arquivo de texto contendo PDF codificado em Base64
        Path in = Paths.get("sample.pdf.b64");

        // Saída: arquivo PDF decodificado
        Path out = Paths.get("output.pdf");

        // Envolver o decodificador Base64 em torno do fluxo de entrada
        try (InputStream b64In = Base64.getMimeDecoder().wrap(Files.newInputStream(in));
             OutputStream pdfOut = Files.newOutputStream(out)) {

            // Transmitir os bytes decodificados diretamente para a saída do PDF
            b64In.transferTo(pdfOut);
        }
    }
}

Explicação Essa abordagem baseada em streaming é mais eficiente em termos de memória, pois decodifica os dados em tempo real, em vez de armazenar a string inteira em buffer. É o método recomendado para arquivos grandes ou fluxos contínuos (por exemplo, soquetes de rede).

• Base64.getMimeDecoder() é usado para tolerar quebras de linha na entrada.
• O método transferTo() copia eficientemente os bytes decodificados da entrada para a saída sem o manuseio manual do buffer.
• No uso real, considere adicionar tratamento de exceções para gerenciar erros de acesso a arquivos ou gravações parciais.

Converter PDF para Base64 em Java (apenas JDK)

Codificar um PDF em Base64 é igualmente simples. Para arquivos menores, ler o PDF inteiro na memória é suficiente:

import java.nio.file.*;
import java.util.Base64;

public class PdfToBase64 {
    public static void main(String[] args) throws Exception {
        // Ler o arquivo PDF em um array de bytes
        byte[] pdfBytes = Files.readAllBytes(Paths.get("input.pdf"));

        // Codificar os bytes do PDF como uma string Base64
        String base64 = Base64.getEncoder().encodeToString(pdfBytes);

        // Escrever a string Base64 em um arquivo de texto
        Files.writeString(Paths.get("output.pdf.b64"), base64);
    }
}

Explicação Essa abordagem é simples e funciona bem para arquivos de pequeno a médio porte. O arquivo PDF inteiro é lido em um array de bytes e codificado como uma única string Base64. Essa string pode ser armazenada, transmitida em JSON ou incorporada em uma URI de dados.

Codificador de streaming (lida com arquivos grandes de forma eficiente)

Para PDFs grandes, você pode evitar a sobrecarga de memória codificando diretamente como um fluxo:

import java.io.*;
import java.nio.file.*;
import java.util.Base64;

public class PdfToBase64Streamed {
    public static void main(String[] args) throws Exception {
        // Entrada: arquivo PDF binário
        try (InputStream pdfIn = Files.newInputStream(Paths.get("input.pdf"));
             // Fluxo de saída bruto para arquivo de texto Base64
             OutputStream rawOut = Files.newOutputStream(Paths.get("output.pdf.b64"));
             // Envolver o fluxo de saída com o codificador Base64
             OutputStream b64Out = Base64.getEncoder().wrap(rawOut)) {

            // Transmitir bytes de PDF diretamente para a saída codificada em Base64
            pdfIn.transferTo(b64Out);
        }
    }
}

Explicação O codificador de streaming lida eficientemente com arquivos grandes, codificando os dados de forma incremental em vez de carregar tudo na memória. O método Base64.getEncoder().wrap() transforma um fluxo de saída regular em um que grava texto Base64 automaticamente.

Este design escala melhor para PDFs grandes, fluxos de rede ou serviços que devem lidar com muitos documentos simultaneamente sem sofrer pressão de memória.

Dicas de Validação e Segurança

• Detectar URIs de Dados: os usuários podem enviar prefixos data:application/pdf;base64,. Remova-os antes de decodificar.
• Quebras de linha: ao decodificar texto que pode conter linhas quebradas (e-mails, logs), use Base64.getMimeDecoder().
• Verificação rápida de sanidade: após a decodificação, os primeiros bytes de um PDF válido geralmente começam com %PDF-. Você pode verificar isso para detecção precoce de falhas.
• Codificação de caracteres: trate o texto Base64 como UTF-8 (ou US-ASCII) ao ler/escrever arquivos .b64.
• Tratamento de erros: envolva a decodificação/codificação em blocos try/catch e exiba mensagens acionáveis (por exemplo, tamanho, incompatibilidade de cabeçalho).

Salvar Imagens Base64 como PDF em Java

Às vezes, você recebe imagens (por exemplo, PNG ou JPEG) como strings Base64 e precisa envolvê-las em um PDF. Embora a biblioteca padrão do Java não tenha APIs de PDF, o Free Spire.PDF for Java torna isso simples.

Você pode baixar o Free Spire.PDF for Java e adicioná-lo ao seu projeto ou instalar o Free Spire.PDF for Java a partir do repositório Maven.

Conceitos-chave do Spire.PDF

• PdfDocument — o contêiner para uma ou mais páginas de PDF.
• PdfPageBase — representa uma página na qual você pode desenhar.
• PdfImage.fromImage() — carrega uma BufferedImage ou um fluxo em uma imagem PDF desenhável.
• drawImage() — posiciona a imagem nas coordenadas e no tamanho especificados.
• Sistema de Coordenadas — o Spire.PDF usa um sistema de coordenadas onde (0,0) é o canto superior esquerdo.

Exemplo: Converter imagem Base64 para PDF usando Java

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.graphics.PdfImage;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.Base64;

public class Base64ImageToPdf {
    public static void main(String[] args) throws Exception {
        // 1) Ler arquivo Base64 e decodificar (remover prefixo de URI de dados, se existir)
        String base64Image = Files.readString(Paths.get("G:/Document/image.b64"), StandardCharsets.UTF_8).trim();
        int comma = base64Image.indexOf(',');
        if (comma > 0 && base64Image.substring(0, comma).toLowerCase().contains("base64")) {
            base64Image = base64Image.substring(comma + 1).trim();
        }
        byte[] imageBytes = Base64.getMimeDecoder().decode(base64Image);

        // 2) Criar PDF e inserir a imagem
        PdfDocument pdf = new PdfDocument();
        try (ByteArrayInputStream in = new ByteArrayInputStream(imageBytes)) {
            PdfImage img = PdfImage.fromStream(in);
            pdf.getPageSettings().setWidth(img.getWidth());
            pdf.getPageSettings().setHeight(img.getHeight());
            pdf.getPageSettings().setMargins(0, 0, 0, 0);
            PdfPageBase page = pdf.getPages().add();
            page.getCanvas().drawImage(img, 0, 0);
        }

        // 3) Salvar arquivo PDF
        pdf.saveToFile("output/image.pdf");
    }
}

O exemplo a seguir decodifica uma imagem Base64 e a incorpora em uma página de PDF. A saída se parece com isto:

Este fluxo de trabalho é ideal para incorporar documentos digitalizados ou assinaturas que chegam como Base64.

Para gráficos vetoriais, você também pode consultar nosso guia sobre Converter SVG para PDF em Java.

Carregar PDF Base64, Modificar e Salvar de Volta como Base64

Em muitas APIs, um PDF chega como Base64. Com o Spire.PDF, você pode carregá-lo, desenhar nas páginas (texto/marcas d'água) e retornar Base64 novamente — ideal para funções sem servidor ou microsserviços.

Conceitos-chave do Spire.PDF usados aqui

• PdfDocument.loadFromBytes(byte[]) — constrói um documento diretamente a partir de bytes decodificados.
• PdfPageBase#getCanvas() — obtém uma superfície de desenho para colocar texto, formas ou imagens.
• Fontes e pincéis — por exemplo, PdfTrueTypeFont ou fontes integradas via PdfFont, com PdfSolidBrush para colorir.
• Salvar na memória — pdf.saveToStream(ByteArrayOutputStream) produz bytes brutos, que você pode recodificar com Base64.

Exemplo: Carregar, modificar e salvar PDF Base64 em Java

import com.spire.pdf.*;
import com.spire.pdf.graphics.*;

import java.awt.*;
import java.io.*;
import java.util.Base64;

public class EditBase64Pdf {
    public static void main(String[] args) throws Exception {
        String base64Pdf = "..."; // string de PDF Base64 recebida

        // Decodificar para bytes
        byte[] pdfBytes = Base64.getDecoder().decode(base64Pdf);

        // Carregar PDF
        PdfDocument pdf = new PdfDocument();
        pdf.loadFromBytes(pdfBytes);

        // Adicionar carimbo em cada página
        for (PdfPageBase page : (Iterable) pdf.getPages()) {
            PdfTrueTypeFont font = new PdfTrueTypeFont(new Font("Arial", Font.BOLD, 36));
            PdfSolidBrush brush = new PdfSolidBrush(new PdfRGBColor(Color.BLUE));
            page.getCanvas().drawString("Processed", font, brush, 100, 100);
        }

        // Salvar na memória e codificar de volta para Base64
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        pdf.saveToStream(output);
        pdf.close();

        String resultBase64 = Base64.getEncoder().encodeToString(output.toByteArray());
        System.out.println(resultBase64);
    }
}

Neste exemplo, uma marca d'água azul "Processado" é adicionada a cada página do PDF antes de recodificá-lo de volta para Base64. O resultado se parece com isto:

Esta viagem de ida e volta (Base64 → PDF → Base64) é útil para pipelines de documentos, como carimbar faturas ou adicionar assinaturas dinâmicas em um serviço de nuvem.

Tutoriais relacionados:
Extrair Texto de PDF em Java | Criar Documentos PDF em Java

Considerações de Desempenho e Memória

• Streaming vs. E/S de arquivos — ao lidar com Base64, prefira ByteArrayInputStream e ByteArrayOutputStream para evitar arquivos temporários desnecessários.
• PDFs com muitas imagens — a decodificação de imagens Base64 pode aumentar o uso da memória; considere redimensionar ou comprimir antes de incorporar.
• PDFs grandes — o Spire.PDF lida com PDFs de vários MB, mas para documentos muito grandes, considere o processamento página por página.
• Funções sem servidor — os fluxos de trabalho Base64 se encaixam bem porque você evita a dependência do sistema de arquivos e retorna os resultados diretamente por meio de respostas de API.

FAQ

P: Posso converter Base64 para PDF usando apenas o JDK?

Sim. O Java SE fornece utilitários de Base64 e E/S de arquivos, para que você possa lidar com a conversão sem bibliotecas extras.

P: Posso editar um PDF com a biblioteca padrão do Java?

Não. O Java SE não suporta a análise da estrutura ou a renderização de PDF. Para edição, use uma biblioteca dedicada como Spire.PDF for Java.

P: O Free Spire.PDF for Java é suficiente?

Sim. O Free Spire.PDF for Java é limitado no tamanho do documento, mas suficiente para testes ou projetos de pequena escala.

P: Preciso salvar os PDFs no disco?

Nem sempre. A conversão também pode ser executada na memória usando fluxos, o que é frequentemente preferido para APIs e aplicativos em nuvem.

Veja Também

• Converter HTML para PDF com JavaScript
• Converter Bytes para PDF em Java
• Converter Texto para PDF em Java
• Extrair Imagens de PDF em Java

Java에서 PDF 파일로 작업할 때 바이너리 데이터와 텍스트 기반 형식 간에 변환해야 하는 경우가 많습니다. Base64 인코딩을 사용하면 PDF 콘텐츠를 일반 텍스트로 나타낼 수 있으며, 이는 문서를 JSON으로 전송하거나, 양식 제출을 통해 보내거나, 텍스트 기반 시스템에 저장할 때 유용합니다. Java의 표준 라이브러리는 java.util.Base64를 제공하여 추가 종속성 없이 Base64를 PDF로 및 PDF를 Base64로 변환하는 작업을 간단하게 구현할 수 있습니다.

이 튜토리얼에서는 JDK만 사용하여 이러한 변환을 처리하는 방법과 Base64 이미지로 작업하고 이를 PDF에 포함하는 방법을 살펴봅니다. Base64로 받은 PDF를 편집하고 다시 내보내는 것과 같은 고급 작업의 경우 Free Spire.PDF for Java를 사용하는 방법을 시연합니다.

목차

• Java에서 Base64를 PDF로 변환 (JDK만 사용)
• Java에서 PDF를 Base64로 변환 (JDK만 사용)
• 유효성 검사 및 안전 팁
• Java에서 Base64 이미지를 PDF로 저장
• Base64 PDF 로드, 수정 및 Base64로 다시 저장
• 성능 및 메모리 고려 사항
• FAQ

Java에서 Base64를 PDF로 변환 (JDK만 사용)

가장 간단한 방법은 Base64 문자열을 메모리로 읽어들인 다음, 선택적 접두사(예: data:application/pdf;base64,)를 제거하고 PDF로 디코딩하는 것입니다. 이 방법은 중소 규모 파일에 적합합니다.

import java.nio.file.*;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Base64ToPdf {
    public static void main(String[] args) throws Exception {
        // 파일(또는 다른 소스)에서 Base64 텍스트 읽기
        String base64 = Files.readString(Paths.get("sample.pdf.b64"), StandardCharsets.UTF_8);

        // 존재하는 경우 일반적인 데이터 URI 접두사 제거
        base64 = stripDataPrefix(base64);

        // Base64를 원시 PDF 바이트로 디코딩
        // MIME 디코더는 줄 바꿈 및 줄 바꿈된 텍스트를 허용합니다
        byte[] pdfBytes = Base64.getMimeDecoder().decode(base64);

        // 디코딩된 바이트를 PDF 파일에 쓰기
        Files.write(Paths.get("output.pdf"), pdfBytes);
    }

    /** "data:application/pdf;base64," 접두사를 제거하는 유틸리티 */
    private static String stripDataPrefix(String src) {
        String s = src.trim();
        int comma = s.indexOf(',');
        if (comma > 0 && s.substring(0, comma).toLowerCase().contains("base64")) {
            return s.substring(comma + 1).trim();
        }
        return s;
    }
}

설명 이 예제는 메모리에 편안하게 맞는 Base64 콘텐츠에 대해 간단하고 신뢰할 수 있습니다. Base64.getMimeDecoder()는 이메일 시스템이나 API에서 내보낸 Base64 텍스트에서 흔히 볼 수 있는 줄 바꿈을 정상적으로 처리하기 때문에 선택되었습니다. Base64 문자열에 줄 바꿈이 없다는 것을 알고 있다면 Base64.getDecoder()를 사용할 수도 있습니다.

디코딩하기 전에 데이터 URI 접두사(data:application/pdf;base64,)를 제거해야 합니다. 이는 Base64 페이로드의 일부가 아니기 때문입니다. 도우미 메서드 stripDataPrefix()가 이를 자동으로 수행합니다.

스트리밍 변형 (메모리에 전체 문자열 없음)

대용량 PDF의 경우 Base64를 스트리밍 방식으로 처리하는 것이 좋습니다. 이렇게 하면 전체 Base64 문자열을 한 번에 메모리에 로드하는 것을 피할 수 있습니다.

import java.io.*;
import java.nio.file.*;
import java.util.Base64;

public class Base64ToPdfStreamed {
    public static void main(String[] args) throws Exception {
        // 입력: Base64로 인코딩된 PDF가 포함된 텍스트 파일
        Path in = Paths.get("sample.pdf.b64");

        // 출력: 디코딩된 PDF 파일
        Path out = Paths.get("output.pdf");

        // 입력 스트림 주위에 Base64 디코더 래핑
        try (InputStream b64In = Base64.getMimeDecoder().wrap(Files.newInputStream(in));
             OutputStream pdfOut = Files.newOutputStream(out)) {

            // 디코딩된 바이트를 PDF 출력으로 직접 스트리밍
            b64In.transferTo(pdfOut);
        }
    }
}

설명 이 스트리밍 기반 접근 방식은 전체 문자열을 버퍼링하는 대신 데이터를 즉시 디코딩하므로 메모리 효율성이 더 높습니다. 대용량 파일이나 연속적인 스트림(예: 네트워크 소켓)에 권장되는 방법입니다.

• Base64.getMimeDecoder()는 입력의 줄 바꿈을 허용하는 데 사용됩니다.
• transferTo() 메서드는 수동 버퍼 처리 없이 디코딩된 바이트를 입력에서 출력으로 효율적으로 복사합니다.
• 실제 사용 시에는 파일 접근 오류나 부분 쓰기를 관리하기 위해 예외 처리를 추가하는 것을 고려하십시오.

Java에서 PDF를 Base64로 변환 (JDK만 사용)

PDF를 Base64로 인코딩하는 것도 마찬가지로 간단합니다. 작은 파일의 경우 전체 PDF를 메모리로 읽는 것이 좋습니다.

import java.nio.file.*;
import java.util.Base64;

public class PdfToBase64 {
    public static void main(String[] args) throws Exception {
        // PDF 파일을 바이트 배열로 읽기
        byte[] pdfBytes = Files.readAllBytes(Paths.get("input.pdf"));

        // PDF 바이트를 Base64 문자열로 인코딩
        String base64 = Base64.getEncoder().encodeToString(pdfBytes);

        // Base64 문자열을 텍스트 파일에 쓰기
        Files.writeString(Paths.get("output.pdf.b64"), base64);
    }
}

설명 이 접근 방식은 간단하며 중소 규모 파일에 적합합니다. 전체 PDF 파일이 바이트 배열로 읽혀 단일 Base64 문자열로 인코딩됩니다. 이 문자열은 저장하거나 JSON으로 전송하거나 데이터 URI에 포함할 수 있습니다.

스트리밍 인코더 (대용량 파일을 효율적으로 처리)

대용량 PDF의 경우 스트림으로 직접 인코딩하여 메모리 오버헤드를 피할 수 있습니다.

import java.io.*;
import java.nio.file.*;
import java.util.Base64;

public class PdfToBase64Streamed {
    public static void main(String[] args) throws Exception {
        // 입력: 바이너리 PDF 파일
        try (InputStream pdfIn = Files.newInputStream(Paths.get("input.pdf"));
             // Base64 텍스트 파일을 위한 원시 출력 스트림
             OutputStream rawOut = Files.newOutputStream(Paths.get("output.pdf.b64"));
             // 출력 스트림을 Base64 인코더로 래핑
             OutputStream b64Out = Base64.getEncoder().wrap(rawOut)) {

            // PDF 바이트를 Base64로 인코딩된 출력으로 직접 스트리밍
            pdfIn.transferTo(b64Out);
        }
    }
}

설명 스트리밍 인코더는 모든 것을 메모리에 로드하는 대신 데이터를 점진적으로 인코딩하여 대용량 파일을 효율적으로 처리합니다. Base64.getEncoder().wrap() 메서드는 일반 출력 스트림을 자동으로 Base64 텍스트를 쓰는 스트림으로 변환합니다.

이 디자인은 대용량 PDF, 네트워크 스트림 또는 메모리 부담 없이 동시에 많은 문서를 처리해야 하는 서비스에 더 잘 확장됩니다.

유효성 검사 및 안전 팁

• 데이터 URI 감지: 사용자가 data:application/pdf;base64, 접두사를 보낼 수 있습니다. 디코딩하기 전에 제거하십시오.
• 줄 바꿈: 줄 바꿈된 줄이 포함될 수 있는 텍스트(이메일, 로그)를 디코딩할 때는 Base64.getMimeDecoder()를 사용하십시오.
• 빠른 온전성 검사: 디코딩 후 유효한 PDF의 첫 번째 바이트는 일반적으로 %PDF-로 시작합니다. 조기 실패 감지를 위해 이를 확인할 수 있습니다.
• 문자 인코딩: .b64 파일을 읽고 쓸 때 Base64 텍스트를 UTF-8(또는 US-ASCII)로 처리하십시오.
• 오류 처리: 디코드/인코드 작업을 try/catch로 감싸고 실행 가능한 메시지(예: 크기, 헤더 불일치)를 표시하십시오.

Java에서 Base64 이미지를 PDF로 저장

때때로 이미지(예: PNG 또는 JPEG)를 Base64 문자열로 받고 이를 PDF로 래핑해야 하는 경우가 있습니다. Java의 표준 라이브러리에는 PDF API가 없지만 Free Spire.PDF for Java를 사용하면 간단하게 할 수 있습니다.

Free Spire.PDF for Java를 다운로드하여 프로젝트에 추가하거나 Maven 저장소에서 Free Spire.PDF for Java를 설치할 수 있습니다.

주요 Spire.PDF 개념

• PdfDocument — 하나 이상의 PDF 페이지를 담는 컨테이너입니다.
• PdfPageBase — 그릴 수 있는 페이지를 나타냅니다.
• PdfImage.fromImage() — BufferedImage 또는 스트림을 그릴 수 있는 PDF 이미지로 로드합니다.
• drawImage() — 지정된 좌표와 크기로 이미지를 배치합니다.
• 좌표계 — Spire.PDF는 (0,0)이 왼쪽 상단 모서리인 좌표계를 사용합니다.

예제: Java를 사용하여 Base64 이미지를 PDF로 변환

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.graphics.PdfImage;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.Base64;

public class Base64ImageToPdf {
    public static void main(String[] args) throws Exception {
        // 1) Base64 파일 읽기 및 디코딩 (데이터 URI 접두사가 있는 경우 제거)
        String base64Image = Files.readString(Paths.get("G:/Document/image.b64"), StandardCharsets.UTF_8).trim();
        int comma = base64Image.indexOf(',');
        if (comma > 0 && base64Image.substring(0, comma).toLowerCase().contains("base64")) {
            base64Image = base64Image.substring(comma + 1).trim();
        }
        byte[] imageBytes = Base64.getMimeDecoder().decode(base64Image);

        // 2) PDF 생성 및 이미지 삽입
        PdfDocument pdf = new PdfDocument();
        try (ByteArrayInputStream in = new ByteArrayInputStream(imageBytes)) {
            PdfImage img = PdfImage.fromStream(in);
            pdf.getPageSettings().setWidth(img.getWidth());
            pdf.getPageSettings().setHeight(img.getHeight());
            pdf.getPageSettings().setMargins(0, 0, 0, 0);
            PdfPageBase page = pdf.getPages().add();
            page.getCanvas().drawImage(img, 0, 0);
        }

        // 3) PDF 파일 저장
        pdf.saveToFile("output/image.pdf");
    }
}

다음 예제는 Base64 이미지를 디코딩하여 PDF 페이지에 포함시킵니다. 출력은 다음과 같습니다.

이 워크플로는 Base64로 도착하는 스캔된 문서나 서명을 포함하는 데 이상적입니다.

벡터 그래픽의 경우 Java에서 SVG를 PDF로 변환하는 가이드를 참조할 수도 있습니다.

Base64 PDF 로드, 수정 및 Base64로 다시 저장

많은 API에서 PDF는 Base64로 도착합니다. Spire.PDF를 사용하면 이를 로드하고, 페이지에 그림(텍스트/워터마크)을 그리고, 다시 Base64를 반환할 수 있어 서버리스 함수나 마이크로서비스에 이상적입니다.

여기서 사용되는 주요 Spire.PDF 개념

• PdfDocument.loadFromBytes(byte[]) — 디코딩된 바이트에서 직접 문서를 구성합니다.
• PdfPageBase#getCanvas() — 텍스트, 도형 또는 이미지를 배치할 그리기 표면을 가져옵니다.
• 글꼴 및 브러시 — 예: PdfTrueTypeFont 또는 PdfFont를 통한 내장 글꼴, 색칠을 위한 PdfSolidBrush.
• 메모리에 저장 — pdf.saveToStream(ByteArrayOutputStream)은 원시 바이트를 생성하며, 이를 Base64로 다시 인코딩할 수 있습니다.

예제: Java에서 Base64 PDF 로드, 수정 및 저장

import com.spire.pdf.*;
import com.spire.pdf.graphics.*;

import java.awt.*;
import java.io.*;
import java.util.Base64;

public class EditBase64Pdf {
    public static void main(String[] args) throws Exception {
        String base64Pdf = "..."; // 들어오는 Base64 PDF 문자열

        // 바이트로 디코딩
        byte[] pdfBytes = Base64.getDecoder().decode(base64Pdf);

        // PDF 로드
        PdfDocument pdf = new PdfDocument();
        pdf.loadFromBytes(pdfBytes);

        // 각 페이지에 스탬프 추가
        for (PdfPageBase page : (Iterable) pdf.getPages()) {
            PdfTrueTypeFont font = new PdfTrueTypeFont(new Font("Arial", Font.BOLD, 36));
            PdfSolidBrush brush = new PdfSolidBrush(new PdfRGBColor(Color.BLUE));
            page.getCanvas().drawString("Processed", font, brush, 100, 100);
        }

        // 메모리에 저장하고 다시 Base64로 인코딩
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        pdf.saveToStream(output);
        pdf.close();

        String resultBase64 = Base64.getEncoder().encodeToString(output.toByteArray());
        System.out.println(resultBase64);
    }
}

이 예제에서는 PDF의 각 페이지에 파란색 'Processed' 워터마크를 추가한 다음 다시 Base64로 인코딩합니다. 결과는 다음과 같습니다.

이 왕복(Base64 → PDF → Base64)은 송장 스탬핑이나 클라우드 서비스에서 동적 서명 추가와 같은 문서 파이프라인에 유용합니다.

관련 튜토리얼:
Java에서 PDF 텍스트 추출 | Java에서 PDF 문서 생성

성능 및 메모리 고려 사항

• 스트리밍 대 파일 I/O — Base64를 다룰 때 불필요한 임시 파일을 피하기 위해 ByteArrayInputStream 및 ByteArrayOutputStream을 선호합니다.
• 이미지가 많은 PDF — Base64 이미지 디코딩은 메모리 사용량을 급증시킬 수 있습니다. 포함하기 전에 크기를 조정하거나 압축하는 것을 고려하십시오.
• 대용량 PDF — Spire.PDF는 수 MB의 PDF를 처리하지만 매우 큰 문서의 경우 페이지별 처리를 고려하십시오.
• 서버리스 함수 — Base64 워크플로는 파일 시스템 종속성을 피하고 API 응답을 통해 직접 결과를 반환하기 때문에 잘 맞습니다.

FAQ

Q: JDK만 사용하여 Base64를 PDF로 변환할 수 있나요?

예. Java SE는 Base64 및 파일 I/O 유틸리티를 제공하므로 추가 라이브러리 없이 변환을 처리할 수 있습니다.

Q: 표준 Java 라이브러리로 PDF를 편집할 수 있나요?

아니요. Java SE는 PDF 구조 구문 분석이나 렌더링을 지원하지 않습니다. 편집을 위해서는 Spire.PDF for Java와 같은 전용 라이브러리를 사용하십시오.

Q: Free Spire.PDF for Java로 충분한가요?

예. Free Spire.PDF for Java는 문서 크기가 제한되지만 테스트나 소규모 프로젝트에는 충분합니다.

Q: PDF를 디스크에 저장해야 하나요?

항상 그런 것은 아닙니다. 변환은 종종 API 및 클라우드 앱에 선호되는 스트림을 사용하여 메모리 내에서 실행될 수도 있습니다.

참고 항목

• JavaScript로 HTML을 PDF로 변환
• Java에서 바이트 배열을 PDF로 변환
• Java에서 텍스트를 PDF로 변환
• Java에서 PDF 이미지 추출

Lorsque l'on travaille avec des fichiers PDF en Java, il est souvent nécessaire de convertir entre des données binaires et des formats textuels. L'encodage Base64 permet de représenter le contenu d'un PDF sous forme de texte brut, ce qui est utile lors de la transmission de documents en JSON, de leur envoi via des soumissions de formulaires ou de leur stockage dans des systèmes basés sur du texte. La bibliothèque standard de Java fournit java.util.Base64, ce qui facilite la mise en œuvre des conversions Base64 vers PDF et PDF vers Base64 sans dépendances supplémentaires.

Dans ce tutoriel, nous explorerons comment gérer ces conversions en utilisant uniquement le JDK, ainsi que comment travailler avec des images Base64 et les intégrer dans des PDF. Pour des opérations plus avancées, telles que la modification d'un PDF reçu en Base64 et son réexportation, nous démontrerons l'utilisation de Free Spire.PDF for Java.

Table des matières

• Convertir Base64 en PDF en Java (JDK uniquement)
• Convertir PDF en Base64 en Java (JDK uniquement)
• Conseils de validation et de sécurité
• Enregistrer des images Base64 en PDF en Java
• Charger un PDF Base64, le modifier et le réenregistrer en Base64
• Considérations sur les performances et la mémoire
• FAQ

Convertir Base64 en PDF en Java (JDK uniquement)

L'approche la plus simple consiste à lire une chaîne Base64 en mémoire, à supprimer les préfixes facultatifs (tels que data:application/pdf;base64,), puis à la décoder en PDF. Cela fonctionne bien pour les fichiers de petite à moyenne taille.

import java.nio.file.*;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Base64ToPdf {
    public static void main(String[] args) throws Exception {
        // Lire le texte Base64 d'un fichier (ou de toute autre source)
        String base64 = Files.readString(Paths.get("sample.pdf.b64"), StandardCharsets.UTF_8);

        // Supprimer les préfixes d'URI de données courants s'ils sont présents
        base64 = stripDataPrefix(base64);

        // Décoder le Base64 en octets PDF bruts
        // Le décodeur MIME tolère les sauts de ligne et le texte enveloppé
        byte[] pdfBytes = Base64.getMimeDecoder().decode(base64);

        // Écrire les octets décodés dans un fichier PDF
        Files.write(Paths.get("output.pdf"), pdfBytes);
    }

    /** Utilitaire pour supprimer le préfixe "data:application/pdf;base64,", s'il est inclus */
    private static String stripDataPrefix(String src) {
        String s = src.trim();
        int comma = s.indexOf(',');
        if (comma > 0 && s.substring(0, comma).toLowerCase().contains("base64")) {
            return s.substring(comma + 1).trim();
        }
        return s;
    }
}

Explication Cet exemple est simple et fiable pour le contenu Base64 qui tient confortablement en mémoire. Le Base64.getMimeDecoder() est choisi car il gère avec élégance les sauts de ligne, qui sont courants dans le texte Base64 exporté depuis des systèmes de messagerie ou des API. Si vous savez que votre chaîne Base64 ne contient aucun saut de ligne, vous pouvez également utiliser Base64.getDecoder().

Assurez-vous de supprimer tout préfixe d'URI de données (data:application/pdf;base64,) avant de décoder, car il ne fait pas partie de la charge utile Base64. La méthode d'aide stripDataPrefix() le fait automatiquement.

Variante en streaming (pas de chaîne complète en mémoire)

Pour les gros PDF, il est préférable de traiter le Base64 en mode streaming. Cela évite de charger toute la chaîne Base64 en mémoire en une seule fois.

import java.io.*;
import java.nio.file.*;
import java.util.Base64;

public class Base64ToPdfStreamed {
    public static void main(String[] args) throws Exception {
        // Entrée : fichier texte contenant un PDF encodé en Base64
        Path in = Paths.get("sample.pdf.b64");

        // Sortie : fichier PDF décodé
        Path out = Paths.get("output.pdf");

        // Envelopper le décodeur Base64 autour du flux d'entrée
        try (InputStream b64In = Base64.getMimeDecoder().wrap(Files.newInputStream(in));
             OutputStream pdfOut = Files.newOutputStream(out)) {

            // Transférer les octets décodés directement vers la sortie PDF
            b64In.transferTo(pdfOut);
        }
    }
}

Explication Cette approche basée sur le streaming est plus efficace en termes de mémoire, car elle décode les données à la volée plutôt que de mettre en mémoire tampon la chaîne entière. C'est la méthode recommandée pour les fichiers volumineux ou les flux continus (par exemple, les sockets réseau).

• Base64.getMimeDecoder() est utilisé pour tolérer les sauts de ligne dans l'entrée.
• La méthode transferTo() copie efficacement les octets décodés de l'entrée vers la sortie sans gestion manuelle de la mémoire tampon.
• Dans un cas d'utilisation réel, envisagez d'ajouter une gestion des exceptions pour gérer les erreurs d'accès aux fichiers ou les écritures partielles.

Convertir PDF en Base64 en Java (JDK uniquement)

Encoder un PDF en Base64 est tout aussi simple. Pour les fichiers plus petits, lire l'intégralité du PDF en mémoire convient parfaitement :

import java.nio.file.*;
import java.util.Base64;

public class PdfToBase64 {
    public static void main(String[] args) throws Exception {
        // Lire le fichier PDF dans un tableau d'octets
        byte[] pdfBytes = Files.readAllBytes(Paths.get("input.pdf"));

        // Encoder les octets du PDF en une chaîne Base64
        String base64 = Base64.getEncoder().encodeToString(pdfBytes);

        // Écrire la chaîne Base64 dans un fichier texte
        Files.writeString(Paths.get("output.pdf.b64"), base64);
    }
}

Explication Cette approche est simple et fonctionne bien pour les fichiers de petite ou moyenne taille. L'intégralité du fichier PDF est lue dans un tableau d'octets et encodée en une seule chaîne Base64. Cette chaîne peut être stockée, transmise en JSON ou intégrée dans une URI de données.

Encodeur en streaming (gère efficacement les gros fichiers)

Pour les gros PDF, vous pouvez éviter la surcharge de mémoire en encodant directement en tant que flux :

import java.io.*;
import java.nio.file.*;
import java.util.Base64;

public class PdfToBase64Streamed {
    public static void main(String[] args) throws Exception {
        // Entrée : fichier PDF binaire
        try (InputStream pdfIn = Files.newInputStream(Paths.get("input.pdf"));
             // Flux de sortie brut pour le fichier texte Base64
             OutputStream rawOut = Files.newOutputStream(Paths.get("output.pdf.b64"));
             // Envelopper le flux de sortie avec l'encodeur Base64
             OutputStream b64Out = Base64.getEncoder().wrap(rawOut)) {

            // Transférer les octets du PDF directement dans la sortie encodée en Base64
            pdfIn.transferTo(b64Out);
        }
    }
}

Explication L'encodeur en streaming gère efficacement les fichiers volumineux en encodant les données de manière incrémentielle au lieu de tout charger en mémoire. La méthode Base64.getEncoder().wrap() transforme un flux de sortie ordinaire en un flux qui écrit automatiquement du texte Base64.

Cette conception s'adapte mieux aux PDF volumineux, aux flux réseau ou aux services qui doivent gérer de nombreux documents simultanément sans subir de pression sur la mémoire.

Conseils de validation et de sécurité

• Détecter les URI de données : les utilisateurs peuvent envoyer des préfixes data:application/pdf;base64,. Supprimez-les avant de décoder.
• Sauts de ligne : lors du décodage de texte pouvant contenir des lignes enveloppées (e-mails, journaux), utilisez Base64.getMimeDecoder().
• Vérification rapide : après le décodage, les premiers octets d'un PDF valide commencent généralement par %PDF-. Vous pouvez l'affirmer pour une détection précoce des défaillances.
• Encodage des caractères : traitez le texte Base64 en UTF-8 (ou US-ASCII) lors de la lecture/écriture de fichiers .b64.
• Gestion des erreurs : enveloppez le décodage/encodage dans des blocs try/catch et affichez des messages exploitables (par exemple, taille, discordance d'en-tête).

Enregistrer des images Base64 en PDF en Java

Parfois, vous recevez des images (par exemple, PNG ou JPEG) sous forme de chaînes Base64 et vous devez les encapsuler dans un PDF. Bien que la bibliothèque standard de Java ne dispose pas d'API PDF, Free Spire.PDF for Java rend cela simple.

Vous pouvez télécharger Free Spire.PDF for Java et l'ajouter à votre projet ou installer Free Spire.PDF for Java depuis le référentiel Maven.

Concepts clés de Spire.PDF

• PdfDocument — le conteneur pour une ou plusieurs pages PDF.
• PdfPageBase — représente une page sur laquelle vous pouvez dessiner.
• PdfImage.fromImage() — charge une BufferedImage ou un flux dans une image PDF dessinable.
• drawImage() — place l'image aux coordonnées et à la taille spécifiées.
• Système de coordonnées — Spire.PDF utilise un système de coordonnées où (0,0) est le coin supérieur gauche.

Exemple : Convertir une image Base64 en PDF en utilisant Java

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.graphics.PdfImage;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.Base64;

public class Base64ImageToPdf {
    public static void main(String[] args) throws Exception {
        // 1) Lire le fichier Base64 et décoder (supprimer le préfixe de l'URI de données s'il existe)
        String base64Image = Files.readString(Paths.get("G:/Document/image.b64"), StandardCharsets.UTF_8).trim();
        int comma = base64Image.indexOf(',');
        if (comma > 0 && base64Image.substring(0, comma).toLowerCase().contains("base64")) {
            base64Image = base64Image.substring(comma + 1).trim();
        }
        byte[] imageBytes = Base64.getMimeDecoder().decode(base64Image);

        // 2) Créer un PDF et y insérer l'image
        PdfDocument pdf = new PdfDocument();
        try (ByteArrayInputStream in = new ByteArrayInputStream(imageBytes)) {
            PdfImage img = PdfImage.fromStream(in);
            pdf.getPageSettings().setWidth(img.getWidth());
            pdf.getPageSettings().setHeight(img.getHeight());
            pdf.getPageSettings().setMargins(0, 0, 0, 0);
            PdfPageBase page = pdf.getPages().add();
            page.getCanvas().drawImage(img, 0, 0);
        }

        // 3) Enregistrer le fichier PDF
        pdf.saveToFile("output/image.pdf");
    }
}

L'exemple suivant décode une image Base64 et l'intègre dans une page PDF. La sortie ressemble à ceci :

Ce flux de travail est idéal pour intégrer des documents numérisés ou des signatures qui arrivent en Base64.

Pour les graphiques vectoriels, vous pouvez également consulter notre guide sur la conversion de SVG en PDF en Java.

Charger un PDF Base64, le modifier et le réenregistrer en Base64

Dans de nombreuses API, un PDF arrive en Base64. Avec Spire.PDF, vous pouvez le charger, dessiner sur les pages (texte/filigranes) et renvoyer à nouveau du Base64 — idéal pour les fonctions sans serveur ou les microservices.

Concepts clés de Spire.PDF utilisés ici

• PdfDocument.loadFromBytes(byte[]) — construit un document directement à partir d'octets décodés.
• PdfPageBase#getCanvas() — obtient une surface de dessin pour placer du texte, des formes ou des images.
• Polices et pinceaux — par ex., PdfTrueTypeFont ou polices intégrées via PdfFont, avec PdfSolidBrush pour la coloration.
• Enregistrement en mémoire — pdf.saveToStream(ByteArrayOutputStream) produit des octets bruts, que vous pouvez réencoder avec Base64.

Exemple : Charger, modifier et enregistrer un PDF Base64 en Java

import com.spire.pdf.*;
import com.spire.pdf.graphics.*;

import java.awt.*;
import java.io.*;
import java.util.Base64;

public class EditBase64Pdf {
    public static void main(String[] args) throws Exception {
        String base64Pdf = "..."; // chaîne PDF en Base64 entrante

        // Décoder en octets
        byte[] pdfBytes = Base64.getDecoder().decode(base64Pdf);

        // Charger le PDF
        PdfDocument pdf = new PdfDocument();
        pdf.loadFromBytes(pdfBytes);

        // Ajouter un tampon sur chaque page
        for (PdfPageBase page : (Iterable) pdf.getPages()) {
            PdfTrueTypeFont font = new PdfTrueTypeFont(new Font("Arial", Font.BOLD, 36));
            PdfSolidBrush brush = new PdfSolidBrush(new PdfRGBColor(Color.BLUE));
            page.getCanvas().drawString("Processed", font, brush, 100, 100);
        }

        // Enregistrer en mémoire et réencoder en Base64
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        pdf.saveToStream(output);
        pdf.close();

        String resultBase64 = Base64.getEncoder().encodeToString(output.toByteArray());
        System.out.println(resultBase64);
    }
}

Dans cet exemple, un filigrane bleu « Processed » est ajouté à chaque page du PDF avant de le réencoder en Base64. Le résultat ressemble à ceci :

Ce cycle (Base64 → PDF → Base64) est utile pour les pipelines de documents, tels que l'estampillage de factures ou l'ajout de signatures dynamiques dans un service cloud.

Tutoriels associés :
Extraire du texte d'un PDF en Java | Créer des documents PDF en Java

Considérations sur les performances et la mémoire

• Streaming vs. E/S de fichiers — lors du traitement de Base64, préférez ByteArrayInputStream et ByteArrayOutputStream pour éviter les fichiers temporaires inutiles.
• PDF riches en images — le décodage d'images Base64 peut augmenter considérablement l'utilisation de la mémoire ; envisagez de les redimensionner ou de les compresser avant de les intégrer.
• Gros PDF — Spire.PDF gère les PDF de plusieurs Mo, mais pour les documents très volumineux, envisagez un traitement page par page.
• Fonctions sans serveur — les flux de travail Base64 s'intègrent bien car vous évitez la dépendance au système de fichiers et renvoyez les résultats directement via les réponses de l'API.

FAQ

Q : Puis-je convertir Base64 en PDF en utilisant uniquement le JDK ?

Oui. Java SE fournit des utilitaires Base64 et d'E/S de fichiers, vous pouvez donc gérer la conversion sans bibliothèques supplémentaires.

Q : Puis-je modifier un PDF avec la bibliothèque standard de Java ?

Non. Java SE ne prend pas en charge l'analyse de la structure ou le rendu des PDF. Pour l'édition, utilisez une bibliothèque dédiée telle que Spire.PDF for Java.

Q : Free Spire.PDF for Java est-il suffisant ?

Oui. La version gratuite de Spire.PDF for Java est limitée en taille de document, mais suffisante pour les tests ou les projets à petite échelle.

Q : Dois-je enregistrer les PDF sur le disque ?

Pas toujours. La conversion peut également s'exécuter en mémoire à l'aide de flux, ce qui est souvent préférable pour les API et les applications cloud.

Voir aussi

• Convertir HTML en PDF avec JavaScript
• Convertir un tableau d'octets en PDF en Java
• Convertir du texte en PDF en Java
• Extraire des images d'un PDF en Java