Java iText PDF – Creando un pdf en Java con iText

Java iText PDF - Creando un pdf desde Java

Hoy vamos a ver iText una librería PDF en Java que nos permite crear, analizar, modificar y mantener documentos en el formato PDF. iText no es usado solo por Java también se utiliza en .NET, Android and GAE para aportar a sus aplicaciones funcionalidades con PDF.

iText logo

¿Qué nos proporciona iText ?

iText es una librería PDF que nos permite crear, adaptar, revisar y mantener documentos en el formato de documento PDF, algunas de las principales características son:

  • Generar documentos y los informes extraídos de un fichero XML o de una base de datos
  • Crear mapas y libros, incorporando características interactivas en formato PDF
  • Añadir marcadores, números de página, marcas de agua, y otras características a los documentos PDF existentes
    Split o concatenar las páginas de los archivos PDF existentes
  • Rellenar formularios interactivos.
  • Servir generado dinámicamente o manipular documentos PDF en un navegador web.

Java iText PDF – Creando un pdf en Java con iText

  1. Añadimos las librerías y creamos la clase
  2. Creación del documento y metadatos
  3. Creamos nuestra primera página
  4. Añadimos más elementos de iText a nuestro PDF
  5. Uso de tablas en iText: PDFPTable
  6. Resultado Final (Código completo)
  7. Documentación utilizada

Software y herramientas utilizadas


 

1. Añadimos las librerías y creamos la clase

Empezaremos descargando la la última versión de está librería, puedes acceder a Sourceforge o descargarla desde este enlace: Descarga de itext desde Sourceforge.

Configuramos el proyecto

Para este proyecto vamos a utilizar Netbeans que proporciona un gran soporte para el desarrollo de aplicaciones con Java.

Para ello abrimos Netbeans y buscamos la opción New Project , al abrirse el wizard seleccionamos Java > Java Application, después únicamente le daremos nombre a nuestro proyecto y su ubicación.

Puedes usar cualquier otro IDE para Java lo único que necesitarás realmente es añadir las librerías de iText.

Creamos la clase

Para crear una nueva clase nos situamos sobre el proyecto y en el menú pop-up seleccionamos New > Java Class, ahí introduciremos el nombre de la clase y el paquete donde la queremos ubicar, en mi caso:

  • Nombre de la clase: GeneratePDFFileIText.java
  • Paquete: org.xulescode.itext

Este código pretende ser la más sencillo posible, así que colocaremos todo el código dentro del método: public void createPDF(File pdfNewFile) para poder seguir a modo de guión como creamos un documento PDF, añado ya unas variables de fuentes y una ubicación para una imagen que utilizaré en el ejemplo:

package org.xulescode.itext;

import com.itextpdf.*;
import java.io.*; 

/**
 * Example of using the iText library to work with PDF documents on Java, 
 * lets you create, analyze, modify and maintain documents in this format.
 * Ejemplo de uso de la librería iText para trabajar con documentos PDF en Java, 
 * nos permite crear, analizar, modificar y mantener documentos en este formato.
 *
 * @author xules You can follow me on my website http://www.codigoxules.org/en
 * Puedes seguirme en mi web http://www.codigoxules.org
 */
public class GeneratePDFFileIText {

    private static final Font chapterFont = FontFactory.getFont(FontFactory.HELVETICA, 26, Font.BOLDITALIC);
    private static final Font paragraphFont = FontFactory.getFont(FontFactory.HELVETICA, 12, Font.NORMAL);
        
    private static final Font categoryFont = new Font(Font.FontFamily.TIMES_ROMAN, 18, Font.BOLD);
    private static final Font subcategoryFont = new Font(Font.FontFamily.TIMES_ROMAN, 16, Font.BOLD);
    private static final Font blueFont = new Font(Font.FontFamily.TIMES_ROMAN, 12, Font.NORMAL, BaseColor.RED);    
    private static final Font smallBold = new Font(Font.FontFamily.TIMES_ROMAN, 12, Font.BOLD);
    
    private static final String iTextExampleImage = "/home/xules/codigoxules/iText-Example-image.png";
    /**
     * We create a PDF document with iText using different elements to learn 
     * to use this library.
     * Creamos un documento PDF con iText usando diferentes elementos para aprender 
     * a usar esta librería.
     * @param pdfNewFile  <code>String</code> 
     *      pdf File we are going to write. 
     *      Fichero pdf en el que vamos a escribir. 
     */
    public void createPDF(File pdfNewFile) {
        // Aquí introduciremos el código para crear el PDF.
    }
}


 

2. Creación del documento y metadatos

