Une comparaison entre IronPDF for Java & Qoppa Software – Bibliothèque Java PDF

1.1. Installation d'IronPDF en Java

Pour inclure la bibliothèque IronPDF dans un projet Java, deux méthodes sont disponibles :

1. Ajouter IronPDF comme dépendance dans un projet Java configuré avec Maven.
2. Télécharger le fichier JAR IronPDF et l'ajouter manuellement au classpath du projet.

Ces deux méthodes d'installation seront brièvement expliquées dans la section suivante.

Option 1 : L'installation d'IronPDF en tant que dépendance Maven implique d'ajouter les artefacts nécessaires à la section des dépendances du fichier pom.xml du projet Java.

<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>

L'artefact initial référence la version la plus récente de la bibliothèque IronPDF pour Java, tandis que le second artefact référence une implémentation SLF4J. Cette dépendance est nécessaire pour que le moteur de rendu IronPDF produise des messages de journalisation pendant son fonctionnement. Les programmeurs peuvent remplacer cette dépendance par d'autres fournisseurs de journaux comme Logback et Log4J ou l'omettent complètement si la journalisation n'est pas nécessaire.

Pour obtenir la version la plus récente des bibliothèques mentionnées, exécutez la commande mvn install dans un terminal à la racine du projet Java.

Option 2 : Alternativement, les développeurs qui ne souhaitent pas utiliser Maven ou d'autres systèmes de gestion des dépendances peuvent télécharger manuellement le fichier JAR de la bibliothèque IronPDF (avec l'implémentation SLF4J facultative) et l'ajouter au classpath de leur projet.

Pour télécharger le fichier JAR IronPDF, accédez-le directement à partir du référentiel Maven.

1.2. Installation de Qoppa PDF en Java

Qoppa PDF est une bibliothèque tierce pour travailler avec des fichiers PDF dans les applications Java.

Les bibliothèques Qoppa Java PDF sont disponibles sous forme d'artefacts et sont hébergées par Qoppa Software dans un référentiel Maven. Avec seulement une légère modification de fichier POM, vous pouvez simplement intégrer les capacités de Qoppa PDF dans vos projets et applications Maven.

Les détails du référentiel Maven de Qoppa et les dépendances des artefacts publiés peuvent être vus ci-dessous.

Les paramètres du dépôt Qoppa et l'emplacement à inclure dans votre fichier Maven pom.xml sont les suivants :

<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>

Vous pouvez ajouter un des fichiers JAR de Qoppa en tant que fichier local à votre projet Maven comme alternative à l'utilisation du référentiel Maven de Qoppa Software. Par conséquent, par exemple, si vous souhaitez ajouter jPDFEditor en tant que JAR local, vous enregistreriez le fichier dans un chemin système donné, tel que $project.basedir/src/main/resources/, puis ajouteriez jPDFEditor en utilisant la dépendance listée ci-dessous.

<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 de PDF avec IronPDF

IronPDF est un outil puissant qui offre aux développeurs la possibilité de traiter et de manipuler des documents PDF tout en respectant les flux de travail des documents. Avec sa dernière version, l'outil fournit aux utilisateurs finaux divers composants et fonctionnalités pour répondre à leurs besoins de lecture et d'écriture de fichiers PDF. Dans cet article, nous allons explorer comment lire et écrire des fichiers PDF avec IronPDF.

Pour commencer, les développeurs doivent d'abord installer IronPDF pour Java, puis importer les classes nécessaires et commencer à lire des fichiers PDF.

2.2. Lecture de fichiers PDF avec IronPDF

Après l'installation d'IronPDF, nous pouvons utiliser ses classes et les parseurs Apache Tika dans notre projet. Pour lire un fichier PDF existant en Java, nous pouvons utiliser le code suivant :

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

Dans ce code, PdfDocument.fromFile ouvre le document PDF, et Paths.get obtient le chemin du fichier. La méthode extractAllText lit tout le texte du document.

2.3. Lire du texte à partir d'une page spécifique

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 vers PDF

Nous pouvons également utiliser IronPDF pour convertir une page Web en PDF puis extraire le texte. Le code suivant génère un PDF à partir d'une URL et extrait tout le texte du site Web :

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. Extraire des images d'un PDF

De plus, IronPDF peut être utilisé pour extraire des images de fichiers PDF. Le code ci-dessous démontre l'extraction d'images :

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. Lecture de fichiers PDF avec Qoppa PDF

La lecture de fichiers PDF avec Qoppa PDF en Java peut être accomplie en utilisant le code d'exemple suivant :

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. Écriture de fichiers PDF avec Qoppa PDF

L'écriture de fichiers PDF avec Qoppa PDF en Java peut être effectuée en utilisant leurs API :

/*
 * 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. Simplicité

L'un des principaux avantages d'IronPDF est sa simplicité. IronPDF possède une API simple d'utilisation, même pour les débutants. Les développeurs peuvent facilement créer et modifier des documents PDF avec seulement quelques lignes de code. En revanche, Qoppa PDF a une API plus complexe, qui peut être intimidante pour les nouveaux utilisateurs.

4.2. Compatibilité

IronPDF est compatible avec un large éventail de plateformes et de frameworks, y compris Java, .NET, ASP.NET, et .NET Core. IronPDF prend également en charge une gamme de formats de fichiers, y compris HTML, CSS, et SVG. Cela permet aux développeurs d'intégrer facilement IronPDF dans leurs applications existantes.

En revanche, Qoppa PDF a une compatibilité limitée avec les plateformes autres que Java. Cela peut être un inconvénient pour les développeurs qui travaillent avec d'autres langages de programmation.

4.3. Performance

IronPDF est conçu pour être rapide et efficace, même lors du traitement de grands documents PDF. IronPDF utilise des algorithmes optimisés pour s'assurer que la manipulation des PDF est effectuée rapidement et en douceur. C'est particulièrement important pour les applications qui doivent traiter un grand volume de fichiers PDF.

Les performances d'IronPDF sont impressionnantes, même lors du travail avec des fichiers PDF volumineux. Cela est dû aux algorithmes optimisés d'IronPDF et à une gestion efficace de la mémoire.

5.1. Tarification et licence d'IronPDF

IronPDF offre un modèle de tarification simple et transparent basé sur le nombre de développeurs qui utiliseront l'outil. Vous pouvez acheter une licence pour un seul développeur, une équipe de développeurs, ou un entreprise avec des développeurs illimités.

Avec l'achat d'une licence, vous pouvez utiliser IronPDF dans un nombre illimité de projets, et vous recevrez des mises à jour gratuites et un support technique pendant un an. Après la première année, vous pouvez choisir de renouveler votre licence à un prix réduit.

5.2. Tarification et licence de Qoppa PDF

Qoppa PDF offre une variété d'options de licence, y compris des licences perpétuelles, des licences annuelles, et des licences par abonnement.

En termes de tarification et de licence, IronPDF offre une approche plus simple et plus transparente. La tarification est basée sur le nombre de développeurs utilisant l'outil, et il n'y a pas de frais cachés ou de coûts supplémentaires.