Ein Vergleich zwischen IronPDF für Java und Qoppa Software – Java PDF-Bibliothek

1.1. Installation von IronPDF in Java

Um die IronPDF-Bibliothek in ein Java-Projekt einzubinden, gibt es zwei Methoden:

1. Hinzufügen von IronPDF als Abhängigkeit in einem Maven-konfigurierten Java-Projekt.
2. Herunterladen der IronPDF-JAR-Datei und manuelles Hinzufügen zum Klassenpfad des Projekts.

Beide Installationsmethoden werden im folgenden Abschnitt kurz erklärt.

Option 1: Die Installation von IronPDF als Maven-Abhängigkeit beinhaltet das Hinzufügen der erforderlichen Artefakte zum Abhängigkeitsabschnitt der pom.xml-Datei des Java-Projekts.

<dependency>
    <groupId>com.ironsoftware</groupId>
    <artifactId>ironpdf</artifactId>
    <version>2023.1.1</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.32</version>
</dependency>

<dependency>
    <groupId>com.ironsoftware</groupId>
    <artifactId>ironpdf</artifactId>
    <version>2023.1.1</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.32</version>
</dependency>

Das erste Artefakt verweist auf die neueste Version der IronPDF-Bibliothek für Java, während das zweite Artefakt auf eine SLF4J-Implementierung verweist. Diese Abhängigkeit ist notwendig, damit die IronPDF-Rendering-Engine während ihrer Ausführung Protokollierungsnachrichten erzeugen kann. Programmierer können diese Abhängigkeit durch andere Protokollanbieter wie Logback und Log4J ersetzen oder sie ganz weglassen, wenn keine Protokollierung erforderlich ist.

Um die neueste Version der vorgenannten Bibliotheken zu erhalten, führen Sie den mvn install-Befehl in einem Terminal im Stammverzeichnis des Java-Projekts aus.

Option 2: Alternativ können Entwickler, die Maven oder andere Abhängigkeitsmanagementsysteme nicht nutzen möchten, die JAR-Datei der IronPDF-Bibliothek (zusammen mit der optionalen SLF4J-Implementierung) manuell herunterladen und zum Klassenpfad ihres Projekts hinzufügen.

Um die IronPDF-JAR-Datei herunterzuladen, greifen Sie direkt über das Maven-Repository darauf zu.

1.2. Installation von Qoppa PDF in Java

Qoppa PDF ist eine Drittanbieterbibliothek zur Arbeit mit PDF-Dateien in Java-Anwendungen.

Qoppa Java-PDF-Bibliotheken sind als Artefakte verfügbar und werden von Qoppa Software in einem Maven-Repository gehostet. Mit nur wenigen Änderungen an der POM-Datei können Sie die Qoppa PDF-Funktionen einfach in Ihre Maven-Projekte und -Anwendungen integrieren.

Die Details zum Maven-Repository von Qoppa und zu den Abhängigkeiten der veröffentlichten Artefakte sind unten zu sehen.

Die Einstellungen und der Speicherort des Qoppa-Repositorys, die Sie in Ihrer Maven-pom.xml-Datei einfügen sollten, sind wie folgt:

<repositories>
    <repository>
        <id>QoppaSoftware</id>
        <name>Qoppa Software</name>
        <url>http://download.qoppa.com/maven</url>
    </repository>
</repositories>

<repositories>
    <repository>
        <id>QoppaSoftware</id>
        <name>Qoppa Software</name>
        <url>http://download.qoppa.com/maven</url>
    </repository>
</repositories>

Sie können eines der JAR-Dateien von Qoppa als lokale Datei zu Ihrem Maven-Projekt hinzufügen, als Alternative zur Nutzung des Maven-Repositorys von Qoppa Software. Wenn Sie beispielsweise jPDFEditor als lokales JAR hinzufügen möchten, würden Sie die Datei in einem angegebenen Systempfad speichern, wie $project.basedir/src/main/resources/, und dann jPDFEditor unter Verwendung der unten aufgeführten Abhängigkeit hinzufügen.

<dependencies>
    <dependency>
        <groupId>com.qoppa</groupId>
        <artifactId>jPDFEditor</artifactId>
        <version>2021R1.01</version>
        <scope>system</scope>
        <systemPath>${project.basedir}/src/main/resources/jPDFEditor.jar</systemPath>
    </dependency>
</dependencies>

<dependencies>
    <dependency>
        <groupId>com.qoppa</groupId>
        <artifactId>jPDFEditor</artifactId>
        <version>2021R1.01</version>
        <scope>system</scope>
        <systemPath>${project.basedir}/src/main/resources/jPDFEditor.jar</systemPath>
    </dependency>
</dependencies>

2.1. Manipulation von PDF mit IronPDF

IronPDF ist ein leistungsstarkes Tool, das Entwicklern die Möglichkeit bietet, PDF-Dokumente zu verarbeiten und zu manipulieren, während die Dokumenten-Workflows respektiert werden. Mit der neuesten Version bietet das Tool Endbenutzern verschiedene Komponenten und Funktionen, um ihre Anforderungen beim Lesen und Schreiben von PDF-Dateien zu unterstützen. In diesem Artikel werden wir erforschen, wie man mit IronPDF PDF-Dateien lesen und schreiben kann.

Um zu beginnen, müssen Entwickler zuerst IronPDF für Java installieren und dann die erforderlichen Klassen importieren und beginnen, PDF-Dateien zu lesen.

2.2. Lesen von PDF-Dateien mit IronPDF

Nach der Installation von IronPDF können wir seine Klassen und Apache Tika-Parser in unserem Projekt verwenden. Um eine bestehende PDF-Datei in Java zu lesen, können wir den folgenden Code verwenden:

import com.ironsoftware.ironpdf.*;

public class ReadPDFExample {
    public static void main(String[] args) {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
        // Extract all the text from the document
        String text = pdf.extractAllText();
        // Output the extracted text
        System.out.println(text);
    }
}

import com.ironsoftware.ironpdf.*;

public class ReadPDFExample {
    public static void main(String[] args) {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
        // Extract all the text from the document
        String text = pdf.extractAllText();
        // Output the extracted text
        System.out.println(text);
    }
}

In diesem Code öffnet PdfDocument.fromFile das PDF-Dokument und Paths.get erhält den Pfad der Datei. Die extractAllText-Methode liest den gesamten Text im Dokument.

2.3. Text von einer bestimmten Seite lesen

public class ReadSpecificPageExample {
    public static void main(String[] args) {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
        // Extract text from the second page (page index starts at 0)
        String text = pdf.extractTextFromPage(PageSelection.singlePage(1));
        // Output the extracted text from the specific page
        System.out.println(text);
    }
}

public class ReadSpecificPageExample {
    public static void main(String[] args) {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
        // Extract text from the second page (page index starts at 0)
        String text = pdf.extractTextFromPage(PageSelection.singlePage(1));
        // Output the extracted text from the specific page
        System.out.println(text);
    }
}

2.4. URL zu PDF

Wir können auch IronPDF verwenden, um eine Webseite in ein PDF zu konvertieren und dann Text daraus zu extrahieren. Der folgende Code generiert ein PDF aus einer URL und extrahiert allen Text von der Website:

public class UrlToPdfExample {
    public static void main(String[] args) {
        // Render the website as a PDF
        PdfDocument pdf = PdfDocument.renderUrlAsPdf("https://unsplash.com/");
        // Extract all text from the generated PDF
        String text = pdf.extractAllText();
        // Output the extracted text
        System.out.println("Text extracted from the website: " + text);
    }
}

public class UrlToPdfExample {
    public static void main(String[] args) {
        // Render the website as a PDF
        PdfDocument pdf = PdfDocument.renderUrlAsPdf("https://unsplash.com/");
        // Extract all text from the generated PDF
        String text = pdf.extractAllText();
        // Output the extracted text
        System.out.println("Text extracted from the website: " + text);
    }
}

2.5. Bilder aus PDF extrahieren

Zusätzlich kann IronPDF verwendet werden, um Bilder aus PDF-Dateien zu extrahieren. Der untenstehende Code zeigt die Extraktion von Bildern:

import com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import javax.imageio.ImageIO;

public class ExtractImagesExample {
    public static void main(String[] args) throws IOException {
        // Set the IronPDF license key
        License.setLicenseKey("YOUR LICENSE KEY HERE");
        // Load the PDF document
        PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));

        try {
            // Extract all images from the PDF document
            List<BufferedImage> images = pdf.extractAllImages();
            // Output number of images extracted
            System.out.println("Number of images extracted from the website: " + images.size());

            // Save each extracted image to a file
            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();
        }
    }
}

import com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import javax.imageio.ImageIO;

public class ExtractImagesExample {
    public static void main(String[] args) throws IOException {
        // Set the IronPDF license key
        License.setLicenseKey("YOUR LICENSE KEY HERE");
        // Load the PDF document
        PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));

        try {
            // Extract all images from the PDF document
            List<BufferedImage> images = pdf.extractAllImages();
            // Output number of images extracted
            System.out.println("Number of images extracted from the website: " + images.size());

            // Save each extracted image to a file
            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();
        }
    }
}

3.1. Lesen von PDF-Dateien mit Qoppa PDF

Das Lesen von PDF-Dateien mit Qoppa PDF in Java kann mit dem folgenden Beispielcode durchgeführt werden:

import com.qoppa.pdf.PDFImages;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.Font;
import java.io.File;
import javax.imageio.ImageIO;

public class ReadPdfWithQoppa {
    public static void main(String[] args) {
        try {
            // Load the document
            PDFImages pdfDoc = new PDFImages("input.pdf", null);

            // Loop through pages
            for (int count = 0; count < pdfDoc.getPageCount(); ++count) {
                // Get an image of the PDF page at a resolution of 150 DPI
                BufferedImage pageImage = pdfDoc.getPageImage(count, 150);

                // Create a Graphics 2D from the page image
                Graphics2D g2d = pageImage.createGraphics();

                // Modify BufferedImage using drawing functions available in Graphics2D
                // Here is an example on how to add a watermark
                g2d.setFont(new Font("sansserif", Font.PLAIN, 200));
                g2d.rotate(Math.toRadians(45));
                g2d.setColor(new Color(128, 128, 128, 128));
                g2d.drawString("Watermark", 300, g2d.getFontMetrics().getMaxDescent());

                // Save the image as a JPEG
                File outputFile = new File("output_" + count + ".jpg");
                ImageIO.write(pageImage, "JPEG", outputFile);
                System.out.println("Page " + count + " processed.");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import com.qoppa.pdf.PDFImages;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.Font;
import java.io.File;
import javax.imageio.ImageIO;

public class ReadPdfWithQoppa {
    public static void main(String[] args) {
        try {
            // Load the document
            PDFImages pdfDoc = new PDFImages("input.pdf", null);

            // Loop through pages
            for (int count = 0; count < pdfDoc.getPageCount(); ++count) {
                // Get an image of the PDF page at a resolution of 150 DPI
                BufferedImage pageImage = pdfDoc.getPageImage(count, 150);

                // Create a Graphics 2D from the page image
                Graphics2D g2d = pageImage.createGraphics();

                // Modify BufferedImage using drawing functions available in Graphics2D
                // Here is an example on how to add a watermark
                g2d.setFont(new Font("sansserif", Font.PLAIN, 200));
                g2d.rotate(Math.toRadians(45));
                g2d.setColor(new Color(128, 128, 128, 128));
                g2d.drawString("Watermark", 300, g2d.getFontMetrics().getMaxDescent());

                // Save the image as a JPEG
                File outputFile = new File("output_" + count + ".jpg");
                ImageIO.write(pageImage, "JPEG", outputFile);
                System.out.println("Page " + count + " processed.");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.2. Schreiben von PDF-Dateien mit Qoppa PDF

Das Schreiben von PDF-Dateien mit Qoppa PDF in Java kann über ihre APIs durchgeführt werden:

/*
 * This sample Java program uses jPDFWriter
 * to create a new PDF file, add a page to it
 * and draw an image and text on the page.
 */
package jPDFWriterSamples;

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.io.File;
import javax.imageio.ImageIO;
import com.qoppa.pdfWriter.PDFDocument;
import com.qoppa.pdfWriter.PDFGraphics;
import com.qoppa.pdfWriter.PDFPage;

public class CreatePDFWithTextAndImage {
    public static void main(String [] args) {
        try {
            // Create a new PDF document
            PDFDocument pdfDoc = new PDFDocument();

            // Create a PageFormat of standard letter size with no margins
            Paper paper = new Paper();
            paper.setSize(8.5 * 72, 11 * 72);
            paper.setImageableArea(0, 0, 8.5 * 72, 11 * 72);
            PageFormat pf = new PageFormat();
            pf.setPaper(paper);

            // Create a new page and add it to the PDF
            PDFPage page = pdfDoc.createPage(pf);
            pdfDoc.addPage(page);

            // Get graphics from the page to draw content
            PDFGraphics g2d = (PDFGraphics) page.createGraphics();

            // Read an image (could be png, jpg, etc.)
            BufferedImage image = ImageIO.read(new File("C:\\photo.jpg"));

            // Draw the image on the page
            g2d.drawImage(image, 0, 0, null);

            // Set the font and color for the text
            g2d.setFont(PDFGraphics.HELVETICA.deriveFont(24f));
            g2d.setColor(Color.BLUE);

            // Draw text on the graphics object of the page
            g2d.drawString("NEW TEXT", 200, 30);

            // Save the document to a file
            pdfDoc.saveDocument("C:\\output.pdf");
            System.out.println("PDF created successfully.");
        } catch (Throwable t) {
            System.out.println("Error creating PDF.");
            t.printStackTrace();
        }
    }
}

/*
 * This sample Java program uses jPDFWriter
 * to create a new PDF file, add a page to it
 * and draw an image and text on the page.
 */
package jPDFWriterSamples;

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.io.File;
import javax.imageio.ImageIO;
import com.qoppa.pdfWriter.PDFDocument;
import com.qoppa.pdfWriter.PDFGraphics;
import com.qoppa.pdfWriter.PDFPage;

public class CreatePDFWithTextAndImage {
    public static void main(String [] args) {
        try {
            // Create a new PDF document
            PDFDocument pdfDoc = new PDFDocument();

            // Create a PageFormat of standard letter size with no margins
            Paper paper = new Paper();
            paper.setSize(8.5 * 72, 11 * 72);
            paper.setImageableArea(0, 0, 8.5 * 72, 11 * 72);
            PageFormat pf = new PageFormat();
            pf.setPaper(paper);

            // Create a new page and add it to the PDF
            PDFPage page = pdfDoc.createPage(pf);
            pdfDoc.addPage(page);

            // Get graphics from the page to draw content
            PDFGraphics g2d = (PDFGraphics) page.createGraphics();

            // Read an image (could be png, jpg, etc.)
            BufferedImage image = ImageIO.read(new File("C:\\photo.jpg"));

            // Draw the image on the page
            g2d.drawImage(image, 0, 0, null);

            // Set the font and color for the text
            g2d.setFont(PDFGraphics.HELVETICA.deriveFont(24f));
            g2d.setColor(Color.BLUE);

            // Draw text on the graphics object of the page
            g2d.drawString("NEW TEXT", 200, 30);

            // Save the document to a file
            pdfDoc.saveDocument("C:\\output.pdf");
            System.out.println("PDF created successfully.");
        } catch (Throwable t) {
            System.out.println("Error creating PDF.");
            t.printStackTrace();
        }
    }
}

4.1. Einfachheit

Ein Hauptvorteil von IronPDF ist seine Einfachheit. IronPDF verfügt über eine unkomplizierte API, die einfach zu bedienen ist, selbst für Anfänger. Entwickler können mit nur wenigen Codezeilen PDF-Dokumente einfach erstellen und bearbeiten. Im Gegensatz dazu hat Qoppa PDF eine komplexere API, die für neue Benutzer überwältigend sein kann.

4.2. Kompatibilität

IronPDF ist mit einer Vielzahl von Plattformen und Frameworks kompatibel, einschließlich Java, .NET, ASP.NET und .NET Core. IronPDF unterstützt auch eine Reihe von Dateiformaten, einschließlich HTML, CSS und SVG. Dies macht es Entwicklern leicht, IronPDF in ihre bestehenden Anwendungen zu integrieren.

Im Gegensatz dazu hat Qoppa PDF eine begrenzte Kompatibilität mit Plattformen außerhalb von Java. Dies kann für Entwickler, die mit anderen Programmiersprachen arbeiten, ein Nachteil sein.

4.3. Leistung

IronPDF wurde so entwickelt, dass es schnell und effizient arbeitet, selbst bei großen PDF-Dokumenten. IronPDF verwendet optimierte Algorithmen, um sicherzustellen, dass die PDF-Manipulation schnell und reibungslos abläuft. Dies ist besonders wichtig für Anwendungen, die eine große Menge an PDF-Dateien verarbeiten müssen.

Die Leistung von IronPDF ist beeindruckend, selbst bei der Arbeit mit großen PDF-Dateien. Dies liegt an den optimierten Algorithmen und dem effizienten Speichermanagement von IronPDF.

5.1. IronPDF Preisgestaltung und Lizenzierung

IronPDF bietet ein einfaches und transparentes Preismodell, das auf der Anzahl der Entwickler basiert, die das Tool verwenden. Sie können eine Lizenz für einen einzelnen Entwickler, ein Team von Entwicklern oder ein Unternehmen mit unbegrenzten Entwicklern erwerben.

Mit dem Kauf einer Lizenz können Sie IronPDF in einer beliebigen Anzahl von Projekten verwenden und Sie erhalten kostenlose Updates und technischen Support für ein Jahr. Nach dem ersten Jahr können Sie Ihre Lizenz zu einem ermäßigten Preis verlängern.

5.2. Qoppa PDF Preisgestaltung und Lizenzierung

Qoppa PDF bietet eine Vielzahl von Lizenzierungsmöglichkeiten, einschließlich unbefristeter Lizenzen, jährlicher Lizenzen und Abonnementlizenzen.

In Bezug auf Preisgestaltung und Lizenzierung bietet IronPDF einen einfacheren und transparenteren Ansatz. Die Preisgestaltung basiert auf der Anzahl der Entwickler, die das Tool verwenden, und es gibt keine versteckten Gebühren oder zusätzliche Kosten.