En este primer paso con Java iText PDF necesitamos crear un documento para trabajar con él e ir añadiéndole las diferentes páginas que necesitemos para nuestro ejemplo: Document document = new Document();, una vez creado vamos a asociar el documento de trabajo con el fichero de salida esto lo hacemos con el método com.itextpdf.text.pdf.PdfWriter, este es el código que necesitamos:

        // We create the document and set the file name.        
        // Creamos el documento e indicamos el nombre del fichero.
        try {
            Document document = new Document();
            try {
                PdfWriter.getInstance(document, new FileOutputStream(pdfNewFile));
            } catch (FileNotFoundException fileNotFoundException) {
                System.out.println("No such file was found to generate the PDF "
                        + "(No se encontró el fichero para generar el pdf)" + fileNotFoundException);
            }
            document.open();

            // AQUÍ COMPLETAREMOS NUESTRO CÓDIGO PARA GENERAR EL PDF

            document.close();
            System.out.println("Your PDF file has been generated!(¡Se ha generado tu hoja PDF!");
        } catch (DocumentException documentException) {
            System.out.println("The file not exists (Se ha producido un error al generar un documento): " + documentException);
        }

Ahora vamos añadir información a nuestro documento creado con Java iText PDF introduciendo los metadatos, estos se añaden directamente en los valores del documento definido anteriormente: document:

            // We add metadata to PDF
            // Añadimos los metadatos del PDF
            document.addTitle("Table export to PDF (Exportamos la tabla a PDF)");
            document.addSubject("Using iText (usando iText)");
            document.addKeywords("Java, PDF, iText");
            document.addAuthor("Código Xules");
            document.addCreator("Código Xules");


 

3. Creamos nuestra primera página

Para la creación de está primera página usaremos los elementos generales:

Y el elemento com.itextpdf.text.Chapter que usamos para añadir unas sección especial y que es de donde vamos a colgar en este ejemplo los elementos anteriormente mencionados, lo puedes consultar en el código:

            // First page
            // Primera página 
            Chunk chunk = new Chunk("This is the title", chapterFont);
            chunk.setBackground(BaseColor.GRAY);
            // Let's create de first Chapter (Creemos el primer capítulo)
            Chapter chapter = new Chapter(new Paragraph(chunk), 1);
            chapter.setNumberDepth(0);
            chapter.add(new Paragraph("This is the paragraph", paragraphFont));
            // We add an image (Añadimos una imagen)
            Image image;
            try {
                image = Image.getInstance(iTextExampleImage);  
                image.setAbsolutePosition(2, 150);
                chapter.add(image);
            } catch (BadElementException ex) {
                System.out.println("Image BadElementException" +  ex);
            } catch (IOException ex) {
                System.out.println("Image IOException " +  ex);
            }
            document.add(chapter);


 

4. Añadimos más elementos de iText a nuestro PDF

Ahora simplemente añadimos unos elementos a nuestra nueva página para seguir probando elementos, en primer lugar creamos un nuevo capítulo al que le damos nombre utilizando com.itextpdf.text.Paragraph, también creamos otro que añadiremos a continuación:

            // Second page - some elements
            // Segunda página - Algunos elementos
            Chapter chapSecond = new Chapter(new Paragraph(new Anchor("Some elements (Añadimos varios elementos)")), 1);
            Paragraph paragraphS = new Paragraph("Do it by Xules (Realizado por Xules)", subcategoryFont);

Para mostrar que se pueden hacer muchas cosas añadimos un ejemplo de como subrayar un párrafo con una línea de puntos, ejemplo sacado del blog de Java iText PDF, y en el que se usa el elemento com.itextpdf.text.pdf.draw.DottedLineSeparator que dibuja una línea de puntos de izquierda a derecha:

            // Underline a paragraph by iText (subrayando un párrafo por iText)
            Paragraph paragraphE = new Paragraph("This line will be underlined with a dotted line (Está línea será subrayada con una línea de puntos).");
            DottedLineSeparator dottedline = new DottedLineSeparator();
            dottedline.setOffset(-2);
            dottedline.setGap(2f);
            paragraphE.add(dottedline);
            chapSecond.addSection(paragraphE);

Para hacer un ejemplo sencillo de listas añadimos del ejemplo: List examples de iText, simplemente para mostrar un ejemplo de uso y ver lo sencillo que es de manejar com.itextpdf.text.List:

            Section paragraphMoreS = chapSecond.addSection(paragraphS);
            // List by iText (listas por iText)
            String text = "test 1 2 3 ";
            for (int i = 0; i < 5; i++) {
                text = text + text;
            }
            List list = new List(List.UNORDERED);
            ListItem item = new ListItem(text);
            item.setAlignment(Element.ALIGN_JUSTIFIED);
            list.add(item);
            text = "a b c align ";
            for (int i = 0; i < 5; i++) {
                text = text + text;
            }
            item = new ListItem(text);
            item.setAlignment(Element.ALIGN_JUSTIFIED);
            list.add(item);
            text = "supercalifragilisticexpialidocious ";
            for (int i = 0; i < 3; i++) {
                text = text + text;
            }
            item = new ListItem(text);
            item.setAlignment(Element.ALIGN_JUSTIFIED);
            list.add(item);
            paragraphMoreS.add(list);
            document.add(chapSecond);

