close

Articles Home » Programming Languages » Creating PDF Documents in Java using iText

Creating PDF Documents in Java using iText

Introduction

Creating PDFs programmatically is a common requirement in software projects, ranging from generating reports to creating complex forms. While there are multiple languages and libraries that can help you achieve this, Java stands out for its robustness and versatility. This tutorial will guide you through the process of generating PDF documents in Java using the iText library.

Portable Document Format (PDF) is a file format that captures all the elements of a printed document as an electronic image. Created by Adobe, PDFs are particularly useful for sharing and preserving documents and graphics. They can be opened on any hardware or operating system without altering the document’s appearance, making the format both universal and indispensable.

Why Choose Java for PDF Creation

  1. Portability: Java runs on virtually any machine, without needing any particular software or hardware. This makes it ideal for a PDF generation solution that’s universal.
  2. Robust Libraries: Java offers a vast ecosystem of libraries for PDF creation, including iText, making it easier to add complex features like tables, lists, and images.
  3. Scalability: Being an object-oriented language, Java allows for scalable application design, which is beneficial for PDF generation tasks that may require scalability in the future.
  4. Strong Community Support: With one of the largest developer communities, finding help or resources related to Java PDF libraries is much easier compared to other languages.

What is iText and Why Use it

iText is an open-source library that allows you to create and manipulate PDF files in Java. Here are some reasons why iText is a go-to choice:

  1. Ease of Use: iText provides high-level constructs that make it straightforward to generate complex PDFs.
  2. Feature-Rich: From basic PDF creations to more advanced features like digital signatures, merging/splitting PDFs, or creating form fields, iText supports it all.
  3. Documentation and Community: iText has extensive documentation and an active community, making it easier to find solutions to any issues or queries you might have.
  4. Commercial Support: For enterprise applications, iText offers commercial licenses that include extra features and dedicated support.

What Will You Learn in This Tutorial

In this tutorial, you’ll start with the basics of setting up a Java project and integrating the iText library. From there, you’ll learn:

  • The fundamentals of the iText library and PDF structure
  • How to create simple PDF documents with text
  • Adding images, tables, and lists to your PDF
  • Using advanced features like hyperlinks and PDF forms
  • Best practices and tips for optimizing your PDF generation tasks

Prerequisites

Before diving into the tutorial, make sure you have the following:

  • Java Development Kit (JDK): Installed and configured on your machine. This tutorial will use Java 11, but most of the code should be compatible with other versions.
  • Integrated Development Environment (IDE): While you can use any Java IDE, this tutorial will use examples in Eclipse.
  • Basic Java Knowledge: Familiarity with Java syntax and object-oriented programming concepts will be beneficial.
  • Maven or Gradle: For dependency management, either Maven or Gradle will be needed. Examples will be shown for both.

Getting Started

Before you can begin creating PDF documents in Java using iText, you need to set up your development environment. This involves installing Java, choosing an Integrated Development Environment (IDE), and setting up a new Java project.

Setting up the Development Environment

A properly configured development environment ensures that you can focus on writing code rather than troubleshooting setup issues. Below are the steps to get everything up and running.

Installing Java

  • Download JDK: Visit the Oracle website or Adoptium to download the Java Development Kit (JDK). This tutorial uses Java 11, but you can download other versions based on your needs.
  • Install JDK: Run the installer and follow the on-screen instructions to install Java.
  • Set Environment Variables:
    • Windows: Add the path to javac to the System Variable Path. Usually, it is in the bin directory of where Java is installed.
    • Linux/Mac: Use the export command to set the JAVA_HOME and PATH variables.
  • Verify Installation: Open a terminal and run java -version and javac -version to confirm that Java has been successfully installed.

IDE Recommendations

There are numerous IDEs available for Java development, each with its own set of features and advantages:

  • Eclipse: Free, open-source, and highly extensible. Great for both beginners and advanced users.
  • IntelliJ IDEA: Offers a free community version and a paid ultimate version. Known for its intelligent code assistance and extensive plugin ecosystem.
  • NetBeans: Free and open-source. It is straightforward to use and good for beginners.
  • JDeveloper: Provided by Oracle, it offers various integrated features but is less commonly used compared to the above options.
  • Visual Studio Code: Lightweight and highly extensible, good for quick development tasks but lacks some of the Java-specific features found in full-fledged IDEs.

Choose the one that best suits your needs and download it.

Creating a New Java Project

Once your IDE is set up, you need to create a new Java project. The steps vary slightly between IDEs but generally involve:

  • Open IDE: Launch your chosen IDE and navigate to File > New > Java Project (the exact terminology may vary).
  • Project Name: Give your project a name, for example, JavaPDFWithiText.
  • Configure Settings:
    • JDK Version: Make sure to select the installed JDK version.
    • Project Layout: Choose the appropriate project layout (e.g., Maven or Gradle for dependency management).
  • Finish: Click on the finish button, and the IDE will create a new Java project with a default structure.
  • Add iText Dependency: You’ll need to add the iText library to your project. The next section will cover this in detail.

Installing iText

Once your Java development environment is set up and your new Java project is created, the next step is to install the iText library. iText provides a range of functionalities to create and manipulate PDFs, and integrating it into your project can be done in several ways: Direct Download, Using Maven, or Using Gradle.

