Comparación entre IronPDF for Java y jPDFPrint

Introducción

PDF (Formato de documento portátil) es un formato de archivo ampliamente utilizado para representar documentos de forma independiente del software de aplicación, software o controladores de terceros, hardware y sistemas operativos como macOS. Manipular archivos PDF mediante programación sin intervención del usuario es un requisito habitual en diversas aplicaciones. En este artículo se analizan dos bibliotecas Java, IronPDF y jPDFPrint, que permiten manipular archivos PDF de distintas formas en un entorno de ejecución Java. Profundizaremos en sus características, funcionalidades y compararemos sus ofertas para comprender sus puntos fuertes y débiles y en qué se diferencia de utilizar directamente documentos PDF de Acrobat.

Visión general de IronPDF

IronPDF es una potente biblioteca Java que permite a los desarrolladores crear, manipular y convertir archivos PDF mediante programación. Ofrece una amplia gama de funcionalidades, como generar PDF a partir de HTML, imágenes o documentos existentes, fusionar varios PDF, extraer texto e imágenes de PDF y realizar diversas tareas de manipulación de documentos.

IronPDF ofrece una API fácil de usar con un amplio conjunto de métodos y propiedades, lo que facilita a los desarrolladores trabajar directamente con documentos PDF de Acrobat. También proporciona amplia documentación y tutoriales para guiar a los desarrolladores en el proceso de integración de IronPDF en sus aplicaciones Java.

Una de las características notables de IronPDF es su capacidad para convertir HTML a PDF. Con esta funcionalidad, los desarrolladores pueden generar fácilmente documentos PDF a partir de contenido HTML, incluidos estilos CSS, interactividad JavaScript e incluso datos dinámicos.

Código de ejemplo: Generación de PDF a partir de HTML con IronPDF

import com.ironpdf.*;
 public class HtmlToPdfExample {
  public static void main(String [] args) {
   HtmlToPdfRenderer renderer = new HtmlToPdfRenderer();
   HtmlToPdfOutput output = renderer.RenderHtmlFileAsPdf("input.html");
   output.saveAs("output.pdf");
   }
}

import com.ironpdf.*;
 public class HtmlToPdfExample {
  public static void main(String [] args) {
   HtmlToPdfRenderer renderer = new HtmlToPdfRenderer();
   HtmlToPdfOutput output = renderer.RenderHtmlFileAsPdf("input.html");
   output.saveAs("output.pdf");
   }
}

Visión general de jPDFPrint

jPDFPrint es una biblioteca Java desarrollada por Qoppa software de terceros que se centra específicamente para imprimir documentos PDF mediante programación en un entorno de ejecución Java. Proporciona una API sencilla y directa para imprimir documentos PDF mediante el servicio Java de impresión de documentos.

jPDFPrint permite a los desarrolladores imprimir documentos PDF en cualquier impresora instalada en el sistema, controlar la carga y la configuración de impresión del documento, como el rango de páginas, la orientación y el escalado, e incluso especificar comandos de impresora personalizados, si es necesario. También admite funciones como impresión a doble cara, impresión de folletos, impresión silenciosa sin intervención del usuario y marcas de agua.

La biblioteca se integra perfectamente con las aplicaciones Java, lo que permite a los desarrolladores incorporar fácilmente la funcionalidad de impresión de PDF a sus soluciones de software de aplicaciones Java.

Código de ejemplo: Imprimir documentos PDF con jPDFPrint

//import Qoppa third party software to simply call the library
import com.qoppa.pdfPrinter.PDFPrinterJob;
import java.io.File;
import java.io.IOException;
import java.net.URL;
public class HtmlToPdfExample {
    public static void main(String [] args) throws IOException {
        // Load the HTML page
        URL url = new URL("http://www.example.com");
        String html = org.apache.commons.io.IOUtils.toString(url);
        // Create a PDFPrinterJob object
        PDFPrinterJob printerJob = new PDFPrinterJob();
        // Set the output file
        File outputFile = new File("output.pdf");
        printerJob.setOutputFile(outputFile);
        // Print the HTML page to the output file
        printerJob.printHTML(html);
    }
}

