1. IronPDF
  2. Anleitungen
  3. PDFs bearbeiten

PDF in Java bearbeiten (vollständige Anleitung)

Chaknith Bin
Chaknith Bin
28. Dezember 2022
Aktualisiert 10. Dezember 2024
Teilen Sie:
This article was translated from English: Does it need improvement?
Translated
View the article in English

Dieses Tutorial gibt einen Überblick darüber, wie Java-Entwickler mit IronPDF den Inhalt und die Struktur bestehender PDF-Dokumente bearbeiten können. Dazu gehören PDF-Dokumente, die mit den HTML-Konvertierungsfunktionen von IronPDF aus HTML gerendert wurden, sowie PDFs, die mit anderen Anwendungen und Softwarebibliotheken von Drittanbietern erstellt wurden.

Ein Tutorial zum Bearbeiten von PDF-Dokumenten in C#.NET und VB.NET ist ebenfalls verfügbar.

Dieses Tutorial geht davon aus, dass der Leser bereits weiß, wie man IronPDF verwendet, um HTML-Inhalte in PDFs zu konvertieren. Bedenken Sie, zuerst das HTML-zu-PDF-Tutorial zu lesen, bevor Sie mit diesem Tutorial fortfahren, wenn Sie mit der Funktion nicht vertraut sind (oder den grundlegenden Arbeitsablauf auffrischen müssen).

Wie man PDF-Dateien in Java bearbeitet

  1. Java-Bibliothek zur Bearbeitung von PDF-Dateien installieren
  2. Bearbeiten Sie die Dokumentstruktur mit Zusammenführen, Löschen und Aufteilen von PDFs in Java
  3. Überlagern von Hintergrund und Vordergrund mit mehreren Ebenen
  4. Individuelle Kopf- und Fußzeilen, Stempel und Lesezeichen hinzufügen
  5. Interaktive Texteingabeformulare in PDFs anwenden und bearbeiten

Inhaltsübersicht

  • Dokumentenstruktur bearbeiten

    • Manipulation von PDF-Dokumenten

    • Seiten hinzufügen, kopieren und löschen

    • Zusammenführen und Teilen von PDFs

    • Einstellen der benutzerdefinierten Größe von PDF-Dokumenten

    • PDF-Ausrichtung festlegen
  • Benutzerdefinierte Ränder für PDF festlegen
  • PDF-Dokumente in Bilder konvertieren

  • Hintergrund und Vordergrund hinzufügen

    • PDF als Hintergrund hinzufügen
  • PDF als Vordergrund hinzufügen

  • Bilder- und Textextraktion

    • Auszug Inhalt
  • Bilder extrahieren

  • Dokumenteigenschaften bearbeiten

    • Hinzufügen und Verwenden von PDF-Metadaten

    • Digitale Signaturen
  • PDFs komprimieren

  • PDF-Inhalt bearbeiten

    • Kopf- und Fußzeilen hinzufügen

    • Gliederungen und Lesezeichen

    • Hinzufügen und Bearbeiten von Kommentaren

    • Stempeln und Wasserzeichen

    • Stamper Übersicht

    • Beispiele für Stamper

    • Text in eine PDF-Datei stempeln

    • Ein Bild in eine PDF-Datei stempeln

    • Stempeln eines Barcodes auf eine PDF-Datei

    • Stempeln eines QR-Codes auf eine PDF-Datei
  • Wasserzeichen zu einer PDF-Datei hinzufügen

  • Verwendung von Formularen in PDFs

    • Formulare erstellen und bearbeiten
  • Vorhandene Formulare ausfüllen
  • PDF zum Drucken senden

    Erste Schritte

    Beginnen Sie noch heute mit der Verwendung von IronPDF in Ihrem Projekt mit einer kostenlosen Testversion.

    Erster Schritt:
    green arrow pointer

Es gibt zwei Möglichkeiten, die IronPDF-Bibliothek in ein Java-Projekt einzubinden:

  1. IronPDF als Abhängigkeit in einem Maven-konfigurierten Java-Projekt hinzufügen

  2. Laden Sie die IronPDF JAR-Datei herunter und fügen Sie sie manuell dem Klassenpfad des Projekts hinzu.

    Um IronPDF in einem Java-Projekt mit Maven zu installieren, fügen Sie die unten aufgeführten Artefakte in den Abhängigkeitsbereich der pom.xml-Datei des Java-Projekts ein.

<dependency>
   <groupId>com.ironsoftware</groupId>
   <artifactId>com.ironsoftware</artifactId>
   <version>2025.3.6</version>
</dependency>

Entwickler, die das JAR-File manuell verwalten möchten, können die IronPDF-Bibliothek JAR-Datei herunterladen und zu ihrem Projektclasspath hinzufügen.

Tutorial Inhalt

Dokumentstruktur bearbeiten

Manipulation von PDF-Dokumenten

IronPDF erleichtert die Verwaltung von PDFs durch die Möglichkeit, PDFs zu bestimmten Indizes hinzuzufügen, Seiten entweder als Bereich oder einzeln zu kopieren und Seiten mühelos zu löschen. All diese Aufgaben werden nahtlos im Hintergrund erledigt.

Seiten hinzufügen

import java.io.IOException;
import java.nio.file.Paths;
import com.ironsoftware.ironpdf.PdfDocument;

PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
PdfDocument coverPagePdf = PdfDocument.renderHtmlAsPdf("<h1>Cover Page</h1><hr>");
PDF.prependPdf(coverPagePdf);
PDF.saveAs(Paths.get("report_with_cover.pdf"));
JAVA

Seiten kopieren

import java.io.IOException;
import java.nio.file.Paths;
import com.ironsoftware.ironpdf.PdfDocument;

PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
PDF.copyPages(0,1).saveAs("report_highlight.pdf");
JAVA

Seiten löschen

import java.io.IOException;
import java.nio.file.Paths;
import com.ironsoftware.ironpdf.PdfDocument;

PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
PDF.removePages(PageSelection.lastPage()).saveAs(Paths.get("assets/lastPageRemove.pdf"));
JAVA

Deckblatt beifügen

import com.ironsoftware.ironpdf.PdfDocument;  
import com.ironsoftware.ironpdf.headerfooter.HeaderFooterOptions;
import java.io.IOException;  
import java.nio.file.Paths;

// Create a Sample Cover Page using RenderHtmlAsPdf
PdfDocument coverPage = PdfDocument.renderHtmlAsPdf("<h1>This is a Cover Page</h1>");
PdfDocument webpage = PdfDocument.renderUrlAsPdf("https://www.nuget.org/packages/IronPdf/");

// Set the page number of the PDF document to be created to 2.
HeaderFooterOptions headerFooterOptions = new HeaderFooterOptions();
headerFooterOptions.setFirstPageNumber(1);
TextHeaderFooter footer = new TextHeaderFooter();
footer.setLeftText("");
footer.setCenterText("Page {page}");
footer.setRightText("");
webpage.addTextFooter(footer, headerFooterOptions);

// Convert a web page's content to a PDF document.
// Merge the cover page with the web page and save the new PDF to the filesystem.
try {
    PdfDocument.merge(coverPage, webpage).saveAs(Paths.get("assets/cover_page_pdf.pdf"));
} catch (IOException e) {
    throw new RuntimeException(e);
}
JAVA

Erfahren Sie mehr über das Anhängen von Deckblättern in PDF-Dokumenten.

Zusammenführen und Teilen von PDFs

IronPDF for Java vereinfacht mit seiner benutzerfreundlichen API das Zusammenführen mehrerer PDF-Dateien zu einer einzigen oder das Aufteilen einer bestehenden PDF-Datei.

Mehrere vorhandene PDF-Dokumente zu einem einzigen PDF-Dokument zusammenfügen

import com.ironsoftware.ironpdf.PdfDocument;  
import java.io.IOException;  
import java.nio.file.Paths;

String htmlA = "<p> [PDF_A] </p>"
        + "<p> [PDF_A] 1st Page </p>"
        + "<div style = 'page-break-after: always;' ></div>"
        + "<p> [PDF_A] 2nd Page</p>";
String htmlB = "<p> [PDF_B] </p>"
        + "<p> [PDF_B] 1st Page </p>"
        + "<div style = 'page-break-after: always;' ></div>"
        + "<p> [PDF_B] 2nd Page</p>";

PdfDocument pdfA = PdfDocument.renderHtmlAsPdf(htmlA);
PdfDocument pdfB = PdfDocument.renderHtmlAsPdf(htmlB);
PdfDocument merged = PdfDocument.merge(pdfA, pdfB);

merged.saveAs(Paths.get("assets/merged.pdf"));
JAVA

Aufteilen einer PDF-Datei und Extrahieren von Seiten

import com.ironsoftware.ironpdf.PdfDocument;  
import java.io.IOException;  
import java.nio.file.Paths;
PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
PdfDocument copied = PDF.copyPage(0);
copied.saveAs("assets/Split.pdf");
JAVA

Festlegen der benutzerdefinierten Größe von PDF-Dokumenten

IronPDF ermöglicht es Entwicklern, PDF-Dokumente mit nicht standardisierten Abmessungen zu erstellen, die über das herkömmliche A4-Format (21,59 x 27,94 cm) hinausgehen.

import com.ironsoftware.ironpdf.*;  
import com.ironsoftware.ironpdf.render.*;  
import java.io.IOException;  
import java.nio.file.Paths;

String html = "<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit.</p>";  

ChromePdfRenderOptions renderOptions = new ChromePdfRenderOptions();  
renderOptions.setPaperSize(PaperSize.Custom);  

/*  
 * Setting page sizes using different measuring units: 
 * 1. setCustomPaperWidth( width ) / setCustomPaperHeight( height ): for inches 
 * 2. setCustomPaperSizeInCentimeters( width, height ): for centimeters. 
 * 3. setCustomPaperSizeInMillimeters( width, height ): for millimeters 
 * 4. setCustomPaperSizeInPixelsOrPoints( width, height ): for pixels/points 
 */
renderOptions.setCustomPaperSizeInCentimeters(13.97, 13.97);  
PdfDocument.renderHtmlAsPdf(html, renderOptions).saveAs(Paths.get("assets/CustomPaperSize.pdf"));
JAVA

Erfahren Sie mehr Tricks über die benutzerdefinierte Größe der PDFs.

PDF-Ausrichtung festlegen

IronPDF for Java ermöglicht die Änderung der Seitenausrichtung sowohl in neuen als auch in bestehenden PDFs. Standardmäßig werden neue PDFs, die mit IronPDF erstellt werden, im Hochformat eingestellt, aber Entwickler können dies ändern, indem sie eine ChromePdfRenderOptions-Instanz verwenden, wenn sie Inhalte (wie HTML, RTFs und URLs) in PDFs konvertieren.

import com.ironsoftware.ironpdf.PdfDocument;  
import com.ironsoftware.ironpdf.edit.PageSelection;  
import com.ironsoftware.ironpdf.page.PageRotation;  
import com.ironsoftware.ironpdf.render.*;  
import java.io.IOException;  
import java.nio.file.Paths;

// Use the setPaperOrientation method to set rendered PDFs in portrait or landscape orientation.  
// Note: This will only work for newly-created PDFs!  
ChromePdfRenderOptions renderOptions = new ChromePdfRenderOptions();  
renderOptions.setPaperOrientation(PaperOrientation.LANDSCAPE);  
PdfDocument newPdf = PdfDocument.renderUrlAsPdf("https://ironpdf.com", renderOptions);  
newPdf.saveAs(Paths.get("assets/LandscapePdf.pdf"));  

// Use the rotatePage/rotateAllPages methods to adjust the page orientation for existing PDFs  
PdfDocument existingPdf = PdfDocument.fromFile(Paths.get("assets/example.pdf"));  

// Get the orientation of the first page of the existing PDF document.  
PageRotation firstPageRotation = existingPdf.getPagesInfo().get(0).getPageRotation();  
System.out.println(firstPageRotation);  

// Rotate the first page of the document only 90 degrees clockwise.  
existingPdf.rotatePage(PageRotation.CLOCKWISE_90, PageSelection.firstPage());  

// Rotate all pages of the document clockwise.  
existingPdf.rotateAllPages(PageRotation.CLOCKWISE_270);  

existingPdf.saveAs(Paths.get("assets/ExistingPdfRotated.pdf"));
JAVA

Wenn Sie weitere Informationen erhalten möchten, können Sie den Website-Bereich von IronPDF über die Einstellung der PDF-Ausrichtung besuchen.

Benutzerdefinierte Ränder für PDF festlegen

IronPDF erzeugt neue PDFs mit einem Standardrand von 25 mm auf allen Seiten (oben, unten, links, rechts). Entwickler können jedoch mit IronPDF jeden Rand mit spezifischen Messungen anpassen, um die Designanforderungen zu erfüllen.

import com.ironsoftware.ironpdf.PdfDocument;  
import com.ironsoftware.ironpdf.render.ChromePdfRenderOptions;  
import java.io.IOException;  
import java.nio.file.Paths;

// Set Margins (in millimeters)  
ChromePdfRenderOptions renderOptions = new ChromePdfRenderOptions();  
renderOptions.setMarginTop(40);  
renderOptions.setMarginLeft(20);  
renderOptions.setMarginRight(20);  
renderOptions.setMarginBottom(40);  

PdfDocument.renderHtmlFileAsPdf("assets/wikipedia.html", renderOptions).saveAs(Paths.get("assets/MyContent.pdf"));
JAVA

Besuchen Sie die IronPDF-Website, um mehr über das Festlegen benutzerdefinierter Ränder für PDF-Dokumente zu erfahren.

PDF-Dokumente in Bilder umwandeln

IronPDF kann Seiten einer geladenen PDF-Datei, konvertierte Quellinhalte oder eine modifizierte PDF-Datei mit Kopf- und Fußzeilen, Rändern usw. in Bilder exportieren, die in einem Dateisystem gespeichert, in einer Datenbank abgelegt oder über Netzwerke übertragen werden können.

import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.edit.PageSelection;
import com.ironsoftware.ironpdf.image.ToImageOptions;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.List;

PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/composite.pdf"));

// Extract all the pages from the PDF file.
List<BufferedImage> extractedImages = pdf.toBufferedImages();

// With the ToImageOptions object, specify maximum image dimensions for each
// extracted image, as well as their DPI
ToImageOptions rasterOptions = new ToImageOptions();
rasterOptions.setImageMaxHeight(100);
rasterOptions.setImageMaxWidth(100);

// Call the toBufferedImage method along with a PageSelection object to choose the pages from which to
// extract the images
//
// Available PageSelection methods include: allPages, lastPage, firstPage, singlePage(int pageIndex),
// and pageRange(int startingPage, int endingPage)
List<BufferedImage> sizedExtractedImages = pdf.toBufferedImages(rasterOptions, PageSelection.allPages());

// Save all the extracted images to a file location
int i = 1;
for (BufferedImage extractedImage : sizedExtractedImages) {
    String fileName = "assets/images/" + i++ + ".png";
    ImageIO.write(extractedImage, "PNG", new File(fileName));
}
JAVA

Hintergrund und Vordergrund hinzufügen

IronPDF stellt die Methoden addBackground und addForeground zur Verfügung, um ein bestimmtes Hintergrund- oder Vordergrundelement zu PDFs hinzuzufügen. Diese Methoden ermöglichen es Entwicklern, Inhalte aus einer PDF-Datei als Hintergrund oder Vordergrund einer anderen PDF-Datei einzubinden, was die Erstellung von PDF-Sammlungen auf der Grundlage einer gemeinsamen Designvorlage effizient macht.

PDF als Hintergrund hinzufügen

import com.ironsoftware.ironpdf.*;  
import java.io.IOException;  
import java.nio.file.Paths;

// Load background PDFs from the filesystem (or create them programmatically)  
PdfDocument backgroundPdf = PdfDocument.fromFile(Paths.get("assets/MyBackground.pdf"));  

// Render content (HTML, URL, etc) as a PDF Document  
PdfDocument pdf = PdfDocument.renderUrlAsPdf("https://www.nuget.org/packages/IronPdf");  

// Add the background PDFs to the newly-rendered document.  
pdf.addBackgroundPdf(backgroundPdf);  

pdf.saveAs(Paths.get("assets/BackgroundPdf.pdf"));
JAVA

PDF als Vordergrund hinzufügen

import com.ironsoftware.ironpdf.*;  
import java.io.IOException;  
import java.nio.file.Paths;

// Load foreground PDFs from the filesystem (or create them programmatically)  
PdfDocument foregroundPdf = PdfDocument.fromFile(Paths.get("assets/MyForeground.pdf"));  

// Render content (HTML, URL, etc) as a PDF Document  
PdfDocument pdf = PdfDocument.renderUrlAsPdf("https://www.nuget.org/packages/IronPdf");  

// Add the foreground PDFs to the newly-rendered document.  
pdf.addForegroundPdf(foregroundPdf);  

pdf.saveAs(Paths.get("assets/BackgroundForegroundPdf.pdf"));
JAVA

Bilder und Textextraktion

Die umfassenden PDF-Erstellungs- und Bearbeitungsfunktionen von IronPDF umfassen die Möglichkeit, Inhalte mit seinen Inhaltsextraktionsmethoden granular zu extrahieren.

Die Methode extractAllText ist für alle PdfDocument-Objekte verfügbar und gibt einen String zurück, der den gesamten Text im PDF-Dokument enthält. Zusätzlich gibt extractAllImages eine Sammlung aller eingebetteten Bilder im PDF zurück, jedes in Form eines BufferedImage-Objekts. Um die Bilder als rohe Bytes abzurufen, verwenden Sie die extractAllRawImages-Methode.

Auszug Inhalt

PdfDocument pdf = PdfDocument.renderUrlAsPdf("https://unsplash.com/");
String text = pdf.extractAllText();
System.out.println("Text extracted from the website: " + text);
JAVA

Bilder extrahieren

PdfDocument pdf = PdfDocument.renderUrlAsPdf("https://unsplash.com/");
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();
}
JAVA

Dokumenteigenschaften bearbeiten

Hinzufügen und Verwenden von PDF-Metadaten

IronPDF bietet die Möglichkeit, PDF-Metadaten und Sicherheitsfunktionen zu ändern, einschließlich der Erstellung von PDFs, die nur gelesen, nicht gedruckt, passwortgeschützt und verschlüsselt werden können. In IronPDF for Java kann der MetadataManager verwendet werden, um auf die Metadaten eines PDFs zuzugreifen und diese zu bearbeiten. Die MetadataManager-Klasse bietet direkten Zugriff auf Metadateninhalte und ermöglicht es Entwicklern, allgemeine Metadateneigenschaften einfach über Getter und Setter mit denselben Namen zu lesen und zu bearbeiten.

import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.security.PdfPrintSecurity;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.Date;

// Open an encrypted file (or create a new one from HTML)
PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/encrypted.pdf"), "password");

// Edit file metadata
MetadataManager metadata = pdf.getMetadata();
metadata.setAuthor("Satoshi Nakamoto");
metadata.setKeywords("SEO, Friendly");
metadata.setModifiedDate(new Date().toString());

// Edit file security settings
// The code below makes the PDF read only and disallows users to copy, paste, and print
SecurityOptions securityOptions = new SecurityOptions();
securityOptions.setAllowUserCopyPasteContent(false);
securityOptions.setAllowUserAnnotations(false);
securityOptions.setAllowUserPrinting(PdfPrintSecurity.FULL_PRINT_RIGHTS);
securityOptions.setAllowUserFormData(false);
securityOptions.setOwnerPassword("top-secret");
securityOptions.setUserPassword("sharable");

// Change or set the document encryption password
SecurityManager securityManager = pdf.getSecurity();
securityManager.removePasswordsAndEncryption();
securityManager.makePdfDocumentReadOnly("secret-key");

securityManager.setSecurityOptions(securityOptions);
pdf.saveAs(Paths.get("assets/secured.pdf"));
JAVA

Digitale Signaturen

IronPDF for Java ermöglicht die sichere Signatur neuer oder bestehender PDF-Dateien mit X509Certificate2-Zertifikaten im .pfx- oder .p12-Format. Durch das digitale Signieren einer PDF-Datei wird die Authentizität der Datei garantiert, und sie kann ohne ordnungsgemäße Validierung des Zertifikats nicht verändert werden. Dadurch wird die Zuverlässigkeit des Dokuments erhöht.

Wenn Sie nach einer kostenlosen Möglichkeit suchen, ein Signierzertifikat zu erstellen, ist Adobe Reader genau das Richtige für Sie. Befolgen Sie einfach die Anweisungen im Adobe Digital ID-Tutorial.

IronPDF for Java bietet neben dem herkömmlichen digitalen Signierverfahren auch die Möglichkeit, PDFs mit einem handschriftlichen Unterschriftsbild oder einem Firmenstempel zu signieren. Dies erleichtert es Unternehmen, ihre Dokumente zu personalisieren und eine zusätzliche Sicherheitsebene hinzuzufügen.

import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.signature.Signature;
import com.ironsoftware.ironpdf.signature.SignatureManager;
PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));

File path = new File("assets/Ironpdf.pfx");
byte [] certificate = new byte [(int)path.length()];

Signature signature = new Signature(certificate,"1234");

SignatureManager manager = PDF.getSignature();

manager.SignPdfWithSignature(signature);
JAVA

PDFs komprimieren

IronPDF reduziert die Dateigröße von PDFs mit seiner compressImages-Methode in der PdfDocument-Klasse, was es einfach macht, PDFs mit großen Bildern zu komprimieren. Diese Optimierung führt zu erheblichen Einsparungen an Speicherplatz und Kosten bei der Übertragung von PDF-Dateien über E-Mail und andere Kommunikationskanäle.

import com.ironsoftware.ironpdf.*;
import java.io.IOException;  
import java.nio.file.Paths;

PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/document.pdf"));  

// Valid image compression values range from 1 to 100, where 100 represents 100% of the  
// original image quality.  
pdf.compressImages(60);  
pdf.saveAs(Paths.get("assets/document_compressed.pdf"));  

// The second, optional parameter can scale down the image resolution according to its visible  
// size in the PDF document. Note that this may cause distortion with some image configurations  
pdf.compressImages(90, true);  
pdf.saveAs(Paths.get("assets/document_scaled_compressed.pdf"));
JAVA

Bearbeiten von PDF-Inhalten

Kopf- und Fußzeilen hinzufügen

IronPDF bietet die Möglichkeit, benutzerdefinierte HTML-Header und -Footer zu PDFs hinzuzufügen, indem die Klassen ChromePdfRenderOptions und HtmlHeaderFooter verwendet werden. IronPDF ermöglicht benutzerdefinierte Text-Header und -Footer zu PDFs hinzuzufügen durch die TextHeaderFooter-Klasse, die es erlaubt, Text für die linken, rechten oder mittleren Bereiche des Headers/Footers zu spezifizieren. Dies beinhaltet die Verwendung von eingebauten Templatetags wie {date}, {time}, und {page} oder beliebigem anderen gewünschten benutzerdefiniertem Text.

HTML-Kopfzeile und -Fußzeile

import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.headerfooter.HtmlHeaderFooter;
import java.io.IOException;
import java.nio.file.Paths;

PdfDocument pdf = PdfDocument.renderUrlAsPdf("https://ironpdf.com");
// Build a footer using HTML
// Merge Fields are: {page} {total-pages} {url} {date} {time} {html-title} & {pdf-title}
HtmlHeaderFooter footer = new HtmlHeaderFooter();
footer.setMaxHeight(15); // millimeters
footer.setHtmlFragment("<center><i>{page} of {total-pages}</i></center>");
footer.setDrawDividerLine(true);
pdf.addHtmlFooter(footer);
List<PdfDocument> pdfs = new ArrayList<>();

// Build a header using an image asset
// Note the use of BaseUrl to set a relative path to the assets
HtmlHeaderFooter header = new HtmlHeaderFooter();
header.setMaxHeight(20); // millimeters
header.setHtmlFragment("<img src=\"logo.png\" />");
header.setBaseUrl("./assets/");
pdf.addHtmlHeader(header);
try {
    pdf.saveAs(Paths.get("assets/html_headers_footers.pdf"));
} catch (IOException e) {
    throw new RuntimeException(e);
}
JAVA

Text Kopfzeile und Fußzeile

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

Gliederungen und Lesezeichen

Mit dem BookmarkManager können Entwickler eine hierarchische Struktur von Lesezeichen innerhalb eines PDFs erstellen, die es Benutzern ermöglicht, leicht zu verschiedenen Abschnitten im Dokument zu navigieren. Um ein neues Lesezeichen hinzuzufügen, können Entwickler die Methode add verwenden und dabei den Titel und die Seitenzahl des Lesezeichens angeben. Lesezeichen können auch innerhalb anderer Lesezeichen verschachtelt werden, um eine übersichtlichere Struktur zu schaffen.

import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.bookmark.Bookmark;
import com.ironsoftware.ironpdf.bookmark.BookmarkManager;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.List;

// Load an existing PDF from the file system (or create a new one from HTML)
PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/book.pdf"));

// Add top-level bookmarks to pages of the PDF using their page indices
BookmarkManager bookmarks = pdf.getBookmark();
bookmarks.addBookMarkAtEnd("Author's Note", 2);
bookmarks.addBookMarkAtEnd("Table of Contents", 3);
bookmarks.addBookMarkAtEnd("Summary", 10);
bookmarks.addBookMarkAtEnd("References", 12);

// Retrieve a reference to the Summary bookmark so that we can add a sublist of bookmarks to it.
List<Bookmark> bookmarkList = bookmarks.getBookmarks();
Bookmark bookmark = bookmarkList.get(2);
bookmark.AddChildBookmark("Conclusion", 11);

// Save the PDF to the filesystem
pdf.saveAs(Paths.get("assets/bookmarked.pdf"));
JAVA

Hinzufügen und Bearbeiten von Kommentaren

Mit IronPDF können "Haftnotiz"-Stil-Anmerkungen zu bestimmten Seiten eines PDFs mithilfe der Klassen AnnotationManager und AnnotationOptions hinzugefügt werden. Entwickler können textbasierte Anmerkungen erstellen, indem sie Text und (x,y)-Koordinaten als Argumente an den AnnotationOptions-Konstruktor übergeben und anschließend die addTextAnnotation-Methode des AnnotationManager verwenden, um die Anmerkung der gewünschten Seite hinzuzufügen.

import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.annotation.AnnotationIcon;
import com.ironsoftware.ironpdf.annotation.AnnotationManager;
import com.ironsoftware.ironpdf.annotation.AnnotationOptions;
import java.io.IOException;
import java.nio.file.Paths;

// Create a new PDF or load an existing one from the filesystem
PdfDocument pdf = PdfDocument.fromFile(Paths.get("assets/example.pdf"));

// Create an annotation to be placed at a specific location on a page.
AnnotationOptions annotation = new AnnotationOptions(
        "This is a major title",                                // Title of the annotation
        "This is the long 'sticky note' comment content...",    // Content of the annotation
        150,                                                    // x-axis coordinate location
        250                                                     // y-axis coordinate location
);
annotation.setIcon(AnnotationIcon.HELP);
annotation.setOpacity(0.9);
annotation.setPrintable(false);
annotation.setHidden(false);
annotation.setOpen(true);
annotation.setReadonly(true);
annotation.setRotateable(true);

// Add the annotation to a specific page of the PDF
AnnotationManager annotationManager = pdf.getAnnotation();
annotationManager.addTextAnnotation(annotation, 0);

// Save the PDF with the modifications
pdf.saveAs(Paths.get("assets/annotated.pdf"));
JAVA

Stempeln und Wasserzeichen

IronPDF for Java verfügt über eine leistungsfähige API, die umfangreiche Möglichkeiten zum Stempeln und Wasserzeichen von PDFs bietet. Dank der benutzerfreundlichen Oberfläche können Entwickler schnell und einfach Bilder und HTML-Stempel zu ihren PDFs hinzufügen. Egal, ob Sie ein Firmenlogo, einen Vertraulichkeitshinweis oder eine eindeutige Kennung hinzufügen möchten, IronPDF hat alles für Sie. Die API macht es einfach, Ihren PDFs auffällige Stempel hinzuzufügen, die ihnen eine professionelle und persönliche Note verleihen.

Text in eine PDF-Datei stempeln

import java.io.IOException;
import java.nio.file.Paths;

import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.stamp.TextStamper;
import com.ironsoftware.ironpdf.stamp.VerticalAlignment;
PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
TextStamper stamper1 = new TextStamper();
stamper1.setText("Hello World! Stamp One Here!");
stamper1.setFontFamily("Bungee Spice");
stamper1.setUseGoogleFont(true);

stamper1.setFontSize(100);
stamper1.setBold(true);
stamper1.setItalic(false);
stamper1.setVerticalAlignment(VerticalAlignment.TOP);

PDF.applyStamp(stamper1);
JAVA

Ein Bild in eine PDF-Datei stempeln

import java.io.IOException;
import java.nio.file.Paths;
import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.edit.PageSelection;
import com.ironsoftware.ironpdf.stamp.ImageStamper;

PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
ImageStamper imageStamper = new ImageStamper(Paths.get("assets/logo.png"));
// Apply to every page, one page, or some pages
PDF.applyStamp(imageStamper);
PDF.applyStamp(imageStamper, PageSelection.singlePage(2));
PDF.applyStamp(imageStamper, PageSelection.pageRange(0, 2));
JAVA

Stempeln eines Barcodes auf eine PDF-Datei

import java.io.IOException;
import java.nio.file.Paths;

import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.stamp.BarcodeEncoding;
import com.ironsoftware.ironpdf.stamp.BarcodeStamper;
import com.ironsoftware.ironpdf.stamp.HorizontalAlignment;
import com.ironsoftware.ironpdf.stamp.VerticalAlignment;
PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
BarcodeStamper barcodeStamp = new BarcodeStamper("IronPDF", BarcodeEncoding.Code39);

barcodeStamp.setHorizontalAlignment(HorizontalAlignment.LEFT);
barcodeStamp.setVerticalAlignment(VerticalAlignment.BOTTOM);

PDF.applyStamp(barcodeStamp);
JAVA

Stempeln eines QR-Codes auf eine PDF-Datei

import java.io.IOException;
import java.nio.file.Paths;

import com.ironsoftware.ironpdf.PdfDocument;
import com.ironsoftware.ironpdf.stamp.BarcodeEncoding;
import com.ironsoftware.ironpdf.stamp.BarcodeStamper;
import com.ironsoftware.ironpdf.stamp.HorizontalAlignment;
import com.ironsoftware.ironpdf.stamp.VerticalAlignment;
PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
BarcodeStamper QRStamp = new BarcodeStamper("IronPDF", BarcodeEncoding.QRCode);
QRStamp.setHeight(50);
QRStamp.setWidth(50);
QRStamp.setHorizontalAlignment(HorizontalAlignment.LEFT);
QRStamp.setVerticalAlignment(VerticalAlignment.BOTTOM);
PDF.applyStamp(QRStamp);
JAVA

Wasserzeichen zu einer PDF-Datei hinzufügen

import java.io.IOException;
import java.nio.file.Paths;

import com.ironsoftware.ironpdf.PdfDocument;

PdfDocument PDF = PdfDocument.fromFile(Paths.get("assets/sample.pdf"));
String html = "<h1> Example Title <h1/>";
int watermarkOpacity = 30;
PDF.applyWatermark(html, watermarkOpacity);
JAVA

Formulare in PDFs verwenden

IronPDF for Java bietet Entwicklern eine unkomplizierte und effiziente Möglichkeit, Werte aus Formulartextfeldern in einem PDF-Dokument zu setzen und abzurufen. Mit der FormManager-Klasse können Entwickler einfach die setFieldValue-Methode aufrufen und den Namen des gewünschten Textfeldes sowie den auszufüllenden Wert angeben.

Um den Wert eines Formularfeldes abzurufen, kann der Entwickler direkt über die Sammlung von FormField-Objekten im FormManager auf das Feld zugreifen, indem er den entsprechenden Namen oder Index verwendet. Dieses Maß an Kontrolle über Formularfelder macht es Entwicklern leicht, mit dynamischen und interaktiven PDF-Formularen zu arbeiten.

Formulare erstellen und bearbeiten

import com.ironsoftware.ironpdf.PdfDocument;  
import com.ironsoftware.ironpdf.render.ChromePdfRenderOptions;  
import java.io.IOException;  
import java.nio.file.*;

// #1 Use Case: Create a PDF Form from HTML Form Markup  
Path outputLocation = Paths.get("assets/BasicForm.pdf");  
String formHTML = "<html>"  
  + "<body>"  
  + "<h2>Editable PDF  Form</h2>"  
  + "<form>"  
  + "First name: <br> <input type='text' name='firstname' value=''> <br>"  
  + "Last name: <br> <input type='text' name='lastname' value=''>"  
  + "</form>"  
  + "</body>"  
  + "</html>";  

ChromePdfRenderOptions renderOptions = new ChromePdfRenderOptions();  
renderOptions.setCreatePdfFormsFromHtml(true);  
PdfDocument.renderHtmlAsPdf(formHTML, renderOptions).saveAs(outputLocation);  

// #2 UseCase: Writing Values to the PDF Form  
PdfDocument form = PdfDocument.fromFile(outputLocation);  

// Set the value of the firstname input field.  
form.getForm().setFieldValue("firstname", "Minnie");  

// Set the value of the lastname input field.  
form.getForm().setFieldValue("lastname", "Mouse");  

// Save the changes to the PDF Form.  
form.saveAs(Paths.get("assets/BasicForm_Filled.pdf"));
JAVA

Vorhandene Formulare ausfüllen

import com.ironsoftware.ironpdf.PdfDocument;  
import com.ironsoftware.ironpdf.render.ChromePdfRenderOptions;  
import java.io.IOException;  
import java.nio.file.*;

PdfDocument form = PdfDocument.fromFile("assets/pdfform.pdf");  

// Set the value of the firstname input field.  
form.getForm().setFieldValue("firstname", "Minnie");  

// Set the value of the lastname input field.  
form.getForm().setFieldValue("lastname", "Mouse");  

// Save the changes to the PDF Form.  
form.saveAs(Paths.get("assets/BasicForm_Filled.pdf"));
JAVA

PDF zum Drucken senden

Die Druckmethode von IronPDF ermöglicht es Entwicklern, das Drucken von PDFs einfach in ihre Anwendungen zu integrieren. Durch den einfachen Aufruf der Druckmethode wird der Druckdialog des Betriebssystems geöffnet, in dem der Benutzer die Möglichkeit hat, Druckeinstellungen wie Drucker, Papierformat und Anzahl der Kopien anzupassen.

import com.ironsoftware.ironpdf.PdfDocument;
import java.awt.print.PrinterException;

PdfDocument pdf = PdfDocument.renderHtmlAsPdf("<h1>Created with IronPDF!</h1>");
try {
    pdf.print();
} catch(PrinterException exception) {
    System.out.println("Failed to print PDF");
    exception.printStackTrace();
}
JAVA
Chaknith Bin
Chaknith Bin
  Jetzt mit dem Ingenieurteam chatten
Software-Ingenieur
Chaknith arbeitet an IronXL und IronBarcode. Er hat tiefgehende Expertise in C# und .NET und hilft, die Software zu verbessern und Kunden zu unterstützen. Seine Erkenntnisse aus Benutzerinteraktionen tragen zu besseren Produkten, Dokumentation und einem insgesamt besseren Erlebnis bei.