Direct Download

  • Download JAR files: Visit the iText website or their GitHub repository to download the necessary JAR files.
  • Add to Project:
    • Eclipse: Right-click on your project > Build Path > Configure Build Path > Libraries > Add External JARs and select the downloaded JAR files.
    • IntelliJ IDEA: Go to File > Project Structure > Modules > + > JARs or directories and select the downloaded JAR files.
  • Apply Changes: Click on OK or Apply to confirm the changes.

Using Maven

If you have created a Maven project, adding iText is as simple as adding a dependency to your pom.xml file.

  • Open pom.xml: Navigate to the pom.xml file in your project directory.
  • Add Dependency: Add the following dependency code to the <dependencies> section.
<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext7-core</artifactId>
    <version>7.x.x</version>
</dependency>
Code language: HTML, XML (xml)
  • Save and Build: Save the pom.xml file. Maven should automatically download the iText library and add it to your project. If it doesn’t, try running mvn clean install.

Using Gradle

If you’re using Gradle, you can also easily add iText as a dependency.

  • Open build.gradle: Navigate to the build.gradle file in your project directory.
  • Add Dependency: Add the following code to the dependencies section.
implementation 'com.itextpdf:itext7-core:7.x.x'
Code language: Gradle (gradle)
  • Sync and Build: Save the build.gradle file and click on the Sync or Refresh button that appears in your IDE. Gradle will download the iText library and add it to your project.

You’ve successfully installed iText through one of these methods, and you’re now ready to move forward with creating PDF documents in Java using iText.

Basic Concepts

Understanding the basic architecture and core components of the iText library is crucial for effective PDF manipulation. In this section, we will go through the iText library architecture, identify core classes and interfaces, and explore how iText interacts with PDF documents.

iText Library Architecture

The iText library is modular, consisting of several components that serve different purposes. Here’s a brief rundown of the main modules:

  1. iText Core: The central component, responsible for PDF creation and manipulation.
  2. iText PdfHTML: For converting HTML to PDF.
  3. iText Pdf2Data: For extracting data from PDFs.
  4. iText PdfCalligraph: For advanced typography features.

For this tutorial, we will primarily focus on the iText Core component, which provides all the necessary features for PDF creation and manipulation.

Core Classes and Interfaces

iText contains several core classes and interfaces that you’ll frequently use:

  1. Document: This class represents a PDF document. You can add content like paragraphs, lists, and tables to a Document object.
  2. PdfWriter: Responsible for writing the PDF file. You’ll initialize this class with an output stream pointing to the file location where you want to create or modify a PDF.
  3. PdfReader: Allows you to read an existing PDF file. Useful for PDF manipulation tasks like merging, splitting, or adding watermarks.
  4. PdfDocument: This class acts as a bridge between Document and PdfWriter/PdfReader. It’s used for more complex operations like modifying existing documents.
  5. Paragraph, List, Table: These classes are used to add structured data into the PDF document.
  6. Image: The class to use for adding images to your PDF document.

Here’s a simple way these core classes interact:

PdfWriter writer = new PdfWriter("path/to/output.pdf");
PdfDocument pdf = new PdfDocument(writer);
Document document = new Document(pdf);

// Add content using Paragraph, List, Table, Image etc.
document.add(new Paragraph("Hello World"));

document.close();
Code language: Java (java)

How iText Interacts with PDF

iText operates as an abstraction layer between you and the PDF file format, providing a straightforward way to create PDFs programmatically. When you create a Document object and add elements like text, images, or tables, iText translates these high-level objects into the low-level PDF instructions that define how they should be displayed.

Here is a simplified breakdown:

  1. Initialize: You first initialize a Document object, often linked with a PdfWriter to create a new PDF or a PdfReader to modify an existing one.
  2. Add Elements: You add high-level elements like text, lists, tables, etc., to the Document.
  3. Compile: When you close the Document, iText converts all the added elements into a PDF, following the PDF specification.
  4. Output: The finalized PDF is then written to the disk by the PdfWriter.

Document Fundamentals

Understanding the Document object and its role in PDF generation is crucial when working with the iText library. In this section, we will delve into what a Document object is and how to create a simple PDF document using iText.

What is a Document Object

In iText, the Document class represents a PDF document. It acts as a container for all the content that you wish to add to your PDF file. This content can range from simple text paragraphs to complex elements like tables, lists, images, and even other PDFs.

A Document object doesn’t work in isolation. It’s often used in conjunction with other core classes like PdfWriter for writing PDF files and PdfDocument for more complex tasks involving existing PDFs.

Here are some key functionalities provided by the Document class:

  1. Content Addition: Allows you to add content elements like text, images, and tables.
  2. Layout Control: Helps manage the layout of the added elements in the PDF pages.
  3. Document Metadata: Lets you set properties like the author, title, and creation date of the PDF.

How to Create a Simple PDF Document

Creating a simple PDF document involves several steps, starting from setting up a new Java class to writing code that initializes the iText library components.

Step 1: Create a New Java Class

Create a new Java class in your project, name it SimplePdfGeneration or something similar.

Step 2: Import Required Packages

Import the necessary iText classes at the beginning of your Java class.

import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;
Code language: Java (java)

Step 3: Initialize PdfWriter and PdfDocument

You first need to initialize the PdfWriter and PdfDocument classes. The PdfWriter requires the path where the PDF will be saved.

PdfWriter writer = new PdfWriter("path/to/your/output.pdf");
PdfDocument pdf = new PdfDocument(writer);
Code language: Java (java)

Step 4: Initialize Document and Add Content

Now, initialize the Document object with the PdfDocument instance and add content to it.

Document document = new Document(pdf);
document.add(new Paragraph("Hello, world!"));
Code language: Java (java)