//import Qoppa third party software to simply call the library
import com.qoppa.pdfPrinter.PDFPrinterJob;
import java.io.File;
import java.io.IOException;
import java.net.URL;
public class HtmlToPdfExample {
    public static void main(String [] args) throws IOException {
        // Load the HTML page
        URL url = new URL("http://www.example.com");
        String html = org.apache.commons.io.IOUtils.toString(url);
        // Create a PDFPrinterJob object
        PDFPrinterJob printerJob = new PDFPrinterJob();
        // Set the output file
        File outputFile = new File("output.pdf");
        printerJob.setOutputFile(outputFile);
        // Print the HTML page to the output file
        printerJob.printHTML(html);
    }
}

Comparación de jPDFPrint Java PDF Print API con IronPDF

Ambas bibliotecas son muy sofisticadas y útiles para manipular documentos PDF, como imprimir documentos PDF o convertir documentos de Microsoft Word en documentos PDF.

Uso de jPDFPrint Java PDF Print API para imprimir documentos PDF de Acrobat

jPDFPrint es una librería Java desarrollada por Qoppa Software utilizando la tecnología PDF propietaria de Qoppa, que se centra en la carga programática e imprime archivos PDF. A continuación te explicamos cómo utilizarlo:

1. Importe las clases necesarias: Comience importando las clases necesarias de la librería jPDFPrint a su aplicación Java.

    package jPDFPrintSamples;
    import java.io.FileOutputStream;
    import javax.print.DocFlavor;
    import javax.print.DocPrintJob;
    import javax.print.SimpleDoc;
    import javax.print.StreamPrintService;
    import javax.print.StreamPrintServiceFactory;
    import javax.print.attribute.HashPrintRequestAttributeSet;
    import javax.print.attribute.PrintRequestAttributeSet;
    import javax.print.attribute.standard.MediaSizeName;

    package jPDFPrintSamples;
    import java.io.FileOutputStream;
    import javax.print.DocFlavor;
    import javax.print.DocPrintJob;
    import javax.print.SimpleDoc;
    import javax.print.StreamPrintService;
    import javax.print.StreamPrintServiceFactory;
    import javax.print.attribute.HashPrintRequestAttributeSet;
    import javax.print.attribute.PrintRequestAttributeSet;
    import javax.print.attribute.standard.MediaSizeName;

