Como preencher um formulário PDF em Java (Tutorial)

O IronPDF permite que desenvolvedores Java preencham formulários PDF programaticamente, carregando PDFs existentes, acessando os campos do formulário com o método getForm(), definindo valores com setFieldValue() e salvando o documento preenchido - perfeito para automatizar o processamento de documentos em aplicações comerciais.

Início rápido: Preencha o formulário PDF em Java

```java {title="FillPDFForm.java"} // 1. Adicione a dependência do IronPDF ao seu projeto Maven // 2. Carregue seu formulário em PDF PdfDocument form = PdfDocument.fromFile("form.pdf"); // 3. Preencha os campos do formulário form.getForm().setFieldValue("firstname", "John"); // 4. Salve o PDF preenchido form.saveAs(Paths.get("filled_form.pdf")); // 5. Execute sua aplicação Java para gerar o PDF preenchido.

Este artigo aborda o preenchimento programático de formulários PDF em Java. Um caso de uso comum é quando as interfaces de usuário dos aplicativos coletam dados do usuário que precisam ser convertidos para o formato PDF para arquivamento.

Após coletar os dados inseridos pelo usuário, os aplicativos precisam criar formulários em PDF programaticamente. Esses documentos preenchidos são salvos para uso futuro ou modificados. Existem diversas bibliotecas Java para trabalhar com PDFs, incluindo PDFBox, iText7 e IronPDF. Este artigo explica como usar o IronPDF para preencher formulários interativos. Para desenvolvedores que trabalham em aplicativos empresariais que exigem automação de documentos, o IronPDF fornece ferramentas para [criar formulários PDF](https://ironpdf.com/java/how-to/create-forms/) e gerenciar dados de formulários.

<div class="hsg-featured-snippet">
<h3>Como preencher um formulário PDF em Java</h3>
<ol>
<li><a class="js-modal-open" data-modal-id="download-modal" href="#download-modal">Instale a biblioteca Java para preencher formulários PDF.</a></li>
<li>Carregar um PDF existente que contenha campos de formulário.</li>
<li>Selecione o campo do formulário do PDF carregado com o método `getForm`</li>
<li>Utilize o método `setFieldValue` para definir o valor de um campo de formulário específico.</li>
<li>Exportar o documento PDF</li>
</ol>
</div>

## O que é o IronPDF e por que usá-lo para formulários em PDF?

IronPDF é uma [biblioteca Java para criação e edição de PDFs](https://ironpdf.com/java/) , que permite aos desenvolvedores criar, editar e manipular documentos PDF em aplicações Java. A biblioteca é compatível com Java e se integra a qualquer projeto baseado em Java com o mínimo de código.

O IronPDF oferece recursos como manipulação de texto e imagem, segurança de documentos e assinatura digital. Com o IronPDF, os desenvolvedores podem gerar documentos PDF de forma eficiente. A biblioteca também oferece suporte à [compressão de PDF](https://ironpdf.com/java/how-to/compress-pdf-java-tutorial/) para otimizar o tamanho dos arquivos e [os recursos de impressão](https://ironpdf.com/java/how-to/java-print-pdf-tutorial/) para integração com impressoras físicas.

Para trabalhar com formulários, o IronPDF mantém a formatação do documento, ao mesmo tempo que fornece acesso programático a todos os elementos do formulário. Isso o torna adequado para processamento em lote de formulários, preenchimento automático de campos com informações do banco de dados ou integração do preenchimento de formulários em fluxos de trabalho Java existentes. A API da biblioteca permite que você comece a preencher formulários PDF com o mínimo de código, como mostrado em nossos [exemplos de dados de formulário](https://ironpdf.com/java/examples/form-data/) .

## Como preencher formulários PDF usando o IronPDF?

Vamos examinar como preencher um formulário PDF programaticamente usando esta biblioteca Java para PDF. O IronPDF é compatível com diversos tipos de campos de formulário, incluindo caixas de texto, caixas de seleção, botões de opção e listas suspensas. A biblioteca preserva a formatação e garante que os formulários preenchidos permaneçam em conformidade com os padrões PDF.

### Como instalo o IronPDF no meu projeto Maven?

Para instalar o IronPDF Java via Maven:

1. Abra o arquivo `pom.xml` em seu projeto.  
2. Add the following dependencies within the ``<dependencies></dependencies>`` tag.  
3. Salve o arquivo `pom.xml` e execute `mvn install` no diretório do seu projeto. Este comando instala o IronPDF Java e suas dependências. Consulte a [página do repositório central da Sonatype para IronPDF](https://central.sonatype.com/artifact/com.ironsoftware/ironpdf/2023.1.1) para obter mais informações.

Para obter orientações detalhadas sobre a configuração em diferentes ambientes, consulte nossa [visão geral de primeiros passos](https://ironpdf.com/java/docs/) . Para implantações em nuvem, fornecemos guias para [implantação na AWS](https://ironpdf.com/java/get-started/aws/) , [Azure Functions](https://ironpdf.com/java/get-started/azure/) e [Google Cloud](https://ironpdf.com/java/get-started/google-cloud/) .

Agora você pode usar o IronPDF com seu código Java.

### Como preencher documentos PDF programaticamente com Java?

O código a seguir demonstra como usar o IronPDF para [criar e preencher formulários PDF com Java](https://ironpdf.com/java/examples/form-data/) usando marcação HTML. O código importa as classes necessárias do IronPDF e usa o método `Paths.get` para especificar onde salvar o formulário PDF resultante. Essa abordagem é útil quando você precisa [converter HTML em PDF](https://ironpdf.com/java/tutorials/html-to-pdf/) , mantendo a funcionalidade do formulário.

```java
import com.ironsoftware.ironpdf.PdfDocument;  
import com.ironsoftware.ironpdf.render.ChromePdfRenderOptions;  
import java.io.IOException;  
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class App {

    // Main method to execute the program
    public static void main(String[] args) throws IOException {
        // Specify where the output PDF will be saved
        Path outputLocation = Paths.get("assets/BasicForm.pdf");  

        // HTML string which represents the form to be converted to PDF
        String formHTML = "<html>"
            + "<body>"
            + "<h2>Editable PDF Form</h2>"
            + "<form>"
            + "First name: <br> <input type='text' name='firstname' value=''> <br>"
            + "Last name: <br> <input type='text' name='lastname' value=''>"
            + "</form>"
            + "</body>"
            + "</html>";  

        // Set up PDF render options to create forms from HTML
        ChromePdfRenderOptions renderOptions = new ChromePdfRenderOptions();  
        renderOptions.setCreatePdfFormsFromHtml(true);  

        // Render the HTML as a PDF and save it to the specified location
        PdfDocument.renderHtmlAsPdf(formHTML, renderOptions).saveAs(outputLocation);

        // #2 Use Case: Writing Values to the PDF Form  
        PdfDocument form = PdfDocument.fromFile(outputLocation);  

        // Set the value of the firstname input field  
        form.getForm().setFieldValue("firstname", "Minnie");  

        // Set the value of the lastname input field  
        form.getForm().setFieldValue("lastname", "Mouse");  

        // Save the changes to the PDF Form  
        form.saveAs(Paths.get("assets/BasicForm_Filled.pdf"));
    }
}

O primeiro bloco cria um formulário PDF convertendo a marcação de formulário HTML usando o método PdfDocument.renderHtmlAsPdf. O objeto ChromePdfRenderOptions define a propriedade createPdfFormsFromHtml como verdadeira, tornando o formulário HTML editável. O PDF resultante é salvo no local especificado usando o método saveAs. Para mais opções de renderização, consulte nosso guia sobre configurações de geração de PDF .

O segundo bloco demonstra como preencher o formulário PDF criado. O método PdfDocument.fromFile carrega o formulário PDF a partir do caminho do arquivo. O método getForm acessa os campos do formulário, e o método setFieldValue define os valores para os campos de entrada firstname e lastname. As alterações são salvas em um novo arquivo usando o método saveAs.