Step 5: Close the Document

Always remember to close the Document object to ensure that all the changes are written to the PDF.

document.close();
Code language: Java (java)

Full Code Example

Here’s how your SimplePdfGeneration class might look:

import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;

public class SimplePdfGeneration {
    public static void main(String[] args) {
        PdfWriter writer = new PdfWriter("path/to/your/output.pdf");
        PdfDocument pdf = new PdfDocument(writer);
        Document document = new Document(pdf);

        document.add(new Paragraph("Hello, world!"));

        document.close();
    }
}
Code language: JavaScript (javascript)

Run this class, and you should find a new PDF document at the specified path, containing a simple paragraph that says “Hello, world!”

You’ve now learned the fundamental concept of what a Document object is in iText and how to create a simple PDF document.

First PDF Document with iText

Creating your first PDF with iText is an important milestone. It gives you the foundation you need to understand more advanced features and functionalities later on. This section will cover initializing the Document and PdfWriter classes, provide a code example for creating a basic PDF, and explain the role of Document and PdfWriter in the PDF creation process.

Initialize Document and PdfWriter

Before you can begin adding content to your PDF, you must initialize the Document and PdfWriter classes.

  • PdfWriter: Responsible for writing the PDF file. When you initialize this class, you specify the file path where you want the PDF to be saved.
  • Document: This class acts as a container where you will add the content of your PDF, whether it’s text, images, lists, or tables.

The PdfDocument class connects these two, acting as a bridge between the Document and PdfWriter.

Here’s a brief code snippet that demonstrates this initialization:

PdfWriter writer = new PdfWriter("path/to/your/output.pdf");
PdfDocument pdf = new PdfDocument(writer);
Document document = new Document(pdf);
Code language: Java (java)

Code Example: Creating a Basic PDF

Let’s combine these components to create a basic PDF document with a simple paragraph.

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;

public class FirstPdfWithiText {
    public static void main(String[] args) {
        // Initialize PdfWriter
        PdfWriter writer = new PdfWriter("path/to/your/output.pdf");

        // Initialize PdfDocument
        PdfDocument pdf = new PdfDocument(writer);

        // Initialize Document
        Document document = new Document(pdf);

        // Add a Paragraph to the Document
        document.add(new Paragraph("This is my first PDF document created using iText."));

        // Close the Document
        document.close();
    }
}
Code language: Java (java)

Run this code, and it will generate a PDF with a single paragraph stating “This is my first PDF document created using iText.”

Explaining the Role of Document and PdfWriter

  • Document: Think of the Document as a virtual canvas where you add elements like paragraphs, lists, images, and tables. It holds the logical structure of your PDF. When you add an element to the Document, you’re essentially queuing it for rendering within the PDF pages.
  • PdfWriter: While the Document handles the logical structure, PdfWriter is responsible for translating these logical elements into a byte stream that conforms to the PDF specification. It writes the actual PDF file to disk, including all the content, metadata, and sometimes even optimizations.

In summary, the Document is where you organize your content, while PdfWriter handles the actual file writing operations. The PdfDocument class acts as the intermediary, converting the logical structure of the Document to an actual PDF file via PdfWriter.

You’ve just created your first PDF using iText in Java. This fundamental knowledge will serve as the stepping stone for more advanced PDF generation tasks, which we will explore in the subsequent sections of this tutorial.

Adding Basic Elements

Once you understand how to create a basic PDF document using iText, the next logical step is to learn how to add various basic elements to your PDF. Text is usually the most common type of content you’ll be adding, so we’ll start there. In this section, we’ll discuss how to add text to your PDF, and provide code examples for adding paragraphs, phrases, and chunks.

Adding Text

Text in iText is usually added through high-level elements like Paragraph, Phrase, and Chunk. These classes make it easier to manage text by providing various methods for styling, alignment, and layout.

  • Paragraph: Represents a paragraph of text. You can set properties like alignment, indentation, and spacing.
  • Phrase: Represents a series of Chunk objects and allows for basic styling like font and size. However, it doesn’t provide layout features like paragraph spacing or indentation.
  • Chunk: The smallest significant part of text that can be added to a document. It’s essentially a string with a certain style applied to it.

Code Example: Adding Paragraphs, Phrases, and Chunks

Here’s a Java program illustrating how to use these three classes:

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;
import com.itextpdf.layout.element.Phrase;
import com.itextpdf.layout.element.Text;

public class AddBasicElements {
    public static void main(String[] args) {
        // Initialize PdfWriter
        PdfWriter writer = new PdfWriter("path/to/your/output.pdf");

        // Initialize PdfDocument
        PdfDocument pdf = new PdfDocument(writer);

        // Initialize Document
        Document document = new Document(pdf);

        // Adding a Paragraph
        Paragraph paragraph = new Paragraph("This is a paragraph.");
        document.add(paragraph);

        // Adding a Phrase
        Phrase phrase = new Phrase("This is a phrase.");
        document.add(new Paragraph(phrase));

        // Adding a Chunk
        Text chunk = new Text("This is a chunk.");
        document.add(new Paragraph(chunk));

        // Close the Document
        document.close();
    }
}
Code language: JavaScript (javascript)

In this code example, we start by adding a Paragraph to the document. After that, we introduce a Phrase wrapped in a Paragraph for layout. Finally, we add a Text (equivalent to a chunk in iText terminology) to a Paragraph.

Remember, wrapping Phrase and Text objects in a Paragraph is optional but commonly done for better layout control.