2. Crear un objeto PDFPrint: Crea una instancia de la clase PDFPrint y pasa la ruta del fichero PDF que quieres imprimir como parámetro.
3. Establecer la configuración de impresión: Personaliza la configuración de impresión utilizando los métodos proporcionados por la clase PDFPrint. Puede establecer el nombre de la impresora, especificar el intervalo de páginas, seleccionar las bandejas de papel, elegir la calidad de impresión y configurar otras opciones de impresión para imprimir documentos PDF.
4. Imprimir el PDF: Llame al método print del objeto PDFPrint para iniciar el proceso de impresión. La biblioteca utilizará el servicio de impresión de Java para enviar el archivo PDF a la impresora.

    package jPDFPrintSamples;
    import java.io.FileOutputStream;
    import javax.print.DocFlavor;
    import javax.print.DocPrintJob;
    import javax.print.SimpleDoc;
    import javax.print.StreamPrintService;
    import javax.print.StreamPrintServiceFactory;
    import javax.print.attribute.HashPrintRequestAttributeSet;
    import javax.print.attribute.PrintRequestAttributeSet;
    import javax.print.attribute.standard.MediaSizeName;
    import com.qoppa.pdfPrint.PDFPrint;
    public class PDFToPS
    {
        public static void main (String [] args)
        {
            try
            {
                DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE;
                String psMimeType = DocFlavor.BYTE_ARRAY.POSTSCRIPT.getMimeType();
                StreamPrintServiceFactory [] factories = StreamPrintServiceFactory.lookupStreamPrintServiceFactories(flavor, psMimeType);
                System.out.println ("Available PS services: " + factories.length);
                if(factories.length == 0)
                {
                    System.err.println ("No PS factories available!");
                    System.exit(0);
                }
                // Open the PDF file
                PDFPrint pdfPrint = new PDFPrint ("test.pdf", null);
                // Open the output file
                FileOutputStream fos = new FileOutputStream("output.ps");
                // Use the first service available
                StreamPrintService sps = factories [0].getPrintService(fos);
                DocPrintJob pj = sps.createPrintJob();
                // Define paper size
                PrintRequestAttributeSet aset = new HashPrintRequestAttributeSet();
                aset.add(MediaSizeName.NA_LETTER);
                // Create simple doc using PDFPrint as Printable and print it
                SimpleDoc doc = new SimpleDoc(pdfPrint, flavor, null);
                pj.print(doc, aset);
                // Close the output PS stream
                fos.close();
            }
            catch (Throwable t)
            {
                t.printStackTrace();
            }
        }
    }

    package jPDFPrintSamples;
    import java.io.FileOutputStream;
    import javax.print.DocFlavor;
    import javax.print.DocPrintJob;
    import javax.print.SimpleDoc;
    import javax.print.StreamPrintService;
    import javax.print.StreamPrintServiceFactory;
    import javax.print.attribute.HashPrintRequestAttributeSet;
    import javax.print.attribute.PrintRequestAttributeSet;
    import javax.print.attribute.standard.MediaSizeName;
    import com.qoppa.pdfPrint.PDFPrint;
    public class PDFToPS
    {
        public static void main (String [] args)
        {
            try
            {
                DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE;
                String psMimeType = DocFlavor.BYTE_ARRAY.POSTSCRIPT.getMimeType();
                StreamPrintServiceFactory [] factories = StreamPrintServiceFactory.lookupStreamPrintServiceFactories(flavor, psMimeType);
                System.out.println ("Available PS services: " + factories.length);
                if(factories.length == 0)
                {
                    System.err.println ("No PS factories available!");
                    System.exit(0);
                }
                // Open the PDF file
                PDFPrint pdfPrint = new PDFPrint ("test.pdf", null);
                // Open the output file
                FileOutputStream fos = new FileOutputStream("output.ps");
                // Use the first service available
                StreamPrintService sps = factories [0].getPrintService(fos);
                DocPrintJob pj = sps.createPrintJob();
                // Define paper size
                PrintRequestAttributeSet aset = new HashPrintRequestAttributeSet();
                aset.add(MediaSizeName.NA_LETTER);
                // Create simple doc using PDFPrint as Printable and print it
                SimpleDoc doc = new SimpleDoc(pdfPrint, flavor, null);
                pj.print(doc, aset);
                // Close the output PS stream
                fos.close();
            }
            catch (Throwable t)
            {
                t.printStackTrace();
            }
        }
    }

Uso de IronPDF Java para imprimir documentos

IronPDF es una potente biblioteca Java que se utiliza en la Aplicación Java para la manipulación de PDF, incluida la generación, conversión y manipulación de documentos PDF. A continuación le explicamos cómo utilizar IronPDF:

1. Importe las clases necesarias: Comience por importar las clases necesarias de la biblioteca IronPDF a su aplicación Java.

    import com.ironsoftware.ironpdf.*;

    import com.ironsoftware.ironpdf.*;

