Ein Vergleich zwischen IronPDF for Java und jPDFPrint

Einführung

PDF (Portable Document Format) ist ein weit verbreitetes Dateiformat zur Darstellung von Dokumenten auf eine Art und Weise, die unabhängig von Anwendungssoftware, Drittanbietersoftware oder -treibern, Hardware und Betriebssystemen wie macOS ist. Das programmatische Manipulieren von PDF-Dateien ohne Benutzereingriff ist eine gängige Anforderung in verschiedenen Anwendungen. Dieser Artikel untersucht zwei Java-Bibliotheken, IronPDF und jPDFPrint, die Möglichkeiten zur Manipulation von PDF-Dateien auf unterschiedliche Weise in einer Java-Laufzeitumgebung bieten. Wir werden ihre Funktionen und Eigenschaften untersuchen und ihre Angebote vergleichen, um ihre Stärken und Schwächen zu verstehen und wie sie sich von der direkten Verwendung von Acrobat-PDF-Dokumenten unterscheiden.

Überblick über IronPDF

IronPDF ist eine leistungsstarke Java-Bibliothek, die es Entwicklern ermöglicht, PDFs programmgesteuert zu erstellen, zu bearbeiten und zu konvertieren. Es bietet eine breite Palette an Funktionen wie das Erstellen von PDFs aus HTML, Bildern oder vorhandenen Dokumenten, das Zusammenführen mehrerer PDFs, das Extrahieren von Text und Bildern aus PDFs sowie das Ausführen verschiedener Aufgaben zur Dokumentenbearbeitung.

IronPDF bietet eine benutzerfreundliche API mit einem umfassenden Satz an Methoden und Eigenschaften, die es Entwicklern erleichtern, direkt mit Acrobat-PDF-Dokumenten zu arbeiten. Es bietet auch umfangreiche Dokumentation und Tutorials, um Entwickler durch den Prozess der Integration von IronPDF in ihre Java-Anwendungen zu führen.

Eines der bemerkenswerten Merkmale von IronPDF ist seine Fähigkeit, HTML in PDF zu konvertieren. Mit dieser Funktionalität können Entwickler problemlos PDF-Dokumente aus HTML-Inhalten erstellen, einschließlich CSS-Stilen, JavaScript-Interaktivität und sogar dynamischen Daten.

Beispielcode: Erzeugen von PDF aus HTML mit 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");
   }
}

Übersicht über jPDFPrint

jPDFPrint ist eine von der Drittanbieter-Software Qoppa entwickelte Java-Bibliothek, die sich speziell auf das programmgesteuerte Drucken von PDF-Dokumenten in einer Java-Laufzeitumgebung konzentriert. Es bietet eine einfache und unkomplizierte API zum Drucken von PDF-Dokumenten mithilfe des Java-Druckdienstes.

jPDFPrint ermöglicht es Entwicklern, PDF-Dokumente auf jedem im System installierten Drucker zu drucken, die Lade- und Druckeinstellungen wie Seitenauswahl, Ausrichtung und Skalierung zu steuern und bei Bedarf sogar benutzerdefinierte Druckerbefehle anzugeben. Es unterstützt auch Funktionen wie Duplexdruck, Broschürendruck, lautloses Drucken ohne Benutzereingriff und Wasserzeichen.

Die Bibliothek integriert sich nahtlos in Java-Anwendungen und ermöglicht Entwicklern, die PDF-Druckfunktionalität einfach in ihre Java-Anwendungssoftwarelösungen einzubinden.

Beispielcode: PDF-Dokumente mit jPDFPrint drucken

//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);
    }
}

Vergleich von jPDFPrint Java PDF Print API vs. IronPDF

Beide Bibliotheken sind sehr ausgereift und hilfreich, um PDF-Dokumente zu bearbeiten, wie zum Beispiel PDF-Dokumente zu drucken und Microsoft Word-Dokumente in PDF-Dokumente zu konvertieren.

Verwendung von jPDFPrint Java PDF Print API zum Drucken von Acrobat PDF-Dokumenten

jPDFPrint ist eine Java-Bibliothek, die von Qoppa Software unter Verwendung der firmeneigenen PDF-Technologie von Qoppa entwickelt wurde und sich auf das programmgesteuerte Laden und Drucken von PDF-Dateien konzentriert. Hier ist eine Übersicht, wie man es verwendet:

1. Die erforderlichen Klassen importieren: Beginnen Sie damit, die notwendigen Klassen aus der jPDFPrint-Bibliothek in Ihre Java-Anwendung zu importieren.

    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. Erstellen eines PDFPrint-Objekts: Erstellen Sie eine Instanz der PDFPrint-Klasse und übergeben Sie den Pfad der PDF-Datei, die Sie drucken möchten, als Parameter.
3. Druckeinstellungen festlegen: Passen Sie die Druckeinstellungen mithilfe von Methoden der PDFPrint-Klasse an. Sie können den Druckernamen festlegen, den Seitenbereich angeben, Papierschächte auswählen, die Druckqualität wählen und weitere Druckoptionen konfigurieren, um PDF-Dokumente zu drucken.
4. Drucken Sie die PDF-Datei: Rufen Sie die print-Methode des PDFPrint-Objekts auf, um den Druckvorgang zu starten. Die Bibliothek wird den Java Print Service verwenden, um die PDF-Datei an den Drucker zu senden.

    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();
            }
        }
    }

Verwendung von IronPDF Java zum Drucken von Dokumenten

IronPDF ist eine leistungsstarke Java-Bibliothek, die in der Java-Anwendung für die PDF-Bearbeitung, einschließlich der PDF-Erstellung, Konvertierung und Dokumentenbearbeitung. Hier ist eine Übersicht über die Verwendung von IronPDF:

1. Importieren Sie die erforderlichen Klassen: Beginnen Sie damit, die notwendigen Klassen aus der IronPDF-Bibliothek in Ihre Java-Anwendung zu importieren.

    import com.ironsoftware.ironpdf.*;

    import com.ironsoftware.ironpdf.*;

2. PDF-Generierung: Um ein PDF-Dokument zu erstellen, haben Sie mehrere Optionen mit IronPDF. Beispielsweise können Sie Java-Eingaben, HTML-Inhalte mit dem HtmlToPdfRenderer Klasse, die der Druckbefehl eines PDF-Dokuments ist, wie im Beispielcode gezeigt, um Dokumente leise zu drucken oder an PDF zu senden. Sie können auch PDF-Dokumente programmatisch erstellen, indem Sie Elemente wie Text, Bilder, Tabellen und Anmerkungen hinzufügen.

    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. Dokumentenbearbeitung: IronPDF bietet eine Reihe von Methoden und Eigenschaften zur Bearbeitung bestehender PDF-Dokumente. Sie können mehrere PDFs zu einem einzigen Dokument zusammenfügen, ein PDF in mehrere Dateien aufteilen, Text und Bilder extrahieren, Wasserzeichen hinzufügen, PDFs verschlüsseln und entschlüsseln und vieles mehr.

    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. PDF-Konvertierung: Zusätzlich zur Erstellung von PDFs aus HTML ermöglicht Ihnen IronPDF das Konvertieren oder Drucken von Acrobat-PDF-Dokumenten in verschiedene Formate, wie z.B. Bilder (JPEG, PNG, TIFF), HTML und sogar Excel-Tabellen.

    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. Speichern und Ausgeben: Nachdem Sie das PDF-Dokument erstellt oder bearbeitet haben, können Sie es mit der saveAs-Methode an einem bestimmten Speicherort speichern, um Dokumente an einen Stream oder eine HTTP-Antwort zu senden.

Bevorzugung für IronPDF

Während sowohl jPDFPrint als auch IronPDF PDF-Manipulationsfunktionen bieten, stellt IronPDF eine umfassendere Palette an Funktionalitäten und Flexibilität bereit. IronPDF zeichnet sich in mehreren Aspekten aus:

1. HTML zu PDF Konvertierung: IronPDF beeindruckt bei der Umwandlung von HTML-Inhalten in PDF, was es zu einer geeigneten Wahl für Anwendungen macht, die eine dynamische PDF-Erzeugung aus Webseiten oder HTML-Vorlagen erfordern.

    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. Umfangreiche Dokumentmanipulation: IronPDF bietet eine breite Palette an Funktionen zur Dokumentmanipulation, einschließlich Zusammenführen, Aufteilen, Extrahieren von Text und Bildern, Verschlüsselung und mehr. Dies macht es zu einem vielseitigen Werkzeug für die Arbeit mit PDF-Dateien.
3. Breiterer Umfang: IronPDF umfasst eine breite Palette von PDF-bezogenen Aufgaben über das reine Drucken hinaus und bietet damit eine robustere Lösung für Anwendungen, die umfassende PDF-Bearbeitungsfunktionen erfordern.
4. Umfassende Dokumentation und Unterstützung: IronPDF bietet umfangreiche Dokumentation, Tutorials und ein engagiertes Support-Team, um Entwickler bei der Integration der Bibliothek und der Lösung von Problemen, die während der Entwicklung auftreten können, zu unterstützen.

    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();
    }