Al finalizar, no podemos olvidarnos añadir nuestro código al documento con document.add(…).


 

5. Uso de tablas en iText: PDFPTable

En este apartado nos centramos en el uso de com.itextpdf.text.pdf.PdfPTable creando una nueva página, que se convertirán en varias como veremos, por la longitud de la tabla que implementaremos para ver el funcionamiento de com.itextpdf.text.pdf.PdfPTable.

En primer lugar en el código añadimos varios elementos para añadir título y subtítulo, que no explicaré más pues utilizamos elementos anteriormente explicados y para más detalles ya lo puedes ver directamente en el código.

Centrémonos en com.itextpdf.text.pdf.PdfPTable que es un elemento que nos permite crear una tabla cuya posición puede ser absoluta pero que también se puede añadir directamente al documento. En este ejemplo simplemente añadimos texto, pero será muy útil para rellenar por ejemplo con los datos obtenidos de la base de datos.

Los pasos que seguimos con los siguientes y los puedes consultar en el código:

  • Creamos la tabla: PdfPTable table = new PdfPTable(numColumns);
  • Añadimos las cabeceras de la tabla: columnHeader = new PdfPCell(new Phrase(“COL ” + column));
  • Rellenamos el contenido de la tabla con un bucle for añadiendo cada celda con el código: table.addCell(“Row ” + row + ” – Col” + column);
  • Finalmente, añadiremos la tabla al documento, añadiéndola en este caso (no tiene porque ser así) al párrafo que creamos al principio para que vaya a continuación.

Este es el código:

            // How to use PdfPTable
            // Utilización de PdfPTable
            
            // We use various elements to add title and subtitle
            // Usamos varios elementos para añadir título y subtítulo
            Anchor anchor = new Anchor("Table export to PDF (Exportamos la tabla a PDF)", categoryFont);
            anchor.setName("Table export to PDF (Exportamos la tabla a PDF)");            
            Chapter chapTitle = new Chapter(new Paragraph(anchor), 1);
            Paragraph paragraph = new Paragraph("Do it by Xules (Realizado por Xules)", subcategoryFont);
            Section paragraphMore = chapTitle.addSection(paragraph);
            paragraphMore.add(new Paragraph("This is a simple example (Este es un ejemplo sencillo)"));
            Integer numColumns = 6;
            Integer numRows = 120;
            // We create the table (Creamos la tabla).
            PdfPTable table = new PdfPTable(numColumns); 
            // Now we fill the PDF table 
            // Ahora llenamos la tabla del PDF
            PdfPCell columnHeader;
            // Fill table rows (rellenamos las filas de la tabla).                
            for (int column = 0; column < numColumns; column++) {
                columnHeader = new PdfPCell(new Phrase("COL " + column));
                columnHeader.setHorizontalAlignment(Element.ALIGN_CENTER);
                table.addCell(columnHeader);
            }
            table.setHeaderRows(1);
            // Fill table rows (rellenamos las filas de la tabla).                
            for (int row = 0; row < numRows; row++) {
                for (int column = 0; column < numColumns; column++) {
                    table.addCell("Row " + row + " - Col" + column);
                }
            }
            // We add the table (Añadimos la tabla)
            paragraphMore.add(table);
            // We add the paragraph with the table (Añadimos el elemento con la tabla).
            document.add(chapTitle);
            document.close();
            System.out.println("Your PDF file has been generated!(¡Se ha generado tu hoja PDF!");


 

6. Resultado Final (Código completo)

Ya hemos completado nuestro código para generar un PDF con iText, ahora solo tenemos que ejecutarlo desde nuestro método main:

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        GeneratePDFFileIText generatePDFFileIText = new GeneratePDFFileIText();
        generatePDFFileIText.createPDF(new File("/home/xules/codigoxules/GeneratePDFFileIText.pdf"));
    }

En el enlace puedes descargar el código completo de este ejemplo:


 

También, puedes ver el código completo directamente:

package org.xulescode.itext;

import com.itextpdf.text.Anchor;
import com.itextpdf.text.BadElementException;
import com.itextpdf.text.BaseColor;
import com.itextpdf.text.Chapter;
import com.itextpdf.text.Chunk;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Element;
import com.itextpdf.text.Font;
import com.itextpdf.text.FontFactory;
import com.itextpdf.text.Image;
import com.itextpdf.text.List;
import com.itextpdf.text.ListItem;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.Section;
import com.itextpdf.text.pdf.PdfPCell;
import com.itextpdf.text.pdf.PdfPTable;
import com.itextpdf.text.pdf.PdfWriter;
import com.itextpdf.text.pdf.draw.DottedLineSeparator;
import java.io.*; 