Text Manipulation

In any document, styling the text is essential for better readability and aesthetic appeal. iText provides a rich set of options to manipulate text styles including font selection, size, and various other attributes like bold, italic, and underlining. In this section, we’ll discuss how to set fonts and styles, explore built-in fonts, learn to use external fonts, and provide a code example for styling text.

Fonts and Styles

In iText, you can set fonts and styles using the PdfFont class. Once you’ve initialized a PdfFont object, you can associate it with text elements like Paragraph, Phrase, or Text.

To set the font style attributes such as bold or italic, you’ll usually need to select an appropriate variant of the font that supports the style you’re looking for.

Built-in Fonts

iText comes with a few built-in standard Type 1 fonts, like Helvetica and Times-Roman, which you can use without needing to import any external files. These can be useful for basic projects where custom fonts are not a requirement.

Here’s a sample code snippet to set a built-in font:

import com.itextpdf.kernel.font.PdfFont;
import com.itextpdf.kernel.font.PdfFontFactory;

PdfFont font = PdfFontFactory.createFont();
Code language: Java (java)

Using External Fonts

For more customization, you can use external TrueType fonts (TTF) or OpenType fonts (OTF). To do this, you’ll need to import the external font file into your Java project and then use iText’s PdfFontFactory to create a PdfFont object.

Here’s a sample code snippet to set an external font:

import com.itextpdf.kernel.font.PdfFont;
import com.itextpdf.kernel.font.PdfFontFactory;

PdfFont customFont = PdfFontFactory.createFont("path/to/your/font.ttf", true);

Code language: Java (java)

Code Example: Styling Text

Let’s create a Java program that demonstrates text styling with built-in and external fonts.

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;
import com.itextpdf.kernel.font.PdfFont;
import com.itextpdf.kernel.font.PdfFontFactory;

public class TextStylingExample {
    public static void main(String[] args) {
        // Initialize PdfWriter
        PdfWriter writer = new PdfWriter("path/to/your/styled_output.pdf");

        // Initialize PdfDocument
        PdfDocument pdf = new PdfDocument(writer);

        // Initialize Document
        Document document = new Document(pdf);

        // Using built-in font
        PdfFont helveticaBold = PdfFontFactory.createFont(com.itextpdf.io.font.constants.StandardFonts.HELVETICA_BOLD);
        Paragraph para1 = new Paragraph("This is text in Helvetica Bold.")
                .setFont(helveticaBold)
                .setFontSize(12);
        document.add(para1);

        // Using external font
        try {
            PdfFont customFont = PdfFontFactory.createFont("path/to/your/font.ttf", true);
            Paragraph para2 = new Paragraph("This is text in a custom font.")
                    .setFont(customFont)
                    .setFontSize(14);
            document.add(para2);
        } catch (Exception e) {
            e.printStackTrace();
        }

        // Close the Document
        document.close();
    }
}
Code language: Java (java)

In this example, the first paragraph uses a built-in Helvetica Bold font, and the second paragraph uses an external font file. You can replace the “path/to/your/font.ttf” with the actual path to the TTF file you’d like to use.

Text Alignment and Spacing

Proper alignment and spacing are crucial for laying out text in a way that’s both visually appealing and easy to read. iText provides a comprehensive set of methods to control these aspects of your PDF document. In this section, we will cover how to set horizontal and vertical alignment and handle spacing in your text. We’ll also provide a code example to demonstrate these capabilities.

Horizontal Alignment

Horizontal alignment specifies the alignment of text within the horizontal space of its container. The most commonly used options are left, center, and right alignment.

In iText, you can use the setTextAlignment method on a Paragraph object to set its horizontal alignment. The method takes a constant like TextAlignment.LEFT, TextAlignment.CENTER, or TextAlignment.RIGHT.

Paragraph leftAlignedParagraph = new Paragraph("This is left-aligned.")
    .setTextAlignment(TextAlignment.LEFT);
Code language: Java (java)

Vertical Alignment

Vertical alignment is often less frequently manipulated than horizontal alignment but can still be important, especially in the context of tables and specific layout requirements.

In iText, vertical alignment can often be set using the setVerticalAlignment method on elements like table cells.

Cell cell = new Cell();
cell.add(new Paragraph("Vertical Center Aligned"))
    .setVerticalAlignment(VerticalAlignment.MIDDLE);
Code language: Java (java)

Code Example: Text Alignment and Spacing

Here’s a simple Java program demonstrating the different alignment options and how to manipulate spacing.

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;
import com.itextpdf.layout.property.TextAlignment;
import com.itextpdf.layout.property.VerticalAlignment;
import com.itextpdf.layout.element.Cell;
import com.itextpdf.layout.element.Table;

public class TextAlignmentAndSpacingExample {
    public static void main(String[] args) {
        // Initialize PdfWriter
        PdfWriter writer = new PdfWriter("path/to/your/alignment_example.pdf");

        // Initialize PdfDocument
        PdfDocument pdf = new PdfDocument(writer);

        // Initialize Document
        Document document = new Document(pdf);

        // Horizontal Alignments
        Paragraph leftAligned = new Paragraph("This is left-aligned.")
            .setTextAlignment(TextAlignment.LEFT);
        Paragraph centerAligned = new Paragraph("This is center-aligned.")
            .setTextAlignment(TextAlignment.CENTER);
        Paragraph rightAligned = new Paragraph("This is right-aligned.")
            .setTextAlignment(TextAlignment.RIGHT);

        // Add them to the document
        document.add(leftAligned);
        document.add(centerAligned);
        document.add(rightAligned);

        // Vertical Alignment
        Table table = new Table(1); // Creating a one-column table
        Cell cell = new Cell();
        cell.add(new Paragraph("This is vertically centered."))
            .setVerticalAlignment(VerticalAlignment.MIDDLE);
        table.addCell(cell);

        // Add table to document
        document.add(table);

        // Close the Document
        document.close();
    }
}
Code language: Java (java)

