Cómo rellenar un formulario PDF en Java (Tutorial)
IronPDF permite a los desarrolladores de Java rellenar formularios PDF de forma programada cargando PDFs existentes, accediendo a campos de formulario con getForm(), estableciendo valores con setFieldValue() y guardando el documento relleno. Esto hace que la automatización del procesamiento de documentos en aplicaciones empresariales sea sencilla.
Inicio rápido: Completar formulario PDF en Java
```java {title="FillPDFForm.java"} //:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/quickstart.java // 1. Añada la dependencia IronPDF a su proyecto Maven // 2. Cargue su formulario PDF Formulario PdfDocument = PdfDocument.fromFile("formulario.pdf"); // 3. Rellenar campos de formulario form.getForm().setFieldValue("nombre", "Juan"); // 4. Guardar el PDF rellenado form.saveAs(Paths.get("formulario_relleno.pdf"));
<div class="hsg-featured-snippet">
<h2>Cómo Completar un Formulario PDF en Java</h2>
<ol>
<li><a class="js-modal-open" data-modal-id="download-modal" href="#download-modal">Instale la biblioteca IronPDF for Java a través de Maven</a></li>
<li>Cargue el PDF existente que contiene campos de formulario utilizando <code>PdfDocument.fromFile()</code></li>
<li>Acceda al formulario con el método <code>getForm()</code></li>
<li>Establezca los valores de los campos utilizando <code>setFieldValue(fieldName, value)</code></li>
<li>Guarde el documento completo con <code>saveAs()</code></li>
</ol>
</div>
Este artículo cubre cómo llenar formularios PDF programáticamente en Java. Un escenario común es cuando una aplicación recoge datos de usuario a través de una interfaz de usuario que debe ser preservada en formato PDF para archivado, cumplimiento o procesamiento posterior.
Después de capturar la entrada del usuario, las aplicaciones a menudo necesitan inyectar esos datos directamente en plantillas PDF preexistentes. Múltiples bibliotecas Java PDF manejan esta tarea, incluyendo [Apache PDFBox](https://pdfbox.apache.org), iText e IronPDF. Esta guía explica cómo utilizar IronPDF para completar formularios interactivos con campos de texto, casillas de verificación, botones de radio y listas desplegables. Para los desarrolladores que construyen flujos de trabajo de documentos relacionados, consulte la guía sobre [crear formularios PDF desde cero en Java](https://ironpdf.com/java/how-to/create-forms/).
## ¿Qué es IronPDF for Java?
IronPDF es una [biblioteca Java PDF](https://ironpdf.com/java/) para crear, editar y manipular documentos PDF. Se integra en cualquier proyecto basado en Maven y expone una API clara que hace posibles las tareas comunes de PDF con el mínimo código repetitivo.
La biblioteca cubre todo el ciclo de vida del PDF: renderizado de HTML a PDF, lectura y escritura de datos de formularios, adición de firmas digitales, aplicación de configuraciones de seguridad, compresión de documentos e impresión. Para trabajar específicamente con formularios, IronPDF ofrece acceso programático a cada tipo de campo en un documento PDF mientras preserva el formato original. Esto lo hace adecuado para el procesamiento de formularios por lotes, pre-poblar plantillas con registros de bases de datos o conectar el llenado de formularios a un flujo de trabajo Java más grande. Consulte la [referencia API Java de IronPDF](https://ironpdf.com/java/object-reference/api/) para obtener una lista completa de clases y métodos disponibles.
## ¿Cómo instalo IronPDF en un proyecto Maven?
Agrega el siguiente bloque de dependencias a tu archivo `pom.xml` para instalar IronPDF for Java.
Abre `pom.xml` e inserta la dependencia dentro del elemento `<dependencies>`, luego ejecuta `mvn install` para descargar la biblioteca. Las versiones disponibles están listadas en [Maven Central](https://search.maven.org/artifact/com.ironsoftware/ironpdf).
```xml
//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/maven-dependency.xml
<dependency>
<groupId>com.ironsoftware</groupId>
<artifactId>ironpdf</artifactId>
<version>2024.9.1</version>
</dependency>Después de la instalación, importa com.ironsoftware.ironpdf.PdfDocument y com.ironsoftware.ironpdf.render.ChromePdfRenderOptions en tu clase Java para acceder a la API de relleno de formularios. Para orientación en la implementación en plataformas en la nube, consulte las guías para AWS, Azure, y Google Cloud.
IronPdf.licenseKey antes de la primera llamada a PdfDocument para evitar retrasos en la verificación de la licencia en tiempo de ejecución.¿Cómo creo y completo un formulario PDF usando HTML en Java?
La manera más confiable de producir un PDF rellenable, estructurado de manera consistente, es definir el formulario en HTML y renderizarlo con IronPDF. La biblioteca convierte elementos <input> HTML directamente en campos de formulario PDF interactivos.
El siguiente código crea un formulario PDF de dos campos a partir de una cadena HTML y luego completa ambos campos:
//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/create-and-fill-form.java
import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.render.ChromePdfRenderOptions;
import java.io.IOException;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) throws IOException {
// Define an HTML form with two text input fields
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>";
// Enable HTML-to-form-field conversion during rendering
ChromePdfRenderOptions renderOptions = new ChromePdfRenderOptions();
renderOptions.setCreatePdfFormsFromHtml(true);
// Render HTML to PDF and save the blank template
PdfDocument.renderHtmlAsPdf(formHTML, renderOptions)
.saveAs(Paths.get("assets/BasicForm.pdf"));
// Load the template and fill in field values
PdfDocument form = PdfDocument.fromFile(Paths.get("assets/BasicForm.pdf"));
form.getForm().setFieldValue("firstname", "Minnie");
form.getForm().setFieldValue("lastname", "Mouse");
// Save the completed form to a new file
form.saveAs(Paths.get("assets/BasicForm_Filled.pdf"));
}
}//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/create-and-fill-form.java
import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.render.ChromePdfRenderOptions;
import java.io.IOException;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) throws IOException {
// Define an HTML form with two text input fields
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>";
// Enable HTML-to-form-field conversion during rendering
ChromePdfRenderOptions renderOptions = new ChromePdfRenderOptions();
renderOptions.setCreatePdfFormsFromHtml(true);
// Render HTML to PDF and save the blank template
PdfDocument.renderHtmlAsPdf(formHTML, renderOptions)
.saveAs(Paths.get("assets/BasicForm.pdf"));
// Load the template and fill in field values
PdfDocument form = PdfDocument.fromFile(Paths.get("assets/BasicForm.pdf"));
form.getForm().setFieldValue("firstname", "Minnie");
form.getForm().setFieldValue("lastname", "Mouse");
// Save the completed form to a new file
form.saveAs(Paths.get("assets/BasicForm_Filled.pdf"));
}
}El primer bloque usa ChromePdfRenderOptions con setCreatePdfFormsFromHtml(true) para indicar al motor de renderizado que trate los elementos <input> HTML como campos de formulario PDF activos en lugar de texto estático. El PDF renderizado se guarda como una plantilla reutilizable. El segundo bloque carga esa plantilla, llama a getForm().setFieldValue() para cada campo por su nombre y escribe el resultado en un archivo de salida separado, dejando la plantilla original intacta para uso futuro.
¿Qué aspecto tiene el resultado?
La primera renderización produce un PDF con dos campos de texto vacíos, completamente editables en cualquier lector de PDF.
Después de que setFieldValue() se ejecuta, ambos campos se llenan con los datos proporcionados:
¿Cómo completo un formulario PDF existente que no creé?
Muchos flujos de trabajo del mundo real reciben plantillas PDF de terceros (formularios gubernamentales, documentos de seguros, contratos de proveedores) que ya contienen campos nombrados. Cargar y rellenar estos es el mismo proceso: usa PdfDocument.fromFile() para cargar el documento, luego getForm().setFieldValue() para establecer cada campo por su nombre.
//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/fill-existing-form.java
import com.ironsoftware.ironpdf.PdfDocument;
import java.io.IOException;
import java.nio.file.Paths;
public class FillExistingForm {
public static void main(String[] args) throws IOException {
// Load a third-party fillable PDF
PdfDocument form = PdfDocument.fromFile(Paths.get("templates/application.pdf"));
// Set text field values by field name
form.getForm().setFieldValue("applicant_name", "Jane Smith");
form.getForm().setFieldValue("date_of_birth", "1985-06-14");
form.getForm().setFieldValue("reference_number", "REF-2024-00421");
// Save the completed application
form.saveAs(Paths.get("output/application_filled.pdf"));
}
}//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/fill-existing-form.java
import com.ironsoftware.ironpdf.PdfDocument;
import java.io.IOException;
import java.nio.file.Paths;
public class FillExistingForm {
public static void main(String[] args) throws IOException {
// Load a third-party fillable PDF
PdfDocument form = PdfDocument.fromFile(Paths.get("templates/application.pdf"));
// Set text field values by field name
form.getForm().setFieldValue("applicant_name", "Jane Smith");
form.getForm().setFieldValue("date_of_birth", "1985-06-14");
form.getForm().setFieldValue("reference_number", "REF-2024-00421");
// Save the completed application
form.saveAs(Paths.get("output/application_filled.pdf"));
}
}Para descubrir los nombres de los campos en un PDF existente, abra el documento en Adobe Acrobat Reader, haga clic derecho en cualquier campo y seleccione "Propiedades". El nombre del campo aparece en la pestaña General. Alternativamente, itere sobre todos los campos programáticamente:
//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/list-form-fields.java
import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.form.FormField;
import java.nio.file.Paths;
public class ListFormFields {
public static void main(String[] args) throws Exception {
PdfDocument form = PdfDocument.fromFile(Paths.get("templates/application.pdf"));
// Print the name and type of every form field
for (FormField field : form.getForm().getFields()) {
System.out.println("Field: " + field.getName()
+ " | Type: " + field.getType());
}
}
}//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/list-form-fields.java
import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.form.FormField;
import java.nio.file.Paths;
public class ListFormFields {
public static void main(String[] args) throws Exception {
PdfDocument form = PdfDocument.fromFile(Paths.get("templates/application.pdf"));
// Print the name and type of every form field
for (FormField field : form.getForm().getFields()) {
System.out.println("Field: " + field.getName()
+ " | Type: " + field.getType());
}
}
}Imprimir los nombres de los campos antes de escribir datos previene que setFieldValue() falle silenciosamente en un nombre que no coincide. Los nombres de los campos en documentos PDF son sensibles a mayúsculas y minúsculas, por lo que "firstname" y "FirstName" son tratados como campos diferentes.
getForm().getFields() de IronPDF devuelve una lista de objetos FormField. Cada uno expone getName(), getType() y getValue(). Estos son útiles al construir rutinas de relleno de formularios dinámicos que leen nombres de campos de una fuente de datos externa, como una base de datos o un archivo CSV.¿Cómo completo casillas de verificación y botones de opción en Java?
Los campos de texto aceptan valores de cadena directamente, pero los casillas de verificación y los botones de opción requieren valores exportados específicos que el PDF define en el momento de la creación. Usa setFieldValue() con la cadena de valor de exportación correcta para cada campo.
//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/fill-checkboxes-radio.java
import com.ironsoftware.ironpdf.PdfDocument;
import java.nio.file.Paths;
public class FillCheckboxesAndRadio {
public static void main(String[] args) throws Exception {
PdfDocument form = PdfDocument.fromFile(Paths.get("templates/survey.pdf"));
// Check a checkbox by setting its exported value (often "Yes" or "On")
form.getForm().setFieldValue("agree_terms", "Yes");
// Select a radio button option by its exported value
form.getForm().setFieldValue("preferred_contact", "email");
form.saveAs(Paths.get("output/survey_filled.pdf"));
}
}//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/fill-checkboxes-radio.java
import com.ironsoftware.ironpdf.PdfDocument;
import java.nio.file.Paths;
public class FillCheckboxesAndRadio {
public static void main(String[] args) throws Exception {
PdfDocument form = PdfDocument.fromFile(Paths.get("templates/survey.pdf"));
// Check a checkbox by setting its exported value (often "Yes" or "On")
form.getForm().setFieldValue("agree_terms", "Yes");
// Select a radio button option by its exported value
form.getForm().setFieldValue("preferred_contact", "email");
form.saveAs(Paths.get("output/survey_filled.pdf"));
}
}El valor de exportación para una casilla de verificación es típicamente "Yes", "On", o una cadena personalizada establecida por el autor del formulario. Para grupos de botones de opción, cada opción en el grupo comparte el mismo nombre de campo pero tiene un valor de exportación único. Use la técnica de listado de campos de la sección anterior para confirmar los valores de exportación exactos antes de escribir rutinas de llenado automatizado.
setFieldValue() no parece marcar una casilla de verificación o seleccionar un botón de opción, probablemente la cadena del valor de exportación es incorrecta. Enumera el campo con getFields() e inspecciona getValue() en una copia revisada manualmente del PDF para recuperar la cadena correcta.¿Cómo completo listas desplegables en un formulario PDF usando Java?
Los campos de lista desplegable (también llamados campos de cuadro combinado) usan la misma API que los campos de texto. Pasa el valor de exportación de la opción como una cadena a setFieldValue(). El valor de exportación es típicamente el texto de la opción visible a menos que el autor del formulario haya definido un valor subyacente separado.
//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/fill-dropdown.java
import com.ironsoftware.ironpdf.PdfDocument;
import java.nio.file.Paths;
public class FillDropdown {
public static void main(String[] args) throws Exception {
PdfDocument form = PdfDocument.fromFile(Paths.get("templates/registration.pdf"));
// Set a dropdown/combo box field to a specific option
form.getForm().setFieldValue("country", "United States");
// Set a list box field (multi-select may require comma-separated values)
form.getForm().setFieldValue("subscription_tier", "Professional");
form.saveAs(Paths.get("output/registration_filled.pdf"));
}
}//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/fill-dropdown.java
import com.ironsoftware.ironpdf.PdfDocument;
import java.nio.file.Paths;
public class FillDropdown {
public static void main(String[] args) throws Exception {
PdfDocument form = PdfDocument.fromFile(Paths.get("templates/registration.pdf"));
// Set a dropdown/combo box field to a specific option
form.getForm().setFieldValue("country", "United States");
// Set a list box field (multi-select may require comma-separated values)
form.getForm().setFieldValue("subscription_tier", "Professional");
form.saveAs(Paths.get("output/registration_filled.pdf"));
}
}Cuando el valor de exportación del menú desplegable difiere de la etiqueta visible, utiliza getFields() para inspeccionar las opciones disponibles del campo. Pasar un valor que no coincide con ninguna opción en la definición del campo deja la selección sin cambios sin lanzar una excepción, por lo que validar los valores de exportación antes de una ejecución por lotes evita la pérdida silenciosa de datos.
FormField a FormComboBoxField y llama getOptions(). Esto devuelve la lista de valores de exportación válidos para esa lista desplegable.¿Cómo aplano un formulario PDF completo en Java?
Aplanar convierte todos los campos de formulario en contenido estático, no editable. Esto previene que los destinatarios alteren los datos enviados y es necesario para muchos casos de uso de archivo y cumplimiento. IronPDF admite el aplanado de formularios como parte de sus capacidades de manipulación PDF.
//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/flatten-form.java
import com.ironsoftware.ironpdf.PdfDocument;
import java.nio.file.Paths;
public class FlattenForm {
public static void main(String[] args) throws Exception {
PdfDocument form = PdfDocument.fromFile(Paths.get("assets/BasicForm_Filled.pdf"));
// Flatten all form fields -- values become static text
form.getForm().flatten();
form.saveAs(Paths.get("output/BasicForm_Archived.pdf"));
}
}//:path=/static-assets/pdf/content-code-examples/how-to/java-fill-pdf-form-tutorial/flatten-form.java
import com.ironsoftware.ironpdf.PdfDocument;
import java.nio.file.Paths;
public class FlattenForm {
public static void main(String[] args) throws Exception {
PdfDocument form = PdfDocument.fromFile(Paths.get("assets/BasicForm_Filled.pdf"));
// Flatten all form fields -- values become static text
form.getForm().flatten();
form.saveAs(Paths.get("output/BasicForm_Archived.pdf"));
}
}Después de que flatten() se ejecuta, no quedan campos de formulario interactivos en el PDF de salida. El tamaño del documento típicamente disminuye porque se eliminan las capas superpuestas del campo de formulario. Los PDFs aplanados son seguros para distribuir sin riesgo de que los destinatarios editen los valores enviados.
¿Cuáles son los siguientes pasos para el llenado de formularios PDF en Java?
IronPDF proporciona una API enfocada y con poco código repetitivo para rellenar formularios PDF en Java. El método getForm() proporciona acceso directo a campos de texto, casillas de verificación, botones de opción y listas desplegables. Cuando se requiere archivado, flatten() bloquea todos los datos rellenados como contenido estático.
Para las siguientes etapas de su flujo de trabajo de documentos PDF, explore estas guías:
- Crear formularios PDF desde HTML en Java: construir plantillas de formularios personalizados programáticamente
- Convertir HTML a PDF en Java: renderizar páginas y fragmentos HTML completos como documentos PDF
- Seguridad de PDF y protección con contraseña: restringir acceso a formularios llenos antes de su distribución
- Firmas digitales para PDF en Java: firmar formularios completos para establecer autenticidad
- Referencias de la API Java de IronPDF: documentación completa de clases y métodos
Inicie una prueba gratuita de IronPDF for Java para probar el llenado de formularios en su propio proyecto. Cuando esté listo para implementar, vea las opciones de licencia de IronPDF para encontrar un plan que se ajuste a las necesidades de su equipo.
Preguntas Frecuentes
¿Cuáles son los pasos básicos para rellenar un formulario PDF en Java?
Agregue la dependencia Maven de IronPDF, cargue su PDF con PdfDocument.fromFile(), acceda a los campos del formulario con getForm(), llame a setFieldValue(fieldName, value) para cada campo, y guarde el resultado con saveAs().
¿Cómo descubro los nombres de los campos en un PDF existente?
Abra el PDF en Adobe Acrobat Reader, haga clic derecho en cualquier campo y seleccione Propiedades. El nombre del campo aparece en la pestaña General. Alternativamente, llame a getForm().getFields() para iterar sobre todos los campos e imprimir cada getName() y getType() programáticamente.
¿Cómo lleno las casillas de verificación y los botones de radio en Java?
Use setFieldValue() con la cadena de valor de exportación del campo. Los valores de exportación de las casillas de verificación suelen ser Yes o On. Para grupos de botones de radio, cada opción comparte el mismo nombre de campo pero tiene un valor de exportación único. Si el campo no responde, inspeccione getValue() en una copia del PDF marcada manualmente para encontrar la cadena correcta.
¿Cómo lleno un campo de lista desplegable?
Llame a setFieldValue(fieldName, optionValue) con el valor de exportación de la opción. El valor de exportación suele ser el texto visible de la opción. Para enumerar las opciones disponibles programáticamente, convierta FormField a FormComboBoxField y llame a getOptions().
¿Qué hace aplanar un formulario PDF?
El aplanamiento convierte todos los campos de formulario interactivos en contenido estático y no editable. Llame a getForm().flatten() antes de guardar. El PDF resultante no puede ser editado por los destinatarios, lo cual es necesario para muchos flujos de trabajo de archivo y cumplimiento.
¿Puede IronPDF llenar formularios creados por otras herramientas?
Sí. PdfDocument.fromFile() carga cualquier PDF rellenable estándar independientemente de cómo fue creado. Use getForm().getFields() para inspeccionar los nombres de los campos antes de llamar a setFieldValue(), ya que los nombres de los campos son sensibles a mayúsculas y minúsculas y varían según el autor del formulario.
¿Aún desplazándote?
¿Quieres una prueba rápida?
ejecutar una muestra Mira cómo tu HTML se convierte en PDF.
Comience gratis
Comience gratis
Reserve demostración en vivo gratis
No se requiere tarjeta de crédito ni creación de cuenta