/**
 * Example of using the iText library to work with PDF documents on Java, 
 * lets you create, analyze, modify and maintain documents in this format.
 * Ejemplo de uso de la librería iText para trabajar con documentos PDF en Java, 
 * nos permite crear, analizar, modificar y mantener documentos en este formato.
 *
 * @author xules You can follow me on my website http://www.codigoxules.org/en
 * Puedes seguirme en mi web http://www.codigoxules.org
 */
public class GeneratePDFFileIText {
    // Fonts definitions (Definición de fuentes).
    private static final Font chapterFont = FontFactory.getFont(FontFactory.HELVETICA, 26, Font.BOLDITALIC);
    private static final Font paragraphFont = FontFactory.getFont(FontFactory.HELVETICA, 12, Font.NORMAL);
        
    private static final Font categoryFont = new Font(Font.FontFamily.TIMES_ROMAN, 18, Font.BOLD);
    private static final Font subcategoryFont = new Font(Font.FontFamily.TIMES_ROMAN, 16, Font.BOLD);
    private static final Font blueFont = new Font(Font.FontFamily.TIMES_ROMAN, 12, Font.NORMAL, BaseColor.RED);    
    private static final Font smallBold = new Font(Font.FontFamily.TIMES_ROMAN, 12, Font.BOLD);
    
    private static final String iTextExampleImage = "/home/xules/codigoxules/iText-Example-image.png";
    /**
     * We create a PDF document with iText using different elements to learn 
     * to use this library.
     * Creamos un documento PDF con iText usando diferentes elementos para aprender 
     * a usar esta librería.
     * @param pdfNewFile  <code>String</code> 
     *      pdf File we are going to write. 
     *      Fichero pdf en el que vamos a escribir. 
     */
    public void createPDF(File pdfNewFile) {
        // We create the document and set the file name.        
        // Creamos el documento e indicamos el nombre del fichero.
        try {
            Document document = new Document();
            try {

                PdfWriter.getInstance(document, new FileOutputStream(pdfNewFile));

            } catch (FileNotFoundException fileNotFoundException) {
                System.out.println("No such file was found to generate the PDF "
                        + "(No se encontró el fichero para generar el pdf)" + fileNotFoundException);
            }
            document.open();
            // We add metadata to PDF
            // Añadimos los metadatos del PDF
            document.addTitle("Table export to PDF (Exportamos la tabla a PDF)");
            document.addSubject("Using iText (usando iText)");
            document.addKeywords("Java, PDF, iText");
            document.addAuthor("Código Xules");
            document.addCreator("Código Xules");
            
            // First page
            // Primera página 
            Chunk chunk = new Chunk("This is the title", chapterFont);
            chunk.setBackground(BaseColor.GRAY);
            // Let's create de first Chapter (Creemos el primer capítulo)
            Chapter chapter = new Chapter(new Paragraph(chunk), 1);
            chapter.setNumberDepth(0);
            chapter.add(new Paragraph("This is the paragraph", paragraphFont));
            // We add an image (Añadimos una imagen)
            Image image;
            try {
                image = Image.getInstance(iTextExampleImage);  
                image.setAbsolutePosition(2, 150);
                chapter.add(image);
            } catch (BadElementException ex) {
                System.out.println("Image BadElementException" +  ex);
            } catch (IOException ex) {
                System.out.println("Image IOException " +  ex);
            }
            document.add(chapter);
            
            // Second page - some elements
            // Segunda página - Algunos elementos
            Chapter chapSecond = new Chapter(new Paragraph(new Anchor("Some elements (Añadimos varios elementos)")), 1);
            Paragraph paragraphS = new Paragraph("Do it by Xules (Realizado por Xules)", subcategoryFont);
            
            // Underline a paragraph by iText (subrayando un párrafo por iText)
            Paragraph paragraphE = new Paragraph("This line will be underlined with a dotted line (Está línea será subrayada con una línea de puntos).");
            DottedLineSeparator dottedline = new DottedLineSeparator();
            dottedline.setOffset(-2);
            dottedline.setGap(2f);
            paragraphE.add(dottedline);
            chapSecond.addSection(paragraphE);
            
            Section paragraphMoreS = chapSecond.addSection(paragraphS);
            // List by iText (listas por iText)
            String text = "test 1 2 3 ";
            for (int i = 0; i < 5; i++) {
                text = text + text;
            }
            List list = new List(List.UNORDERED);
            ListItem item = new ListItem(text);
            item.setAlignment(Element.ALIGN_JUSTIFIED);
            list.add(item);
            text = "a b c align ";
            for (int i = 0; i < 5; i++) {
                text = text + text;
            }
            item = new ListItem(text);
            item.setAlignment(Element.ALIGN_JUSTIFIED);
            list.add(item);
            text = "supercalifragilisticexpialidocious ";
            for (int i = 0; i < 3; i++) {
                text = text + text;
            }
            item = new ListItem(text);
            item.setAlignment(Element.ALIGN_JUSTIFIED);
            list.add(item);
            paragraphMoreS.add(list);
            document.add(chapSecond);
            
            // How to use PdfPTable
            // Utilización de PdfPTable
            
            // We use various elements to add title and subtitle
            // Usamos varios elementos para añadir título y subtítulo
            Anchor anchor = new Anchor("Table export to PDF (Exportamos la tabla a PDF)", categoryFont);
            anchor.setName("Table export to PDF (Exportamos la tabla a PDF)");            
            Chapter chapTitle = new Chapter(new Paragraph(anchor), 1);
            Paragraph paragraph = new Paragraph("Do it by Xules (Realizado por Xules)", subcategoryFont);
            Section paragraphMore = chapTitle.addSection(paragraph);
            paragraphMore.add(new Paragraph("This is a simple example (Este es un ejemplo sencillo)"));
            Integer numColumns = 6;
            Integer numRows = 120;
            // We create the table (Creamos la tabla).
            PdfPTable table = new PdfPTable(numColumns); 
            // Now we fill the PDF table 
            // Ahora llenamos la tabla del PDF
            PdfPCell columnHeader;
            // Fill table rows (rellenamos las filas de la tabla).                
            for (int column = 0; column < numColumns; column++) {
                columnHeader = new PdfPCell(new Phrase("COL " + column));
                columnHeader.setHorizontalAlignment(Element.ALIGN_CENTER);
                table.addCell(columnHeader);
            }
            table.setHeaderRows(1);
            // Fill table rows (rellenamos las filas de la tabla).                
            for (int row = 0; row < numRows; row++) {
                for (int column = 0; column < numColumns; column++) {
                    table.addCell("Row " + row + " - Col" + column);
                }
            }
            // We add the table (Añadimos la tabla)
            paragraphMore.add(table);
            // We add the paragraph with the table (Añadimos el elemento con la tabla).
            document.add(chapTitle);
            document.close();
            System.out.println("Your PDF file has been generated!(¡Se ha generado tu hoja PDF!");
        } catch (DocumentException documentException) {
            System.out.println("The file not exists (Se ha producido un error al generar un documento): " + documentException);
        }
    }
    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        GeneratePDFFileIText generatePDFFileIText = new GeneratePDFFileIText();
        generatePDFFileIText.createPDF(new File("/home/xules/codigoxules/GeneratePDFFileIText.pdf"));
    }
}

 

