PDF in Java bearbeiten (vollständige Anleitung)
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 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. Lesen Sie zuerst das HTML-zu-PDF-Tutorial, 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
- Java-Bibliothek zur Bearbeitung von PDF-Dateien installieren
- Bearbeiten der Dokumentstruktur mit Zusammenführen, Löschen und Teilen von PDF in Java
- Hintergrund und Vordergrund mit mehreren Ebenen überlagern
- Hinzufügen von benutzerdefinierten Kopf- und Fußzeilen, Stempeln und Lesezeichen
- 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
Beginnen Sie noch heute mit der Verwendung von IronPDF in Ihrem Projekt mit einer kostenlosen Testversion.
Es gibt zwei Möglichkeiten, die IronPDF-Bibliothek in ein Java-Projekt einzubinden:
IronPDF als Abhängigkeit in einem Maven-konfigurierten Java-Projekt hinzufügen
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.11.4</version>
</dependency>
Entwickler, die es vorziehen, die JAR-Datei manuell zu verwalten, können">die JAR-Datei der IronPDF-Bibliothek herunterladen und fügen es dem Klassenpfad ihres Projekts hinzu.
Laden Sie die IronPDF JAR-Datei direkt vondas IronPDF 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"));
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");
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"));
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);
}
Erfahren Sie mehr überanhä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"));
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");
Festlegen 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"));
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"));
Weitere Informationen finden Sie auf der Website von IronPDF unterpDF-Ausrichtung einstellen.
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"));
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));
}
Hintergrund und Vordergrund hinzufügen
IronPDF bietet die Methoden addBackground
und addForeground
fürhinzufügen eines bestimmten Hintergrund- oder Vordergrundelements 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"));
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"));
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);
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();
}
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"));
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);
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"));
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);
}
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);
}
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"));
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"));
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);
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));
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);
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);
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);
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 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"));
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"));
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();
}