2. Generación de PDF: Para generar un documento PDF, tiene varias opciones con IronPDF. Por ejemplo, puede convertir la entrada de Java, el contenido HTML a PDF utilizando la función renderizador de HTML a PDF que es el comando de impresión de un documento PDF, como se muestra en el código de ejemplo para imprimir o enviar silenciosamente documentos a PDF. También puede crear documentos PDF mediante programación añadiendo elementos como texto, imágenes, tablas y anotaciones.

    import com.ironsoftware.ironpdf.*;  
    import java.io.IOException;  
    import java.nio.file.Paths;  
    // Apply your license key
    License.setLicenseKey("YOUR-LICENSE-KEY");
    // Set a log path
    Settings.setLogPath(Paths.get("C:/tmp/IronPdfEngine.log"));
    // Render the HTML as a PDF. Stored in myPdf as type PdfDocument;
    PdfDocument myPdf = PdfDocument.renderHtmlAsPdf("<h1> ~Hello World~ </h1> Made with IronPDF!");
    // Save the PdfDocument to a file
    myPdf.saveAs(Paths.get("html_saved.pdf"));

    import com.ironsoftware.ironpdf.*;  
    import java.io.IOException;  
    import java.nio.file.Paths;  
    // Apply your license key
    License.setLicenseKey("YOUR-LICENSE-KEY");
    // Set a log path
    Settings.setLogPath(Paths.get("C:/tmp/IronPdfEngine.log"));
    // Render the HTML as a PDF. Stored in myPdf as type PdfDocument;
    PdfDocument myPdf = PdfDocument.renderHtmlAsPdf("<h1> ~Hello World~ </h1> Made with IronPDF!");
    // Save the PdfDocument to a file
    myPdf.saveAs(Paths.get("html_saved.pdf"));

3. **Manipulación de documentos: IronPDF proporciona una serie de métodos y propiedades para manipular documentos PDF existentes. Puede fusionar varios PDF en un solo documento, dividir un PDF en varios archivos, extraer texto e imágenes, añadir marcas de agua, cifrar y descifrar PDF, y mucho más.

    import com.ironsoftware.ironpdf.PdfDocument;
    import com.ironsoftware.ironpdf.font.FontTypes;
    import com.ironsoftware.ironpdf.headerfooter.TextHeaderFooter;
    import com.ironsoftware.ironpdf.headerfooter.HeaderFooterOptions;
    import java.io.IOException;
    // Initialize HeaderFooterOptions object.
    HeaderFooterOptions options = new HeaderFooterOptions();
    PdfDocument pdf = PdfDocument.renderUrlAsPdf("http://www.google.com");
    // Add a header to every page easily
    // Mergeable fields are:
    // {page} {total-pages} {url} {date} {time} {html-title} & {pdf-title}
    options.setFirstPageNumber(1); // use 2 if a cover page  will be appended
    TextHeaderFooter textHeader = new TextHeaderFooter();
    textHeader.setDrawDividerLine(true);
    textHeader.setCenterText("{url}");
    textHeader.setFont(FontTypes.getHelvetica());
    textHeader.setFontSize(12);
    pdf.addTextHeader(textHeader, options);
    // Add a footer too
    TextHeaderFooter textFooter = new TextHeaderFooter();
    textFooter.setDrawDividerLine(true);
    textFooter.setFont(FontTypes.getArial());
    textFooter.setFontSize(10);
    textFooter.setLeftText("{date} {time}");
    textFooter.setRightText("{page} of {total-pages}");
    pdf.addTextFooter(textFooter, options);
    try {
        pdf.saveAs(Paths.get("assets/text_headers_footers.pdf"));
    } catch (IOException e) {
        System.out.println("Failed to save PDF");
        throw new RuntimeException(e);
    }

    import com.ironsoftware.ironpdf.PdfDocument;
    import com.ironsoftware.ironpdf.font.FontTypes;
    import com.ironsoftware.ironpdf.headerfooter.TextHeaderFooter;
    import com.ironsoftware.ironpdf.headerfooter.HeaderFooterOptions;
    import java.io.IOException;
    // Initialize HeaderFooterOptions object.
    HeaderFooterOptions options = new HeaderFooterOptions();
    PdfDocument pdf = PdfDocument.renderUrlAsPdf("http://www.google.com");
    // Add a header to every page easily
    // Mergeable fields are:
    // {page} {total-pages} {url} {date} {time} {html-title} & {pdf-title}
    options.setFirstPageNumber(1); // use 2 if a cover page  will be appended
    TextHeaderFooter textHeader = new TextHeaderFooter();
    textHeader.setDrawDividerLine(true);
    textHeader.setCenterText("{url}");
    textHeader.setFont(FontTypes.getHelvetica());
    textHeader.setFontSize(12);
    pdf.addTextHeader(textHeader, options);
    // Add a footer too
    TextHeaderFooter textFooter = new TextHeaderFooter();
    textFooter.setDrawDividerLine(true);
    textFooter.setFont(FontTypes.getArial());
    textFooter.setFontSize(10);
    textFooter.setLeftText("{date} {time}");
    textFooter.setRightText("{page} of {total-pages}");
    pdf.addTextFooter(textFooter, options);
    try {
        pdf.saveAs(Paths.get("assets/text_headers_footers.pdf"));
    } catch (IOException e) {
        System.out.println("Failed to save PDF");
        throw new RuntimeException(e);
    }

4. Conversión de PDF: Además de generar PDF a partir de HTML, IronPDF permite convertir o imprimir documentos PDF de Acrobat a varios formatos, como imágenes (JPEG, PNG, TIFF)hTML e incluso hojas de cálculo Excel.

    try {
        List<BufferedImage> images = pdf.extractAllImages();
        System.out.println("Number of images extracted from the website: " + images.size());
        int i = 0;
        for (BufferedImage image : images) {
            ImageIO.write(image, "PNG", Files.newOutputStream(Path.of("assets/extracted_" + ++i + ".png")));
        }
    } catch(Exception exception) {
        System.out.println("Failed to extract images from the website");
        exception.printStackTrace();
    }

    try {
        List<BufferedImage> images = pdf.extractAllImages();
        System.out.println("Number of images extracted from the website: " + images.size());
        int i = 0;
        for (BufferedImage image : images) {
            ImageIO.write(image, "PNG", Files.newOutputStream(Path.of("assets/extracted_" + ++i + ".png")));
        }
    } catch(Exception exception) {
        System.out.println("Failed to extract images from the website");
        exception.printStackTrace();
    }

5. Guardar y enviar: Una vez que haya generado o manipulado el documento PDF, puede guardarlo en una ubicación específica utilizando el método saveAs para enviar documentos a un flujo o respuesta HTTP.

Preferencia por IronPDF

Aunque tanto jPDFPrint como IronPDF ofrecen funciones de manipulación de PDF, IronPDF proporciona un conjunto más completo de funcionalidades y flexibilidad. IronPDF destaca en varios aspectos:

1. Conversión de HTML a PDF: IronPDF destaca en la conversión de contenido HTML a PDF, por lo que es una opción adecuada para aplicaciones que requieren la generación dinámica de PDF a partir de páginas web o plantillas HTML.

    import com.ironsoftware.ironpdf.*;  
    import java.io.IOException;  
    import java.nio.file.Paths;  
    // Apply your license key
    License.setLicenseKey("YOUR-LICENSE-KEY");
    // Set a log path
    Settings.setLogPath(Paths.get("C:/tmp/IronPdfEngine.log"));
    // Render the HTML as a PDF. Stored in myPdf as type PdfDocument;
    PdfDocument myPdf = PdfDocument.renderHtmlAsPdf("<h1> ~Hello World~ </h1> Made with IronPDF!");
    // Save the PdfDocument to a file
    myPdf.saveAs(Paths.get("html_saved.pdf"));

    import com.ironsoftware.ironpdf.*;  
    import java.io.IOException;  
    import java.nio.file.Paths;  
    // Apply your license key
    License.setLicenseKey("YOUR-LICENSE-KEY");
    // Set a log path
    Settings.setLogPath(Paths.get("C:/tmp/IronPdfEngine.log"));
    // Render the HTML as a PDF. Stored in myPdf as type PdfDocument;
    PdfDocument myPdf = PdfDocument.renderHtmlAsPdf("<h1> ~Hello World~ </h1> Made with IronPDF!");
    // Save the PdfDocument to a file
    myPdf.saveAs(Paths.get("html_saved.pdf"));

2. Amplia manipulación de documentos: IronPDF ofrece una amplia gama de funciones para la manipulación de documentos, incluyendo fusión, división, extracción de texto e imágenes, encriptación y mucho más. Esto la convierte en una herramienta versátil para trabajar con archivos PDF.
3. Alcance más amplio: IronPDF cubre una amplia gama de tareas relacionadas con PDF más allá de la mera impresión, lo que lo convierte en una solución más robusta para aplicaciones que requieren amplias capacidades de manipulación de PDF.
4. Rica Documentación y Soporte: IronPDF proporciona una amplia documentación, tutoriales y un equipo de soporte dedicado para ayudar a los desarrolladores a integrar la biblioteca y resolver cualquier problema que pueda surgir durante el desarrollo.

    import com.ironsoftware.ironpdf.PdfDocument;
    import java.io.IOException;
    import java.nio.file.Paths;
    // Case 1: Generate a PDF from a string of Rich Text Content
    try {
        String content = "{\\rtf1\\ansi\\ansicpg1252\\deff0\\nouicompat\\deflang1033{\\fonttbl{\\f0\\fnil\\fcharset0 Calibri;}}\n" +
                "{\\*\\generator Riched20 10.0.22621}\\viewkind4\\uc1 \n" +
                "\\pard\\sa200\\sl276\\slmult1\\b\\f0\\fs160\\lang9 Hello, world!\\par\n" +
                "}\n" +
                " ";
        PdfDocument pdf = PdfDocument.renderRtfAsPdf(content);
        pdf.saveAs(Paths.get("assets/rtf_to_pdf.pdf"));
    } catch(IOException exception) {
        exception.printStackTrace();
    }
    // Case 2: Generate a PDF from a RTF file located on a filesystem path
    try {
        PdfDocument pdf = PdfDocument.renderRtfFileAsPdf(Paths.get("assets/test.rtf"));
        pdf.saveAs(Paths.get("assets/rtf_to_pdf_2.pdf"));
    } catch(IOException exception) {
        exception.printStackTrace();
    }

    import com.ironsoftware.ironpdf.PdfDocument;
    import java.io.IOException;
    import java.nio.file.Paths;
    // Case 1: Generate a PDF from a string of Rich Text Content
    try {
        String content = "{\\rtf1\\ansi\\ansicpg1252\\deff0\\nouicompat\\deflang1033{\\fonttbl{\\f0\\fnil\\fcharset0 Calibri;}}\n" +
                "{\\*\\generator Riched20 10.0.22621}\\viewkind4\\uc1 \n" +
                "\\pard\\sa200\\sl276\\slmult1\\b\\f0\\fs160\\lang9 Hello, world!\\par\n" +
                "}\n" +
                " ";
        PdfDocument pdf = PdfDocument.renderRtfAsPdf(content);
        pdf.saveAs(Paths.get("assets/rtf_to_pdf.pdf"));
    } catch(IOException exception) {
        exception.printStackTrace();
    }
    // Case 2: Generate a PDF from a RTF file located on a filesystem path
    try {
        PdfDocument pdf = PdfDocument.renderRtfFileAsPdf(Paths.get("assets/test.rtf"));
        pdf.saveAs(Paths.get("assets/rtf_to_pdf_2.pdf"));
    } catch(IOException exception) {
        exception.printStackTrace();
    }

Dadas estas ventajas, los desarrolladores que busquen una solución de manipulación de PDF potente y flexible con capacidades de conversión de HTML a PDF, amplias funciones de manipulación de documentos y un excelente soporte deberían dar preferencia a IronPDF sobre jPDFPrint.

Sin embargo, es esencial evaluar los requisitos específicos de su proyecto y valorar las funciones, la documentación y la asistencia que ofrece cada biblioteca para tomar una decisión informada que se ajuste a las necesidades de su aplicación.

Comparación de las funciones de jPDFPrint con IronPDF

1. Funcionalidad

jPDFPrint se centra exclusivamente en la impresión de archivos PDF y proporciona un amplio control sobre el proceso de impresión.

package jPDFPrintSamples;
import com.qoppa.pdfPrint.PDFPrint;
public class SimplePrint
{
    public static void main (String [] args)
    {
        try
        {
            PDFPrint pdfPrint = new PDFPrint("input.pdf", null);
            pdfPrint.print(null);
        }
        catch (Throwable t)
        {
            t.printStackTrace();
        }
    }
}

package jPDFPrintSamples;
import com.qoppa.pdfPrint.PDFPrint;
public class SimplePrint
{
    public static void main (String [] args)
    {
        try
        {
            PDFPrint pdfPrint = new PDFPrint("input.pdf", null);
            pdfPrint.print(null);
        }
        catch (Throwable t)
        {
            t.printStackTrace();
        }
    }
}

IronPDF ofrece una gama más amplia de funcionalidades, como la generación de PDF a partir de HTML, la manipulación de documentos, la extracción de texto e imágenes, etc.

// Import statement for IronPDF Java
import com.ironsoftware.ironpdf.*;
// Apply your license key
License.setLicenseKey("YOUR-LICENSE-KEY");
// Set a log path
Settings.setLogPath(Paths.get("C:/tmp/IronPdfEngine.log"));
// Render the URL page as a PDF. Stored in myPdf as type PdfDocument
PdfDocument myPdf = PdfDocument.renderUrlAsPdf("/java");
// Save the PdfDocument to a file
myPdf.saveAs(Paths.get("url_saved.pdf"));
PdfDocument pdfDocument = PdfDocument.renderUrlAsPdf("/java");

// Import statement for IronPDF Java
import com.ironsoftware.ironpdf.*;
// Apply your license key
License.setLicenseKey("YOUR-LICENSE-KEY");
// Set a log path
Settings.setLogPath(Paths.get("C:/tmp/IronPdfEngine.log"));
// Render the URL page as a PDF. Stored in myPdf as type PdfDocument
PdfDocument myPdf = PdfDocument.renderUrlAsPdf("/java");
// Save the PdfDocument to a file
myPdf.saveAs(Paths.get("url_saved.pdf"));
PdfDocument pdfDocument = PdfDocument.renderUrlAsPdf("/java");

2. Diseño API

jPDFPrint tiene una API sencilla diseñada específicamente para la impresión de PDF. Proporciona métodos y propiedades para manejar la configuración de impresión e interactuar con las impresoras.

IronPDF ofrece una API completa con un mayor alcance de funcionalidad. Proporciona métodos y propiedades para crear, manipular y convertir documentos PDF, además de un amplio soporte para la conversión de HTML a PDF.

Integración y facilidad de uso

jPDFPrint se integra perfectamente con las aplicaciones Java y simplifica las tareas de impresión de PDF. Está bien documentado y es fácil de integrar en los proyectos existentes.

IronPDF proporciona una API fácil de usar con documentación y tutoriales completos. Su amplio conjunto de funciones puede requerir más esfuerzo de aprendizaje e integración, pero sus capacidades ofrecen un abanico más amplio de posibilidades para la manipulación de PDF.

4. Conversión de HTML a PDF

IronPDF destaca en la conversión de HTML a PDF, permitiendo a los desarrolladores generar documentos PDF directamente a partir de contenido HTML, incluyendo estilos CSS e interactividad JavaScript.

jPDFPrint no proporciona capacidades nativas de conversión de HTML a PDF. Su principal objetivo es imprimir archivos PDF existentes en lugar de generarlos a partir de HTML.

5. Características de impresión

jPDFPrint ofrece funciones de impresión avanzadas como impresión a doble cara, impresión de folletos, marcas de agua, etc. Ofrece un control detallado del proceso de impresión y permite personalizar los comandos de la impresora.

IronPDF, en cambio, no está especializado en funciones de impresión. Su principal punto fuerte es la generación, manipulación y extracción de PDF.

6. Comunidad y apoyo

Tanto IronPDF como jPDFPrint cuentan con comunidades activas y ofrecen apoyo a los desarrolladores. La tecnología PDF patentada de Qoppa, creadora de jPDFPrint, ofrece documentación completa, tutoriales y un servicio de atención al cliente muy atento. IronPDF también proporciona amplia documentación y recursos, incluidos tutoriales y un equipo de asistencia especializado.

7. Licencias y precios

Los modelos de licencia y precios difieren entre IronPDF y jPDFPrint. Los desarrolladores deben tener en cuenta los requisitos de su proyecto, el presupuesto y las restricciones de licencia a la hora de elegir entre las dos bibliotecas.

IronPDF ofrece una estructura de precios sencilla y abierta que se basa en la cantidad de desarrolladores que utilizarán el producto. Se puede comprar una licencia para un solo desarrollador, un grupo de desarrolladores o una organización con un número ilimitado de desarrolladores. Los costes son los siguientes:

1. Desarrollador individual: $749 anual
2. Equipo: 1.499 $ anuales

3. Empresas: 2.999 $ anuales

   Puede utilizar IronPDF en cualquier número de proyectos con la compra de una licencia, y obtendrá actualizaciones y asistencia técnica gratuitas durante un año. Tiene la opción de renovar su licencia por un coste inferior después del primer año.

   

   Las licencias perpetuas, anuales y de suscripción son sólo algunas de las opciones de licencia que ofrece Qoppa PDF. El precio varía en función de las piezas y las funciones que necesite. Por ejemplo, una licencia perpetua de Qoppa PDF Automation Server cuesta 4.000 dólares, mientras que una licencia anual cuesta 1.500 dólares.

   Qoppa PDF también ofrece un sistema de licencias basado en derechos para la orquestación de servicios web. Esto implica que se le cobrará en función del volumen de archivos PDF que procese su servicio en línea.

   

Conclusión

Las bibliotecas IronPDF for Java y jPDFPrint Java ofrecen distintas funciones para la manipulación de PDF. Mientras que jPDFPrint se centra en la impresión programática de archivos PDF con funciones avanzadas y un control detallado, IronPDF ofrece un amplio conjunto de funcionalidades, como la generación de PDF a partir de HTML, la manipulación de documentos y la extracción. IronPDF es una versátil biblioteca PDF para Java que permite a los desarrolladores manipular archivos PDF mediante programación. Ofrece una amplia funcionalidad, como la creación, edición, fusión, división y conversión de PDF a partir de HTML. IronPDF ofrece una API fácil de usar, funciones sencillas y documentación completa que simplifican el proceso de desarrollo para la manipulación de PDF.

Por otro lado, jPDFPrint es una biblioteca Java diseñada específicamente para imprimir archivos PDF mediante programación. Proporciona funciones avanzadas, como la selección de impresora, la selección del intervalo de páginas, la impresión a doble cara y la configuración del tamaño y la orientación del papel. jPDFPrint también ofrece una API intuitiva, documentación detallada y un excelente servicio de atención al cliente.

IronPDF ofrece una estructura de precios más sencilla y abierta que jPDFPrint. El modelo de licencia de IronPDF se basa en el número de desarrolladores que utilizarán la biblioteca, con opciones para un único desarrollador, un equipo de desarrolladores o una organización con un número ilimitado de desarrolladores. Las licencias de IronPDF son ligeramente más baratas que las de jPDFPrint, con precios que oscilan entre $749 y $2,999 al año, dependiendo del tipo de licencia. IronPDF también ofrece actualizaciones y asistencia técnica gratuitas durante el primer año, con la opción de renovar a un coste inferior.

En términos de capacidades técnicas, IronPDF ofrece un conjunto de funcionalidades más completo que jPDFPrint. IronPDF permite a los desarrolladores manipular archivos PDF de múltiples maneras, incluyendo la creación, edición, fusión, división y conversión de PDF a partir de HTML. IronPDF también proporciona una amplia documentación, una API fácil de usar y una interfaz sencilla que simplifica el proceso de desarrollo para la manipulación de PDF.

Productos de Iron Software - Los desarrolladores que deseen adquirir IronPDF o cualquier otro producto de Iron Software pueden aprovechar la oferta "Compre 5, pague por 2" disponible en el sitio Web de Iron Software. Esta oferta proporciona un descuento sustancial a los desarrolladores que adquieran varios productos de Iron Software, incluidos IronPDF, IronOCR e IronBarcode, entre otros.