Este es el PDF que se obtiene como resultado final de este ejemplo:


 

Documentación Java iText PDF

Java iText PDF

Espero que te haya sido útil.

20 respuestas en “Java iText PDF – Creando un pdf en Java con iText

  1. xoancar

    Hola,
    He seguido tu tutorial y mientras estoy haciendo pruebas con el proyecto me crea y abre el pdf sin problemas. Mediante la librería Desktop.
    El problema es cuando contruyo el .jar del programa. Genera el pdf pero cuando el sistema lo quiere abrir dice que no lo reconoce dando mensaje de que es untipo de fichero no admitido y no lo reconoce. Llevo dándole vueltas al asunto y ya no sé por donde atacarle.
    ¿puedes sugerir algo?
    Gracias por tu ayuda

    1. Julio Yáñez Novo Autor de la entrada

      Hola xoancar.

      He utilizado el ejemplo más sencillo posible para ejecutar el ejemplo con un jar y no he tenido problemas:

      1. A partir de mi ejemplo, he modificado el método main para abrir el fichero llamando a la librería Desktop, tal que así:
      2.     /**
             * Este método es el que voy a indicar que se ejecute en el jar para abrir el pdf.
             * @param args the command line arguments
             */
            public static void main(String args[]) throws IOException {
                GeneratePDFFileIText generatePDFFileIText = new GeneratePDFFileIText();
                generatePDFFileIText.createPDF(new File("/home/xules/codigoxules/GeneratePDFFileIText.pdf"));
                Desktop.getDesktop().open(new File("/home/xules/codigoxules/GeneratePDFFileIText.pdf"));
            }
        
      3. Ejecuto en el proyecto y compruebo que lo abre sin problema.
      4. Finalmente, compilo el jar del proyecto, indicando como ejecutable el método main antes descrito. En mi caso, estoy utilizando linux, lo he ejecutado por consola y sin problema.

      Se me ocurren dos posibles problemas:

      • Puede ser que no tengas bien nombrada la extensión del fichero, o que tu sistema no los sepa como abrir, y en cambio, desde Netbeans si.
      • La otra posibilidad que se me ocurre es que no este encontrando el fichero que tu has generado.

      Como ves son solo pinceladas para intentar ayudarte a encontrar una solución al problema. Si no te ayuda, añade un comentario con el código donde creas y abres el fichero, y lo probaré con un ejemplo, a ver si a mi me da el mismo fallo.

      Muchas gracias, por exponer tus dudas en mi web.
      Saludos.

  2. xoancar

    Mi caso es diferente. Yo cree un módulo “imprimir” que se lanza mediante un botón porque forma parte de un proyecto más grande. Repito si lo ejecuto desde el Netbeans funciona correctamente pero cuando creo el jar crea el pdf, pero no lo lanza y cuando voy abrirlo directamente dice que está dañado. Este es el código (borrado cosas que no son necesarias)

    import com.itextpdf.text.BadElementException;
    import com.itextpdf.text.Chunk;
    import com.itextpdf.text.Document;
    import com.itextpdf.text.DocumentException;
    import com.itextpdf.text.Element;
    import com.itextpdf.text.Font;
    import com.itextpdf.text.Image;
    import java.io.FileOutputStream;
    import com.itextpdf.text.pdf.PdfWriter;
    import com.itextpdf.text.Paragraph;
    import com.itextpdf.text.Phrase;
    import java.awt.Desktop;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.net.MalformedURLException;
    import java.util.Calendar;
    import java.util.GregorianCalendar;
    import java.util.Random;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    import javax.swing.JOptionPane;

    public class imprimir {
    private String nome;

    // Se crea el documento

    @SuppressWarnings(“empty-statement”)

    public String crearInforme(String dir, int id, String don, String dona, String dni, String curso, String eje, String eje2, String sinon) throws FileNotFoundException, BadElementException, MalformedURLException {
    if (id != 0){
    Document documento = new Document();

    // Se genera un número aleatorio entre 10-100
    // Se crea el OutputStream para el fichero donde queremos dejar el pdf.
    FileOutputStream ficheroPdf;
    try{
    Random rnd = new Random();
    rnd.setSeed(System.currentTimeMillis());
    int alea;
    alea = 10 + rnd.nextInt(90);

    String nome = dni + Integer.toString(alea) + “.pdf”;
    ficheroPdf = new FileOutputStream(nome);

    // Se asocia el documento al OutputStream y se indica que el espaciado entre
    PdfWriter.getInstance(documento,ficheroPdf).setInitialLeading(10);

    // Se abre el documento.

    Calendar fecha = new GregorianCalendar();
    int año = fecha.get(Calendar.YEAR);
    int mes = fecha.get(Calendar.MONTH)+1;
    int dia = fecha.get(Calendar.DAY_OF_MONTH);
    documento.open();
    //empezamos por la cabecera
    Image image1 = Image.getInstance(“src/img/imagen.png”);
    documento.add((Element) image1);
    image1.setAbsolutePosition(0f, 700f);
    documento.add(new Chunk(“_____________________________________________________________________________”));
    documento.add(new Paragraph(” “));
    Font font1 = new Font(Font.FontFamily.TIMES_ROMAN, 11, Font.BOLD);
    Font font2 = new Font(Font.FontFamily.TIMES_ROMAN, 10, Font.NORMAL);
    Font font3 = new Font(Font.FontFamily.TIMES_ROMAN, 10, Font.ITALIC);
    Paragraph uno;
    uno = new Paragraph(“BLABLABLABLA PROFESIONAL”,font1);
    uno.setAlignment(Element.ALIGN_CENTER);
    documento.add(uno);
    documento.add(new Paragraph(” “));
    Paragraph dos;
    dos = new Paragraph(“Código Solicitude: ” + id,font2);
    dos.setAlignment(Element.ALIGN_RIGHT);
    documento.add(dos);
    Paragraph tres;
    tres = new Paragraph(“Don ” + dir + “, “BLABLABLABLA PROFESIONAL”, font2);
    documento.add(tres);
    Paragraph cuatro;
    documento.add(new Paragraph(” “));
    cuatro = new Paragraph(“EXPÓN: “, font1);
    documento.add(cuatro);
    Chunk c1 = new Chunk(“Que a “, font2);
    Chunk c2 = new Chunk(“BLABLABLABLA PROFESIONAL”, font3);
    Chunk c3 = new Chunk(“BLABLABLABLA PROFESIONAL”, font2);
    Phrase p1 = new Phrase();
    p1.add(c1);
    p1.add(c2);
    p1.add(c3);
    Paragraph cinco;
    cinco = new Paragraph();
    cinco.add(p1);
    cinco.setAlignment(Element.ALIGN_JUSTIFIED);
    documento.add(cinco);
    documento.add(new Paragraph(” “));
    Chunk c4 = new Chunk(“Que a “, font2);
    Chunk c5 = new Chunk(“BLABLABLABLA PROFESIONAL”,font3);
    Chunk c6 = new Chunk(“BLABLABLABLA PROFESIONAL”, font2);
    Phrase p2 = new Phrase();
    p2.add(c4);
    p2.add(c5);
    p2.add(c6);
    Paragraph seis;
    seis = new Paragraph();
    seis.add(p2);
    seis.setAlignment(Element.ALIGN_JUSTIFIED);
    documento.add(seis);
    documento.add(new Paragraph(” “));
    Paragraph siete;
    siete = new Paragraph(“Que Dona/Don ” + dona + “, ” + don + “BLABLABLABLA PROFESIONAL” + dni + “BLABLABLABLA PROFESIONAL” + curso + “BLABLABLABLA PROFESIONAL”+ mdo + “.”, font2);
    siete.setAlignment(Element.ALIGN_JUSTIFIED);
    documento.add(siete);
    documento.add(new Paragraph(” “));
    Paragraph ocho;
    ocho = new Paragraph(“BLABLABLABLA PROFESIONAL”, font2);
    ocho.setAlignment(Element.ALIGN_JUSTIFIED);
    documento.add(ocho);
    documento.add(new Paragraph(” “));
    Paragraph nueve;
    nueve = new Paragraph(“RESOLVE: “, font1);
    documento.add(nueve);
    documento.add(new Paragraph(” “));
    Paragraph diez;
    diez = new Paragraph(“BLABLABLABLA PROFESIONAL”, font2);
    diez.setAlignment(Element.ALIGN_JUSTIFIED);
    documento.add(diez);
    documento.add(new Paragraph(” “));
    Paragraph once;
    once = new Paragraph(“BLABLABLABLA PROFESIONAL”, font2);
    once.setAlignment(Element.ALIGN_LEFT);
    documento.add(once);
    documento.add(new Paragraph(” “));
    Paragraph doce;
    doce = new Paragraph(“Marín, ” + dia + “/” + mes + “/” + año, font2);
    doce.setAlignment(Element.ALIGN_LEFT);
    documento.add(doce);
    documento.add(new Paragraph(” “));
    Paragraph trece;
    trece = new Paragraph(“BLABLABLABLA PROFESIONAL”, font2);
    trece.setAlignment(Element.ALIGN_LEFT);
    documento.add(trece);
    documento.add(new Paragraph(” “));
    documento.add(new Paragraph(” “));
    Paragraph catorce;
    catorce = new Paragraph(“Asdo.: ” + dir, font2);
    catorce.setAlignment(Element.ALIGN_LEFT);
    documento.add(catorce);
    Paragraph quince;
    quince = new Paragraph(“______________________________________________________________________________”);
    documento.add(quince);
    Paragraph dieciseis;
    dieciseis = new Paragraph(“Recibín: ” + dona + ” ” + don, font2);
    documento.add(dieciseis);
    documento.close();
    int opt = JOptionPane.showConfirmDialog(null, “Desexa Abrilo ?”, ” INFORME ” + nome + ” CREADO “, JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
    if (opt == JOptionPane.YES_OPTION) {
    return nome;
    }
    } catch (DocumentException e) {
    JOptionPane.showMessageDialog(null, “Erro non se creou o informe”);
    } catch (IOException ex) {
    Logger.getLogger(imprimir.class.getName()).log(Level.SEVERE, null, ex);
    }
    //path.deleteOnExit();
    }
    else {
    JOptionPane.showMessageDialog(null,”BLABLABLABLA PROFESIONAL”, “WARNING_MESSAGE” , JOptionPane.ERROR_MESSAGE);
    }
    return nome;
    }

        1. Julio Yáñez Novo Autor de la entrada

          Hola Seba.

          La solución de Xoancar debería funcionar, como dijo él incluyendo las imágenes dentro de una carpeta del proyecto, o bien, indicando la ruta completa en el ordenador que ejecutas el jar, como yo he hecho en mi ejemplo: private static final String iTextExampleImage = “/home/xules/codigoxules/iText-Example-image.png”; como ves estoy incluyendo la ruta absoluta en este ejemplo sencillo.

          Espero que te sirva de ayuda, gracias por usar mi web.

  3. Cristian

    Buenas tardes, estoy haciendo uso del itext para generar unas tablas que luego seran llenadas por consultas SQL, mi problema es que al generar el pdf, en las tablas siempre me trae el ultimo dato registrado en mi base de datos es decir si en mi tabla 1 tengo estos datos
    —–nombre —–apellido
    carlos jaramillo
    pepito perez
    ———————————-
    por lo cual en la tabla aparece “pepito perez” como podria realizar que siempre me traiga los datos en orden?

    1. Julio Yáñez Novo Autor de la entrada

      Hola Cristian.

      Para rellenar tu tabla PDF con iText necesitarás recorrer la consulta de la base de datos, así que lo que tienes que hacer es ordenar tu consulta SQL con ORDER BY con los campos que necesites, y después al recorrer el bucle en el mismo orden para rellenar la tabla de iText ya te aparecerán en el orden adecuado.

      No es leyendo de la base de datos, pero lo que te explico lo puedes ver en mi ejemplo: Java JTable importar contenido carpeta y exportar a PDF donde cojo los datos de una tabla en Java Swing y los exporto a PDF, te muestro el código de la exportación a PDF simplemente sustituye mi bucle for que recorre los datos de la tabla por tu consulta a la base de datos.

      /**
       * Explanation of the method by which we read the JTable we pass as
       * parameter, and where we copy its content in a PDF passed 
       * as a parameter.
       * Método con el que leemos cualquier JTable que pasamos como
       * parámetro, y donde copiamos su contenido en un PDF que se pasa 
       * como parámetro. 
       *
       * @param jTable <code>JTable</code> 
       *      the JTable we are going to pass to PDF. 
       *      El JTable que vamos a pasar a PDF.
       * @param pdfNewFile <code>String</code> 
       *      pdf File we are going to write. 
       *      Fichero pdf en el que vamos a escribir. 
       * @param title <code>String</code> 
       *      title
       *      Título 
       */
      public void utilJTableToPdf(JTable jTable, File pdfNewFile, String title){    
          try {
              // We create the document and set the file name.        
              // Creamos el documento e indicamos el nombre del fichero.
              Document document = new Document();
              try {
                  PdfWriter.getInstance(document, new FileOutputStream(pdfNewFile));
              } catch (FileNotFoundException fileNotFoundException) {
                  System.out.println("No such file was found to generate the PDF (No se encontró el fichero para generar el pdf)" + fileNotFoundException);
              }
              document.open();
              // We add metadata to PDF
              // Añadimos los metadatos del PDF
              document.addTitle("Table export to PDF (Exportamos la tabla a PDF)");
              document.addSubject("Using iText (usando iText)");
              document.addKeywords("Java, PDF, iText");
              document.addAuthor("Código Xules");
              document.addCreator("Código Xules");
               
              // First page (Primera página)
              Anchor anchor = new Anchor("Table export to PDF (Exportamos la tabla a PDF)", categoryFont);
              anchor.setName("Table export to PDF (Exportamos la tabla a PDF)");
       
              // Second parameter is the number of the chapter (El segundo parámetro es el número del capítulo).
              Chapter catPart = new Chapter(new Paragraph(anchor), 1);
       
              Paragraph subPara = new Paragraph("Do it by Xules (Realizado por Xules)", subCategoryFont);
              Section subCatPart = catPart.addSection(subPara);
              subCatPart.add(new Paragraph("This is a simple example (Este es un ejemplo sencillo)"));
                           
              // Create the table (Creamos la tabla)
              PdfPTable table = new PdfPTable(jTable.getColumnCount()); 
                
              // Now we fill the rows of the PdfPTable (Ahora llenamos las filas de PdfPTable)
              PdfPCell columnHeader;
              // Fill table columns header 
              // Rellenamos las cabeceras de las columnas de la tabla.                
              for (int column = 0; column < jTable.getColumnCount(); column++) {                 
                  columnHeader = new PdfPCell(new Phrase(jTable.getColumnName(column)));
                  columnHeader.setHorizontalAlignment(Element.ALIGN_CENTER);
                  table.addCell(columnHeader);
              }
              table.setHeaderRows(1);
              // Fill table rows (rellenamos las filas de la tabla).                
              for (int row = 0; row < jTable.getRowCount(); row++) {                
                  for (int column = 0; column < jTable.getColumnCount(); column++) { 
                      table.addCell(jTable.getValueAt(row, column).toString());
                  }
              } 
              subCatPart.add(table);
               
              document.add(catPart);
               
              document.close();
              JOptionPane.showMessageDialog(this.jPanelFicheros, "Your PDF file has been generated!(¡Se ha generado tu hoja PDF!)",
                      "RESULTADO", JOptionPane.INFORMATION_MESSAGE);
          } catch (DocumentException documentException) {
              System.out.println("The file not exists (Se ha producido un error al generar un documento): " + documentException);
              JOptionPane.showMessageDialog(this.jPanelFicheros, "The file not exists (Se ha producido un error al generar un documento): " + documentException,
                      "ERROR", JOptionPane.ERROR_MESSAGE);
          }     
                    
      }
      

      Espero que te sirva de ayuda.

      Saludos.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *