1. IronPDF
  2. Anleitungen
  3. PDFs bearbeiten

PDF in Java bearbeiten (vollständige Anleitung)

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 Inhalt und Struktur bestehender PDF-Dokumente mit IronPDF bearbeiten können. Dazu gehören PDF-Dokumente, die mit IronPDFs HTML-Konvertierungsfunktionen aus HTML gerendert wurden, sowie PDFs, die mit anderen Anwendungen und Softwarebibliotheken von Drittanbietern erstellt wurden

Ein Lernprogramm fürbearbeitung von PDF-Dokumenten in C#.NET und VB.NET ist ebenfalls verfügbar.

In diesem Tutorial wird davon ausgegangen, dass der Leser bereits weiß, wie man IronPDF verwendet, umhTML-Inhalte in PDF-Dateien umwandeln. Wenn Sie mit dieser Funktion nicht vertraut sind, sollten Sie zuerst das HTML-to-PDF-Tutorial lesen, bevor Sie mit diesem Tutorial fortfahren(oder eine Auffrischung der grundlegenden Arbeitsabläufe benötigen).

Wie man PDF-Dateien in Java bearbeitet

  1. Java-Bibliothek zur Bearbeitung von PDF-Dateien installieren
  2. Bearbeiten der Dokumentstruktur mit Zusammenführen, Löschen und Teilen von PDF in Java
  3. Hintergrund und Vordergrund mit mehreren Ebenen überlagern
  4. Kopf- und Fußzeile, Stempel und Lesezeichen individuell anpassen
  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
  • Dokumenteneigenschaften 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

    Java Maven-Bibliothek für PDF

    Installieren mit Maven

    <dependency>
       <groupId>com.ironsoftware</groupId>
       <artifactId>ironpdf</artifactId>
       <version>2024.9.1</version>
    </dependency>
    search.maven.org/artifact/com.ironsoftware/ironpdf
    oder
    Java PDF JAR

    Herunterladen JAR

      JAR herunterladen

    Manuelle Installation in Ihr Projekt

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>2024.9.1</version>
</dependency>

Entwickler, die es vorziehen, die JAR-Datei manuell zu verwalten, können!!--inline-anchor_ironpdfjava-fatjar{die JAR-Datei der IronPDF-Bibliothek herunterladen}--!! und fügen sie dem Klassenpfad ihres Projekts hinzu.

Laden Sie die IronPDF JAR-Datei direkt von hier (oder aus dem Maven Repository).

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 überdeckblatt in PDF-Dokumenten anhängen.

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

Einstellen der benutzerdefinierten Größe von PDF-Dokumenten

IronPDF ermöglicht es Entwicklern, PDF-Dokumente mit nicht standardmäßigen Abmessungen zu erstellen, die über das herkömmliche A4-Format hinausgehen(8½ mal 11 Zoll oder 21,59 mal 27,94 cm).

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 über die Tricks derindividuelle 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 mit IronPDF erstellte PDF-Dateien im Hochformat erstellt. Entwickler können dies jedoch ändern, indem sie beim Konvertieren von Inhalten eine ChromePdfRenderOptions-Instanz verwenden(wie HTML, RTFs und URLs) in PDFs umwandeln.

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 wünschen, können Sie die IronPDF-Website unterpDF-Ausrichtung festlegen.

Benutzerdefinierte Ränder für PDF festlegen

IronPDF erstellt neue PDF-Dateien 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 und erfahren Sie mehr überbenutzerdefinierte Ränder für PDF-Dokumente festlegen.

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 bietet die Methoden addBackground und addForeground fürhinzufügen von bestimmten Hintergrund- oder Vordergrundelementen zu PDFs. 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

IronPDFs umfassende Funktionen zur Erstellung und Bearbeitung von PDF-Dateien bieten unter anderem die Möglichkeitinhalt extrahieren mit seinen Methoden zur Extraktion von Inhalten zu verfeinern.

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

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öglichkeitpDF-Metadaten ändern und Sicherheitsfunktionen, einschließlich der Möglichkeit, PDFs schreibgeschützt, nicht druckbar, passwortgeschützt und verschlüsselt zu machen. In IronPDF for Java kann der MetadataManager verwendet werden, um auf die Metadaten einer PDF-Datei zuzugreifen und diese zu bearbeiten. Die Klasse "MetadataManager" bietet direkten Zugriff auf Metadateninhalte und ermöglicht es Entwicklern, gängige Metadateneigenschaften über gleichnamige Getter und Setter einfach 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 das sichere Signieren neuer oder vorhandener PDF-Dateien mit digitalen Zertifikaten des Typs "X509Certificate2" 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. Folgen Sie einfach den Anweisungen in derAdobe Digital ID-Anleitung.

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 Größe von PDF-Dateien mit der Methode compressImages in der Klasse PdfDocument, was die Komprimierung von PDFs mit großen Bildern erleichtert. 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öglichkeitbenutzerdefinierte HTML-Kopf- und Fußzeilen hinzufügenzu PDFs mit den Klassen ChromePdfRenderOptions und HtmlHeaderFooter. IronPDF ermöglichtkopf- und Fußzeilen mit benutzerdefiniertem Text zu PDFs durch die Klasse "TextHeaderFooter" hinzugefügt werden, die es ermöglicht, Text für den linken, rechten oder mittleren Bereich der Kopf-/Fußzeile festzulegen. Dazu gehört auch die Verwendung von eingebauten Template-Tags wie {datum}, {zeit}und{seite} oder ein anderer gewünschter 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 coverpage  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 vonlesezeichen in einer PDF-Dateidadurch können die Benutzer leicht zu verschiedenen Abschnitten innerhalb des Dokuments 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

IronPDF ermöglicht das Hinzufügen von "Haftnotizen"anmerkungen zu bestimmten Seiten einer PDF-Datei mit Hilfe der Klassen AnnotationManager und AnnotationOptions. Entwickler können textbasierte Anmerkungen erstellen, indem sie Text und(x,y) koordinaten als Argumente für den Konstruktor AnnotationOptions, dann verwenden Sie die Methode addTextAnnotation des AnnotationManager, um die Anmerkung zur 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 Klasse FormManager können Entwickler einfach die Methode setFieldValue aufrufen und den Namen des gewünschten Textfeldes und den zu füllenden Wert angeben.

Um den Wert eines Formularfeldes abzurufen, kann der Entwickler direkt auf das Feld über die Sammlung von FormManager-Objekten 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 Use Case: 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

IronPDFs Druckmethode ermöglicht es Entwicklern, auf einfache WeisepDF-Druck integrieren 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