Angesichts dieser Vorteile sollten Entwickler, die eine leistungsstarke und flexible PDF-Manipulationslösung mit HTML-zu-PDF-Konvertierungsfunktionen, umfangreichen Dokumentmanipulationsfunktionen und hervorragendem Support suchen, IronPDF gegenüber jPDFPrint den Vorzug geben.

Jedoch ist es wichtig, die spezifischen Anforderungen Ihres Projekts zu bewerten und die Funktionen, Dokumentation und Unterstützung jeder Bibliothek zu prüfen, um eine fundierte Entscheidung zu treffen, die den Bedürfnissen Ihrer Anwendung entspricht.

Vergleich der jPDFPrint-Funktionen mit IronPDF

1. Funktionalität

jPDFPrint konzentriert sich ausschließlich auf das Drucken von PDF-Dateien und bietet umfassende Kontrolle über den Druckvorgang.

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 bietet eine breitere Palette von Funktionen, einschließlich PDF-Erstellung aus HTML, Dokumentenmanipulation, Extraktion von Text und Bildern und mehr.

// 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. API-Design

jPDFPrint bietet eine unkomplizierte API, die speziell für das Drucken von PDFs entwickelt wurde. Es bietet Methoden und Eigenschaften zur Handhabung von Druckeinstellungen und zur Interaktion mit Druckern.

IronPDF bietet eine umfassende API mit einem breiteren Funktionsumfang. Es bietet Methoden und Eigenschaften zum Erstellen, Bearbeiten und Konvertieren von PDF-Dokumenten sowie umfangreiche Unterstützung für die Konvertierung von HTML zu PDF.

Integration und Benutzerfreundlichkeit

jPDFPrint lässt sich nahtlos in Java-Anwendungen integrieren und vereinfacht PDF-Druckaufgaben. Es ist gut dokumentiert und leicht in bestehende Projekte zu integrieren.

IronPDF bietet eine benutzerfreundliche API mit umfassender Dokumentation und Tutorials. Sein umfangreicher Funktionsumfang erfordert möglicherweise mehr Aufwand zum Erlernen und Integrieren, aber seine Möglichkeiten bieten eine breitere Palette an Möglichkeiten zur PDF-Bearbeitung.

4. HTML-zu-PDF-Konvertierung

IronPDF ist hervorragend in der HTML-zu-PDF-Konvertierung und ermöglicht es Entwicklern, PDF-Dokumente direkt aus HTML-Inhalten zu erstellen, einschließlich CSS-Styling und JavaScript-Interaktivität.

jPDFPrint bietet keine native HTML-zu-PDF-Konvertierungsfunktionen. Der Hauptfokus liegt auf dem Drucken bestehender PDF-Dateien, nicht auf deren Generierung aus HTML.

5. Druckfunktionen

jPDFPrint bietet erweiterte Druckfunktionen wie Duplexdruck, Broschürendruck, Wasserzeichen und mehr. Es bietet eine feingranulare Kontrolle über den Druckvorgang und ermöglicht die Anpassung von Druckerbefehlen.

IronPDF hingegen ist nicht auf Druckfunktionen spezialisiert. Die Hauptstärke liegt in der PDF-Erstellung, -Verarbeitung und -Extraktion.

6. Community und Support

Sowohl IronPDF als auch jPDFPrint haben aktive Gemeinschaften und bieten Unterstützung für Entwickler. Qoppas proprietäre PDF-Technologie, der Entwickler von jPDFPrint, bietet umfassende Dokumentation, Tutorials und reaktionsschnellen Kundensupport an. IronPDF bietet außerdem umfangreiche Dokumentationen und Ressourcen, einschließlich Tutorials und ein engagiertes Support-Team.

7. Lizenzierung und Preisgestaltung

Lizenzierungs- und Preismodelle unterscheiden sich zwischen IronPDF und jPDFPrint. Entwickler sollten bei der Auswahl zwischen den beiden Bibliotheken ihre Projektanforderungen, ihr Budget und ihre Lizenzbeschränkungen berücksichtigen.

IronPDF bietet eine unkomplizierte und transparente Preisstruktur, die auf der Anzahl der Entwickler basiert, die das Produkt nutzen werden. Eine Lizenz kann für einen einzelnen Entwickler, eine Gruppe von Entwicklern oder eine Organisation mit einer unbegrenzten Anzahl von Entwicklern gekauft werden. Die Kosten sind wie folgt:

1. Einzelentwickler: $749 jährlich
2. Team: $1.499 jährlich

3. Business: 2.999 $ jährlich

   Mit dem Kauf einer Lizenz können Sie IronPDF in beliebig vielen Projekten verwenden, und Sie erhalten ein Jahr lang kostenlose Upgrades und technischen Support. Sie haben die Möglichkeit, Ihre Lizenz nach dem ersten Jahr zu einem geringeren Preis zu verlängern.

   

   Unbefristete, jährliche und Abonnementlizenzen sind nur einige der Lizenzierungsoptionen, die Qoppa PDF bietet. Je nach den spezifischen Teilen und Funktionen, die Sie benötigen, variiert der Preis. Zum Beispiel kostet eine Dauerlizenz für den Qoppa PDF Automation Server $4.000, während eine Jahreslizenz $1.500 kostet.

   Ein auf Lizenzgebühren basierendes Lizenzierungsmodell für die Orchestrierung von Webdiensten wird ebenfalls von Qoppa PDF bereitgestellt. Dies bedeutet, dass Ihnen je nach Volumen der PDF-Dateien, die Ihr Online-Dienst verarbeitet, Gebühren in Rechnung gestellt werden.

   

Schlussfolgerung

IronPDF for Java und die jPDFPrint Java-Bibliotheken bieten unterschiedliche Funktionen zur PDF-Bearbeitung. Während sich jPDFPrint darauf konzentriert, PDF-Dateien mit fortschrittlichen Funktionen und einer feinkörnigen Steuerung programmgesteuert zu drucken, bietet IronPDF einen umfassenden Funktionsumfang, einschließlich PDF-Erstellung aus HTML, Dokumentenmanipulation und Extraktion. IronPDF ist eine vielseitige PDF-Bibliothek für Java, die es Entwicklern ermöglicht, PDF-Dateien programmatisch zu manipulieren. Es bietet umfassende Funktionen wie die Erstellung, Bearbeitung, Zusammenführung, Aufteilung und Umwandlung von PDF-Dokumenten aus HTML. IronPDF bietet eine benutzerfreundliche API, benutzerfreundliche Funktionen und umfassende Dokumentation, die den Entwicklungsprozess für die PDF-Bearbeitung vereinfachen.

Andererseits ist jPDFPrint eine Java-Bibliothek, die speziell für das programmgesteuerte Drucken von PDF-Dateien entwickelt wurde. Es bietet erweiterte Funktionen wie die Auswahl des Druckers, die Auswahl des Seitenbereichs, beidseitiges Drucken sowie Papiergrößen- und Ausrichtungs-einstellungen. jPDFPrint bietet auch eine intuitive API, detaillierte Dokumentation und exzellenten Kundensupport.

IronPDF bietet eine einfachere und transparentere Preisstruktur als jPDFPrint. Das Lizenzmodell von IronPDF basiert auf der Anzahl der Entwickler, die die Bibliothek verwenden werden, mit Optionen für einen einzelnen Entwickler, ein Entwicklerteam oder eine Organisation mit einer unbegrenzten Anzahl von Entwicklern. IronPDF-Lizenzen sind etwas günstiger als die von jPDFPrint, mit Preisen, die je nach Lizenztyp von $749 bis $5,999 pro Jahr reichen. IronPDF bietet außerdem kostenlose Upgrades und technischen Support im ersten Jahr an, mit der Option, zu einem niedrigeren Preis zu verlängern.

Was die technischen Fähigkeiten betrifft, bietet IronPDF einen umfassenderen Funktionsumfang als jPDFPrint. IronPDF ermöglicht es Entwicklern, PDF-Dateien auf verschiedene Arten zu bearbeiten, einschließlich der PDF-Erstellung, -Bearbeitung, -Zusammenführung, -Aufteilung und -Konvertierung aus HTML. IronPDF bietet außerdem umfangreiche Dokumentation, eine benutzerfreundliche API und eine einfach zu bedienende Oberfläche, die den Entwicklungsprozess für die PDF-Verarbeitung vereinfacht.

Produkte von Iron Software - Entwickler, die IronPDF oder ein anderes Iron Software-Produkt kaufen möchten, können das Angebot "5 kaufen, 2 bezahlen" auf der Website von Iron Software nutzen. Dieses Angebot bietet einen erheblichen Rabatt für Entwickler, die mehrere Iron Software-Produkte kaufen, darunter IronPDF, IronOCR und IronBarcode, neben anderen.