In this example, the program first demonstrates the three horizontal alignments: left, center, and right. Then it uses a one-column table to show how to set vertical alignment within a cell. The text within the cell is vertically centered.

Working with Images

Adding images to your PDF documents can enhance their appeal and make them more informative. iText provides an easy and efficient way to embed images in various formats. In this section, we’ll discuss how to add images to your PDF, take a look at the image formats supported by iText, and offer a code example to demonstrate inserting an image.

Adding Images to PDF

Images in iText are typically added through the Image class. You can instantiate this class using the file path of the image you’d like to insert. Once the Image object is created, you can set various properties like scaling, rotation, and alignment, and then add it to the Document object just like any other element.

Supported Formats

iText supports a wide variety of image formats including JPEG, PNG, BMP, and GIF. This allows you to work with most common types of images without having to convert them beforehand.

Code Example: Inserting an Image

Here’s a simple Java program to demonstrate how you can add an image to a PDF document using iText.

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Image;
import com.itextpdf.io.image.ImageData;
import com.itextpdf.io.image.ImageDataFactory;

import java.net.MalformedURLException;

public class ImageInsertionExample {
    public static void main(String[] args) {
        try {
            // Initialize PdfWriter
            PdfWriter writer = new PdfWriter("path/to/your/image_example.pdf");

            // Initialize PdfDocument
            PdfDocument pdf = new PdfDocument(writer);

            // Initialize Document
            Document document = new Document(pdf);

            // Load image data
            ImageData imageData = ImageDataFactory.create("path/to/your/image.jpg");

            // Create Image object
            Image image = new Image(imageData);

            // Scale image
            image.scale(0.5f, 0.5f);

            // Add image to document
            document.add(image);

            // Close the Document
            document.close();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}
Code language: Java (java)

In this example, we use ImageDataFactory to create an ImageData object, which is then used to instantiate an Image object. The image is scaled down to 50% of its original dimensions using the scale method. Finally, the image is added to the Document object before closing it.

Image Manipulation

The manipulation of images—whether it’s resizing, positioning, or rotating—is an essential capability when creating PDF documents. With iText, you have fine-grained control over how images appear in your document. In this section, we’ll dive into how to resize and position images and also look at how to rotate images. A code example will help you understand these techniques practically.

Resizing and Positioning

iText allows you to resize images either by setting specific dimensions or by scaling them by a factor. The scale method can be used to resize an image proportionately. Additionally, you can set the X and Y position of the image using the setFixedPosition method.

For instance, you can set an image to half its original size using scale(0.5f, 0.5f) or set it to a fixed position using setFixedPosition(x, y).

Code Example: Resizing and Rotating Images

Here’s a Java code example that demonstrates resizing, positioning, and rotating an image in a PDF document.

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Image;
import com.itextpdf.io.image.ImageData;
import com.itextpdf.io.image.ImageDataFactory;

import java.net.MalformedURLException;

public class ImageManipulationExample {
    public static void main(String[] args) {
        try {
            // Initialize PdfWriter
            PdfWriter writer = new PdfWriter("path/to/your/manipulated_image_example.pdf");

            // Initialize PdfDocument
            PdfDocument pdf = new PdfDocument(writer);

            // Initialize Document
            Document document = new Document(pdf);

            // Load image data
            ImageData imageData = ImageDataFactory.create("path/to/your/image.jpg");

            // Create Image object
            Image image = new Image(imageData);

            // Resize image to 50% of original dimensions
            image.scale(0.5f, 0.5f);

            // Position image at coordinates (100, 600)
            image.setFixedPosition(100, 600);

            // Rotate image 45 degrees
            image.setRotationAngle(Math.toRadians(45));

            // Add image to document
            document.add(image);

            // Close the Document
            document.close();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}
Code language: Java (java)

In this example, the image is first scaled down to 50% of its original dimensions. It’s then positioned at the coordinates (100, 600) in the PDF page. Finally, the image is rotated 45 degrees clockwise using the setRotationAngle method. Note that the rotation angle is set in radians, so we convert 45 degrees to radians using Math.toRadians.

Lists and Tables

Structuring information effectively is crucial when creating comprehensive and easily digestible PDF documents. In this context, lists and tables are indispensable. While we’ll delve into tables later, this section is dedicated to creating lists. You’ll learn how to create both ordered and unordered lists and see a code example for adding a list to a PDF.

Creating Lists

iText provides two types of lists: ordered and unordered. Both list types are created using the List class, but their behavior is controlled by the setListSymbol and setNumbered methods. These methods allow you to define whether the list should have bullets or numbers.

Ordered and Unordered Lists

Ordered lists are lists where each item is numbered. Unordered lists, on the other hand, typically use bullet points.

  • Ordered Lists: To create an ordered list, you’ll need to use the setNumbered(true) method on a List object.
List orderedList = new List();
orderedList.setNumbered(true);
Code language: Java (java)
  • Unordered Lists: For an unordered list, you could use the setListSymbol method to set a bullet point or any other symbol.
List unorderedList = new List();
unorderedList.setListSymbol("\u2022");
Code language: Java (java)

Code Example: Adding a List to PDF

Here’s how you can add an ordered and an unordered list to your PDF document using iText.

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.List;
import com.itextpdf.layout.element.ListItem;

public class ListExample {
    public static void main(String[] args) {
        // Initialize PdfWriter
        PdfWriter writer = new PdfWriter("path/to/your/list_example.pdf");

        // Initialize PdfDocument
        PdfDocument pdf = new PdfDocument(writer);

        // Initialize Document
        Document document = new Document(pdf);

        // Create an ordered list
        List orderedList = new List();
        orderedList.setNumbered(true);
        orderedList.add(new ListItem("First item"));
        orderedList.add(new ListItem("Second item"));
        orderedList.add(new ListItem("Third item"));

        // Add ordered list to document
        document.add(orderedList);

        // Create an unordered list
        List unorderedList = new List();
        unorderedList.setListSymbol("\u2022");
        unorderedList.add(new ListItem("Apple"));
        unorderedList.add(new ListItem("Banana"));
        unorderedList.add(new ListItem("Cherry"));

        // Add unordered list to document
        document.add(unorderedList);

        // Close the Document
        document.close();
    }
}
Code language: Java (java)

In this example, an ordered list with three items and an unordered list with three different fruits are created and added to the document. The ordered list uses numbers, and the unordered list uses bullet points.

Adding Tables

Tables are an essential element when you want to display data in a structured, grid-like fashion. Whether you’re presenting numerical data, comparing attributes, or simply organizing content, tables help in enhancing readability and providing valuable context. In this section, we will cover how to initialize a table, add cells to it, and include a code example demonstrating the creation of a simple table.

Initializing a Table

In iText, the Table class is used to create a table. You can specify the number of columns when you initialize a new table.

Table table = new Table(numColumns);
Code language: Java (java)

Here, numColumns is an integer that specifies the number of columns your table will have.

Adding Cells

After initializing a table, you can add cells to it using the addCell method. Cells can contain text, lists, or even other tables. The Cell class is used to create a new cell.

Cell cell = new Cell();
cell.add("Sample Text");
table.addCell(cell);
Code language: Java (java)

You can add cells to a specific row and column or simply add them in a linear fashion, and they will be placed from left to right, top to bottom.

Code Example: Creating a Simple Table

Below is a Java code snippet that demonstrates how to create a simple table using iText.

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Table;
import com.itextpdf.layout.element.Cell;
import com.itextpdf.layout.property.UnitValue;

public class TableExample {
    public static void main(String[] args) {
        // Initialize PdfWriter
        PdfWriter writer = new PdfWriter("path/to/your/table_example.pdf");

        // Initialize PdfDocument
        PdfDocument pdf = new PdfDocument(writer);

        // Initialize Document
        Document document = new Document(pdf);

        // Initialize Table
        float[] columnWidths = {1, 2, 2};
        Table table = new Table(UnitValue.createPercentArray(columnWidths));
        
        // Add header cells
        table.addCell(new Cell().add("ID"));
        table.addCell(new Cell().add("Name"));
        table.addCell(new Cell().add("Age"));

        // Add data cells
        for (int i = 1; i <= 3; i++) {
            table.addCell(new Cell().add(String.valueOf(i)));
            table.addCell(new Cell().add("Name " + i));
            table.addCell(new Cell().add(String.valueOf(20 + i)));
        }

        // Add table to document
        document.add(table);

        // Close the Document
        document.close();
    }
}
Code language: JavaScript (javascript)

In this example, a table with three columns (“ID”, “Name”, “Age”) is created. We then add three rows of data to the table. Note that the width of the columns is set using an array columnWidths.

Advanced Features

Creating basic text and tables is a good start, but modern PDFs often include more advanced features like hyperlinks for easy navigation and better user interaction. In this section, we’ll explore how to create text and image hyperlinks using iText. Let’s also include a code example for adding hyperlinks to a PDF document.

Creating Hyperlinks

In iText, the PdfAction and Link classes are used to create hyperlinks. You can create two types of hyperlinks:

  • Text Links: A link applied to a text element.
  • Image Links: A link applied to an image element.

Both can be done using the Link class, which can be configured to use a PdfAction.

Text Links

To create a text link, you use the Link class in combination with a Paragraph or Text object.

Link link = new Link("Click Here", PdfAction.createURI("https://www.example.com"));
Code language: Java (java)

You can then add this link to a Paragraph if you wish.

Paragraph p = new Paragraph().add("Visit: ").add(link);
Code language: Java (java)

Image Links

Similarly, you can make an image clickable by creating a link and associating it with the image.

ImageData imageData = ImageDataFactory.create("path/to/your/image.jpg");
Image image = new Image(imageData);
Link imageLink = new Link("", PdfAction.createURI("https://www.example.com"));
image.setNextRenderer(new LinkRenderer(image, imageLink));
Code language: JavaScript (javascript)

Code Example: Adding Hyperlinks to PDF

Here’s a code snippet illustrating how to add both text and image hyperlinks to a PDF document.

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;
import com.itextpdf.layout.element.Link;
import com.itextpdf.layout.element.Image;
import com.itextpdf.kernel.pdf.action.PdfAction;
import com.itextpdf.io.image.ImageData;
import com.itextpdf.io.image.ImageDataFactory;
import com.itextpdf.layout.renderer.LinkRenderer;

import java.net.MalformedURLException;

public class HyperlinkExample {
    public static void main(String[] args) {
        try {
            // Initialize PdfWriter
            PdfWriter writer = new PdfWriter("path/to/your/hyperlink_example.pdf");

            // Initialize PdfDocument
            PdfDocument pdf = new PdfDocument(writer);

            // Initialize Document
            Document document = new Document(pdf);

            // Create text link
            Link link = new Link("Visit OpenAI", PdfAction.createURI("https://www.openai.com"));
            Paragraph p = new Paragraph().add("To know more about AI, ").add(link);
            document.add(p);

            // Create image link
            ImageData imageData = ImageDataFactory.create("path/to/your/image.jpg");
            Image image = new Image(imageData);
            Link imageLink = new Link("", PdfAction.createURI("https://www.openai.com"));
            image.setNextRenderer(new LinkRenderer(image, imageLink));
            document.add(image);

            // Close the Document
            document.close();

        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}
Code language: Java (java)

In this example, the text “Visit OpenAI” redirects to OpenAI’s website. Additionally, a clickable image is added, which also redirects to OpenAI’s website when clicked.

PDF Forms

PDF forms are a way to make your documents interactive, enabling users to enter information directly within the PDF itself. This is particularly useful for things like application forms, surveys, or any document that requires user input. In this section, we’ll cover how to create text fields and buttons using iText. We’ll also include a code example demonstrating how to create a simple PDF form.

Creating Text Fields

iText provides the PdfFormField class to create various types of form fields, including text fields. A text field allows users to input text data.

Here’s how you can create a text field:

PdfFormField textField = PdfTextFormField.createText(pdfDocument, 
                                                     new Rectangle(x, y, width, height), 
                                                     "fieldName", 
                                                     "defaultValue");
Code language: Java (java)

In this code, x, y, width, and height define the position and dimensions of the text field within the PDF document. "fieldName" is the name of the field, and "defaultValue" is the text that will appear in the text field when the document is opened.

Adding Buttons

Adding buttons, like a Submit button, is another feature that comes handy in interactive forms. Buttons can be created using the PdfButtonFormField class.

Here’s how you can create a simple button:

PdfButtonFormField button = PdfButtonFormField.createPushButton(pdfDocument, 
                                                               new Rectangle(x, y, width, height), 
                                                               "buttonName", 
                                                               "Button Text");
Code language: JavaScript (javascript)

Code Example: Creating a Simple PDF Form

Here’s a simple Java code example that shows how to create a basic PDF form with a text field and a button.

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.annot.PdfAnnotation;
import com.itextpdf.forms.PdfAcroForm;
import com.itextpdf.forms.fields.PdfFormField;
import com.itextpdf.forms.fields.PdfTextFormField;
import com.itextpdf.forms.fields.PdfButtonFormField;
import com.itextpdf.kernel.geom.Rectangle;

public class FormExample {
    public static void main(String[] args) {
        // Initialize PdfWriter
        PdfWriter writer = new PdfWriter("path/to/your/form_example.pdf");

        // Initialize PdfDocument
        PdfDocument pdf = new PdfDocument(writer);

        // Initialize Document
        PdfAcroForm form = PdfAcroForm.getAcroForm(pdf, true);

        // Create text field
        PdfFormField textField = PdfTextFormField.createText(pdf, 
                                                             new Rectangle(50, 750, 200, 20), 
                                                             "nameField", 
                                                             "Enter your name");
        form.addField(textField);

        // Create button
        PdfButtonFormField button = PdfButtonFormField.createPushButton(pdf, 
                                                                       new Rectangle(260, 750, 100, 20), 
                                                                       "submitBtn", 
                                                                       "Submit");
        form.addField(button);

        // Close the PdfDocument
        pdf.close();
    }
}
Code language: Java (java)

In this example, a text field for entering a name and a Submit button are created. Both are added to the form, and the PDF document is closed.

Handling Large Documents

As you start to work with more complex or large-scale PDFs, it becomes increasingly important to manage resources efficiently. iText provides features that can help you handle large documents in a way that is both memory-efficient and performant. In this section, we’ll cover how to manage memory, chunk large data sets, and split PDFs into smaller files. We will also include a code example demonstrating how to split a large PDF into smaller parts.

Memory Management

iText allows you to flush certain objects to the disk as soon as they are no longer needed, helping you to keep the memory footprint small. This is particularly useful when you’re dealing with large documents that may otherwise consume a lot of memory.

Here’s how you can use the setImmediateFlush(true) method to flush a page to disk immediately after it has been written:

Document document = new Document(pdf, PageSize.A4, true);
Code language: Java (java)

In this example, setting the third parameter to true enables immediate flush.

Chunking Large Data

When dealing with large data sets, you might not be able to load all the data into memory at once. In such cases, you can load data in chunks and write them to the PDF progressively.

For example, if you are generating a large table from a database, you can read rows in small chunks and write them to the PDF, thereby keeping memory usage low.

Code Example: Splitting PDFs

Below is a Java code snippet that shows how to split a large PDF file into smaller files, each containing a specific number of pages.

// Import required packages
import com.itextpdf.kernel.pdf.PdfReader;
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;

public class PdfSplitterExample {
    public static void main(String[] args) {
        try {
            // Initialize PdfReader
            PdfReader reader = new PdfReader("path/to/your/large_document.pdf");
            PdfDocument sourcePdf = new PdfDocument(reader);

            int totalNumberOfPages = sourcePdf.getNumberOfPages();
            int pagesPerSplit = 5; // Number of pages in each split

            for (int i = 1; i <= totalNumberOfPages; i += pagesPerSplit) {
                // Calculate last page
                int lastPage = Math.min(i + pagesPerSplit - 1, totalNumberOfPages);

                // Initialize PdfWriter
                PdfWriter writer = new PdfWriter("path/to/your/split_" + i + ".pdf");

                // Initialize destination PdfDocument
                PdfDocument destinationPdf = new PdfDocument(writer);

                // Add pages to the new document
                sourcePdf.copyPagesTo(i, lastPage, destinationPdf);

                // Close the destination PdfDocument
                destinationPdf.close();
            }

            // Close the source PdfDocument
            sourcePdf.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
Code language: Java (java)

In this code, we specify that each split should contain 5 pages. The program then loops through the source PDF, creating new PDF files that contain 5 pages each, until all pages have been processed.

Adding Meta Information

Metadata is data that provides information about other data. When it comes to PDFs, adding metadata like the author’s name, the title of the document, and other related attributes can be beneficial for both organization and SEO (Search Engine Optimization). This section will show you how to add metadata like the author and title to your PDF documents using iText. We’ll also include a code example that demonstrates how to add metadata to a PDF.

Author, Title, and More

iText allows you to set various kinds of metadata for a PDF document, including:

  • Author: The name of the person who created the document.
  • Title: The title of the document.
  • Subject: A brief summary or the subject matter of the document.
  • Keywords: Relevant keywords that describe the document.

To add this metadata, you can use the PdfDocumentInfo class. This class provides setters for each of these properties, among others.

Here’s an example that demonstrates how to set these properties:

PdfDocument pdf = new PdfDocument(new PdfWriter("path/to/your/document.pdf"));
PdfDocumentInfo info = pdf.getDocumentInfo();
info.setAuthor("John Doe");
info.setTitle("Sample PDF Document");
info.setSubject("An example to demonstrate metadata");
info.setKeywords("iText, PDF, Java, metadata");
Code language: JavaScript (javascript)

Code Example: Adding Metadata to PDF

Here’s a complete Java code snippet to illustrate how to create a PDF with metadata:

// Import required packages
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfDocumentInfo;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;

public class MetadataExample {
    public static void main(String[] args) {
        try {
            // Initialize PdfWriter and PdfDocument
            PdfWriter writer = new PdfWriter("path/to/your/metadata_example.pdf");
            PdfDocument pdf = new PdfDocument(writer);

            // Set metadata
            PdfDocumentInfo info = pdf.getDocumentInfo();
            info.setAuthor("John Doe");
            info.setTitle("Sample PDF with Metadata");
            info.setSubject("Demonstrating how to add metadata using iText");
            info.setKeywords("iText, PDF, Java, metadata");

            // Initialize Document
            Document document = new Document(pdf);

            // Add some content
            document.add(new Paragraph("Hello, world!"));

            // Close the document
            document.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
Code language: JavaScript (javascript)

In this example, metadata such as the author’s name, document title, subject, and keywords are added to the PDF. The PDF is then populated with a simple “Hello, world!” paragraph before being closed.

Tips and Best Practices

After mastering the basics and even some of the advanced features of iText for PDF creation, it’s important to be aware of some tips and best practices. These practices will not only make your code more robust but also optimize the performance of your PDF processing tasks. In this section, we’ll discuss best practices related to file handling, error handling, and performance optimization.

File Handling

Close Resources: Always close your Document, PdfDocument, and PdfWriter instances to free up resources. You can use Java’s try-with-resources statement for this.

try (PdfWriter writer = new PdfWriter("path/to/your/document.pdf");
     PdfDocument pdf = new PdfDocument(writer);
     Document document = new Document(pdf)) {
     // Your code here
}
Code language: Java (java)

Overwrite Caution: Be cautious when specifying the file path in PdfWriter. If a file already exists with the same name, it will be overwritten.

File Permissions: When dealing with sensitive documents, consider setting file permissions to restrict unauthorized access.

pdf.getWriter().setEncryption("userPassword".getBytes(), "ownerPassword".getBytes(),
                              PdfWriter.ALLOW_PRINTING, PdfWriter.ENCRYPTION_AES_256);
Code language: Java (java)

Error Handling

Exception Handling: Always wrap your code blocks where you expect something might fail with try-catch blocks to handle exceptions gracefully.

try {
    // Your PDF generation code here
} catch (Exception e) {
    // Log and handle the exception
    e.printStackTrace();
}
Code language: Java (java)

Validation: Validate data before adding it to your PDF. For example, make sure that text strings are not null or that lists are not empty before trying to add them to a document.

Performance Optimization

Immediate Flush: For large documents, use the setImmediateFlush(true) method when creating a new Document instance to flush pages to disk immediately after they are added, thus keeping memory usage low.

Document document = new Document(pdf, PageSize.A4, true);
Code language: Java (java)

Reuse Objects: If you’re adding the same image or repeating elements across multiple pages or documents, consider reusing object instances instead of creating new ones.

Chunk Data: When dealing with large tables or lists, load the data in chunks and add it to the document incrementally to optimize memory usage.

Page Size and Margins: If the content allows, consider using larger page sizes or smaller margins to fit more content per page, thus reducing the total number of pages.

By keeping these best practices in mind, you can ensure that your PDFs are generated in a reliable, efficient, and secure manner. This will not only make your code more maintainable but also improve the user experience by generating PDFs more quickly and with fewer errors.

Related posts: