DEV Community: Pilalo

How to Add Visual Formatting to Excel Sheets with Java

Pilalo — Fri, 05 Jun 2026 02:17:03 +0000

Visual formatting makes Excel reports easier to read and more professional in appearance. Applying background colors and images to worksheets can highlight important sections, distinguish between different sheets, and reinforce branding in distributed reports.

This article demonstrates how to set background colors and background images in Excel worksheets programmatically using Spire.XLS for Java.

Project Setup

To use Spire.XLS for Java in a Maven project, add the following repository and dependency to your pom.xml file:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.xls</artifactId>
        <version>16.4.1</version>
    </dependency>
</dependencies>

Refresh your project to download the required JAR files. The library requires Java 8 or later. A free version is available with a limit on the number of worksheets per workbook; a paid license removes this restriction.

Applying a Background Color to an Entire Worksheet

Setting a solid background color for a worksheet is a straightforward way to make it visually distinct. The library provides the getPageSetup().setBackgoundColor() method for this purpose. The following example creates a workbook with two sheets, each with a different background color:

import com.spire.xls.*;
import java.awt.*;

public class WorksheetBackground {
    public static void main(String[] args) {
        // Create a new workbook
        Workbook workbook = new Workbook();

        // Access the first sheet and rename it
        Worksheet sheet1 = workbook.getWorksheets().get(0);
        sheet1.setName("GreenSheet");
        // Set background color to light green using RGB values
        sheet1.getPageSetup().setBackgoundColor(new Color(144, 238, 144));

        // Add a second sheet with a light blue background
        Worksheet sheet2 = workbook.getWorksheets().add("BlueSheet");
        sheet2.getPageSetup().setBackgoundColor(new Color(173, 216, 230));

        // Add sample data to both sheets
        sheet1.getCellRange("A1").setValue("This sheet has a green background");
        sheet2.getCellRange("A1").setValue("This sheet has a blue background");

        // Save the workbook
        workbook.saveToFile("output/ColoredSheets.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

The Color class from java.awt is used to specify RGB color values. The background color is visible behind all cell content and persists when the file is opened in Microsoft Excel or other compatible applications.

Setting Background Colors for Specific Cell Ranges

In addition to full-sheet backgrounds, you can apply fill colors to specific cell ranges. This is done through cell style properties on a CellRange object, which is useful for formatting headers, highlighting rows, or color-coding data:

import com.spire.xls.*;
import java.awt.*;

public class CellRangeBackground {
    public static void main(String[] args) {
        // Create a new workbook
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.getWorksheets().get(0);

        // Populate a simple data table
        sheet.getCellRange("A1").setValue("Product");
        sheet.getCellRange("B1").setValue("Sales");
        sheet.getCellRange("C1").setValue("Status");

        sheet.getCellRange("A2").setValue("Widget A");
        sheet.getCellRange("B2").setValue("$1,200");
        sheet.getCellRange("C2").setValue("Active");

        sheet.getCellRange("A3").setValue("Widget B");
        sheet.getCellRange("B3").setValue("$800");
        sheet.getCellRange("C3").setValue("Discontinued");

        // Apply dark blue background to the header row
        CellRange headerRange = sheet.getCellRange("A1:C1");
        headerRange.getCellStyle().setColor(new Color(0, 51, 102));
        // Set header font to white for contrast
        headerRange.getCellStyle().getFont().setColor(new Color(255, 255, 255));
        headerRange.getCellStyle().getFont().isBold(true);

        // Highlight the discontinued product row in light red
        sheet.getCellRange("A3:C3").getCellStyle().setColor(new Color(255, 204, 203));

        // Center-align all data cells
        sheet.getCellRange("A1:C3").setHorizontalAlignment(HorizontalAlignType.Center);

        // Auto-fit column widths
        sheet.autoFitColumn(1);
        sheet.autoFitColumn(2);
        sheet.autoFitColumn(3);

        // Save the workbook
        workbook.saveToFile("output/CellRangeColors.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

The getCellStyle().setColor() method changes the fill color of the specified cells. Combining this with font styling and alignment settings produces structured, readable data tables with clear visual hierarchy.

Adding a Background Image to a Worksheet

Beyond solid colors, an image can be set as the worksheet background. This is useful for adding watermarks, company logos, or subtle decorative patterns. The method getPageSetup().setBackgoundImage() accepts either a file path string or a BufferedImage object. The image tiles across the sheet to cover the entire background:

import com.spire.xls.*;
import java.io.File;

public class ImageBackground {
    public static void main(String[] args) {
        // Create a new workbook
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.getWorksheets().get(0);

        // Add sample data
        sheet.getCellRange("A1").setValue("This worksheet has a background image");
        sheet.getCellRange("B2").setValue("The image tiles across the entire sheet");

        // Load and set a background image
        File imageFile = new File("background.png");
        if (imageFile.exists()) {
            sheet.getPageSetup().setBackgoundImage(imageFile.getAbsolutePath());
        } else {
            System.out.println("Image file not found. Skipping background image.");
        }

        // Save the workbook
        workbook.saveToFile("output/ImageBackground.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

Using a BufferedImage object instead of a file path:

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;

BufferedImage image = ImageIO.read(new File("background.png"));
sheet.getPageSetup().setBackgoundImage(image);

Key points about worksheet background images:

The image tiles both horizontally and vertically to fill the entire sheet area, similar to a repeating wallpaper pattern.
Background images are for on-screen display only. They do not appear in printouts, which is standard Excel behavior across all versions and libraries.
Supported formats include PNG, JPEG, and BMP. For watermark effects, a semi-transparent PNG can be used.

Applying Different Backgrounds to Multiple Sheets

When a workbook contains several sheets, applying distinct formatting to each one can help users navigate. The following example combines color and image backgrounds across three sheets:

import com.spire.xls.*;
import java.awt.*;
import java.io.File;

public class MultiSheetBackgrounds {
    public static void main(String[] args) {
        Workbook workbook = new Workbook();

        // Cover sheet: light blue solid color
        Worksheet sheet1 = workbook.getWorksheets().get(0);
        sheet1.setName("Cover Sheet");
        sheet1.getCellRange("A1").setValue("Quarterly Report");
        sheet1.getPageSetup().setBackgoundColor(new Color(220, 230, 241));

        // Data sheet: background image (if available)
        Worksheet sheet2 = workbook.getWorksheets().add("Data Sheet");
        sheet2.getCellRange("A1").setValue("Sales Data");
        File bgImage = new File("background.png");
        if (bgImage.exists()) {
            sheet2.getPageSetup().setBackgoundImage(bgImage.getAbsolutePath());
        }

        // Summary sheet: warm beige solid color
        Worksheet sheet3 = workbook.getWorksheets().add("Summary");
        sheet3.getCellRange("A1").setValue("Summary Statistics");
        sheet3.getPageSetup().setBackgoundColor(new Color(255, 250, 240));

        workbook.saveToFile("output/MultiSheetBackgrounds.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

This approach is helpful in reports where different sheets have different roles—cover pages, detailed data, and summary views—and visual distinction aids navigation.

Practical Considerations

When applying backgrounds in Excel, several points are worth keeping in mind:

Printing behavior: Excel does not print worksheet background images. If a printed background is required, consider inserting an image into the header, footer, or directly into cells instead.
File size impact: Large background images increase the overall workbook file size. Use appropriately sized and compressed images.
Readability: Ensure sufficient contrast between background colors and cell text. Dark backgrounds need light font colors, and light backgrounds work best with dark text.
Performance: Applying background colors and images is a lightweight operation and has minimal impact on processing time, even for larger workbooks.

Alternative Libraries

Several other Java libraries support Excel formatting, each with different capabilities for backgrounds:

Library	License	Notes
Apache POI	Apache 2.0 (open source)	Supports cell fill colors through its style API; worksheet background images require direct manipulation of the underlying XML
Aspose.Cells	Commercial	Provides dedicated methods for both sheet backgrounds and cell formatting
JExcelApi	LGPL (open source)	Limited to the older .xls format; includes basic color support but no background image functionality

Apache POI handles cell fill colors well, but setting a worksheet background image involves working with the low-level sheet XML structure. Aspose.Cells offers comparable features under a commercial license. JExcelApi is constrained by its support only for legacy Excel formats and has fewer formatting options.

Conclusion

Setting background colors and images in Excel worksheets through Spire.XLS for Java involves two main methods: getPageSetup().setBackgoundColor() for solid color fills across an entire sheet, and getPageSetup().setBackgoundImage() for tiled image backgrounds. For more granular formatting, getCellStyle().setColor() applies fill colors to specific cell ranges such as headers and data rows. These techniques can be combined across multiple sheets within a single workbook to create visually organized documents that improve readability and provide clear visual cues for different data sections. When implementing these formatting features, developers should consider the standard Excel behavior of not printing background images, the effect of large image files on workbook size, and the importance of maintaining adequate contrast between backgrounds and text. For additional customization, the library also supports conditional formatting rules, direct image insertion into cells, and chart generation with custom color schemes.

How to Work with Excel Document Properties in Java

Pilalo — Tue, 02 Jun 2026 02:28:43 +0000

Document properties, often called metadata, are descriptive fields embedded within an Excel file. They include details such as author name, title, subject, keywords, and more. Managing these properties programmatically helps organize files, improves searchability in document management systems, and ensures consistency across batches of generated reports.

This article explains how to add, read, and modify document properties in Excel files using Spire.XLS for Java, covering both built-in and custom properties.

Project Setup

To use Spire.XLS for Java in a Maven project, add the following repository and dependency to your pom.xml file:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.xls</artifactId>
        <version>16.4.1</version>
    </dependency>
</dependencies>

Types of Document Properties

Excel supports two categories of document properties:

Built-in properties: Standard fields defined by the Excel specification, such as Title, Subject, Author, Manager, Company, Category, Keywords, and Comments. These are visible in the File Info panel of Excel.
Custom properties: User-defined key-value pairs you create for specific metadata needs. They can store information like a document ID, approval status, revision number, or department code.

Both types are stored within the Excel file and remain with it when shared or archived.

Adding Built-in Document Properties

Built-in properties are accessed through the DocumentProperties object associated with a workbook. The following example sets several common built-in fields on a new Excel file:

import com.spire.xls.*;

public class AddBuiltInProperties {
    public static void main(String[] args) {
        // Create a new workbook
        Workbook workbook = new Workbook();

        // Add a worksheet and put sample data in a cell
        Worksheet sheet = workbook.getWorksheets().get(0);
        sheet.getCellRange("A1").setValue("Sample Data");

        // Access document properties
        DocumentProperties properties = workbook.getDocumentProperties();

        // Set built-in properties
        properties.setAuthor("Jane Doe");
        properties.setTitle("Quarterly Sales Report");
        properties.setSubject("Sales Data for Q1 2026");
        properties.setManager("John Smith");
        properties.setCompany("Acme Corporation");
        properties.setCategory("Financial");
        properties.setKeywords("sales, quarterly, report, 2026");
        properties.setComments("Generated automatically by the reporting system");

        // Save the file
        workbook.saveToFile("output/WithProperties.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

Key points about this code:

getDocumentProperties() returns the properties collection for the workbook.
Individual setter methods such as setAuthor(), setTitle(), and setCompany() write values to the corresponding built-in fields.
Properties are saved along with the sheet data when saveToFile() is called.

Adding Custom Document Properties

Custom properties store metadata beyond the predefined built-in set. Each custom property consists of a name, a value, and a data type. The library supports string, numeric, date, and boolean custom property types.

Here is an example that adds several custom properties to a workbook:

import com.spire.xls.*;

public class AddCustomProperties {
    public static void main(String[] args) {
        // Create a new workbook
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.getWorksheets().get(0);
        sheet.getCellRange("A1").setValue("Document with Custom Properties");

        // Add custom document properties
        workbook.getCustomDocumentProperties().add("DocumentID", "DOC-2026-0042");
        workbook.getCustomDocumentProperties().add("ApprovalStatus", "Approved");
        workbook.getCustomDocumentProperties().add("RevisionNumber", 3);
        workbook.getCustomDocumentProperties().add("ProcessedDate", new java.util.Date());
        workbook.getCustomDocumentProperties().add("IsConfidential", true);

        // Save the file
        workbook.saveToFile("output/CustomProperties.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

Important details about custom properties:

The add() method accepts a property name and a value. The data type is inferred from the Java type of the value you pass.
Property names must be unique within a workbook. Adding a property with an existing name overwrites the previous value.
Custom properties are persisted in the file and can be read by other applications that support Excel metadata.

Reading Existing Document Properties

You can also retrieve properties from an existing Excel file. Built-in and custom properties use different access patterns, as shown in this example:

import com.spire.xls.*;
import com.spire.xls.core.spreadsheet.collections.XlsCustomDocumentPropertiesCollection;

public class ReadProperties {
    public static void main(String[] args) {
        // Load an existing workbook
        Workbook workbook = new Workbook();
        workbook.loadFromFile("output/WithProperties.xlsx");

        // Read built-in properties
        DocumentProperties properties = workbook.getDocumentProperties();
        System.out.println("=== Built-in Properties ===");
        System.out.println("Author: " + properties.getAuthor());
        System.out.println("Title: " + properties.getTitle());
        System.out.println("Subject: " + properties.getSubject());
        System.out.println("Manager: " + properties.getManager());
        System.out.println("Company: " + properties.getCompany());
        System.out.println("Category: " + properties.getCategory());
        System.out.println("Keywords: " + properties.getKeywords());
        System.out.println("Comments: " + properties.getComments());

        // Read custom properties
        System.out.println("\n=== Custom Properties ===");
        XlsCustomDocumentPropertiesCollection customProps = workbook.getCustomDocumentProperties();
        for (int i = 0; i < customProps.getCount(); i++) {
            String name = customProps.get(i).getName();
            Object value = customProps.get(i).getValue();
            System.out.println(name + ": " + value);
        }

        workbook.dispose();
    }
}

A sample output from this code would look like:

=== Built-in Properties ===
Author: Jane Doe
Title: Quarterly Sales Report
Subject: Sales Data for Q1 2026
Manager: John Smith
Company: Acme Corporation
Category: Financial
Keywords: sales, quarterly, report, 2026
Comments: Generated automatically by the reporting system

=== Custom Properties ===
DocumentID: DOC-2026-0042
ApprovalStatus: Approved
RevisionNumber: 3
ProcessedDate: Sun Jun 01 14:30:00 EDT 2026
IsConfidential: true

The getCustomDocumentProperties() method returns a collection you can iterate through to access each property's name and value. The getCount() method gives the number of custom properties, and get(index) retrieves an individual property by its position.

Updating Existing Properties

Modifying properties in an existing file follows the same pattern as adding them. Load the workbook, call the relevant setter or add method, and save:

// Update a built-in property
properties.setAuthor("Updated Author Name");

// Update a custom property (using add with an existing name overwrites the value)
workbook.getCustomDocumentProperties().add("ApprovalStatus", "Pending Review");

For custom properties, calling add() with an existing property name replaces the previous value. There is no separate update method.

Practical Use Cases

Programmatic management of document properties supports several real-world scenarios:

Document classification: Set categories and keywords to make files easier to locate in document management systems.
Audit information: Store processing dates, revision numbers, and approval statuses directly within the file.
Batch consistency: Apply uniform metadata across hundreds of auto-generated reports without manual intervention.
Regulatory requirements: Embed required metadata fields to meet organizational or compliance standards.

Alternative Libraries for Excel Metadata

Several other Java libraries can handle Excel document properties:

Library	License	Notes
Apache POI	Apache 2.0 (open source)	Accesses document summary information through its HPSF module; requires more low-level code for some operations
Aspose.Cells	Commercial	Supports built-in and custom properties with a similar API design
JExcelApi	LGPL (open source)	Limited to the older .xls format; does not support .xlsx files

Apache POI can read and write document properties, though the API involves working with POIFS file system components for certain property operations. Aspose.Cells provides comparable functionality under a commercial license. JExcelApi is restricted to legacy Excel formats and is not suitable for modern .xlsx workflows.

Conclusion

Working with Excel document properties through Spire.XLS for Java involves two main interfaces: the DocumentProperties object for built-in metadata fields like author, title, and subject, and the CustomDocumentProperties collection for user-defined key-value pairs that can store strings, numbers, dates, and boolean values. Both types of properties can be written when creating new files and read back from existing workbooks using straightforward getter and setter methods. These capabilities are particularly useful in automated reporting pipelines where consistent metadata helps with file organization, searchability, and compliance. Developers considering this library should evaluate whether the free version's worksheet limits align with their document volumes and whether the property-handling API covers the metadata fields their workflows require. For more advanced scenarios, the library's documentation also covers applying properties to password-protected files and working with additional built-in fields beyond those shown here.

How to Merge Excel Files with Java

Pilalo — Thu, 28 May 2026 02:01:14 +0000

Combining data from multiple Excel workbooks is a common requirement in reporting, data analysis, and document management workflows. Whether you are consolidating monthly reports, aggregating team submissions, or compiling financial records, programmatic merging is more efficient and less error-prone than manual copy-and-paste operations.

This article demonstrates two practical approaches for merging Excel files using Spire.XLS for Java: combining entire workbooks sheet by sheet, and consolidating data from multiple worksheets into a single summary sheet.

Adding the Library to Your Project

To use Spire.XLS for Java, add it as a dependency in your build configuration. For Maven projects, include the following in your pom.xml file:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.xls</artifactId>
        <version>16.4.1</version>
    </dependency>
</dependencies>

Refresh your project to download the required JAR files. The library requires Java 8 or later. Note that a free version is available with limitations on the number of worksheets per workbook; a paid license removes these restrictions.

Approach 1: Merging Multiple Workbooks into One

This method creates a new workbook and copies every worksheet from each source file into it. The addCopy() method preserves data, cell formatting, formulas, and charts from the original sheets.

The following example merges three Excel files into a single output workbook:

import com.spire.xls.*;

public class MergeExcelWorkbooks {
    public static void main(String[] args) {
        // Specify the input files
        String[] inputFiles = new String[]{
            "Budget_Summary.xlsx",
            "Income.xlsx",
            "Expenses.xlsx"
        };

        // Create a new workbook and remove default empty sheets
        Workbook newBook = new Workbook();
        newBook.getWorksheets().clear();

        // Temporary workbook to load each source file
        Workbook tempBook = new Workbook();

        // Loop through each file and copy all worksheets
        for (String file : inputFiles) {
            tempBook.loadFromFile(file);
            for (Worksheet sheet : (Iterable<Worksheet>) tempBook.getWorksheets()) {
                newBook.getWorksheets().addCopy(sheet, WorksheetCopyType.CopyAll);
            }
        }

        // Save the merged result
        newBook.saveToFile("MergedWorkbook.xlsx", ExcelVersion.Version2016);
        newBook.dispose();
        tempBook.dispose();
    }
}

How this code works:

getWorksheets().clear() removes the default blank sheet that a new workbook creates, giving you a clean starting point.
loadFromFile() opens each source workbook into a temporary Workbook instance.
addCopy() with WorksheetCopyType.CopyAll duplicates a worksheet while preserving all content, styles, and embedded objects.

Handling duplicate sheet names: If multiple source files contain sheets with identical names, the library automatically appends a numeric suffix to prevent naming conflicts. For example, a second "Sheet1" becomes "Sheet1(1)".

Approach 2: Consolidating Worksheets into a Single Sheet

In some scenarios, you may want to combine data from several worksheets into one consolidated sheet rather than keeping them as separate tabs. This approach copies data ranges and appends them sequentially below existing content.

The example below merges two worksheets from the same workbook into the first sheet:

import com.spire.xls.*;

public class MergeWorksheetsIntoSingle {
    public static void main(String[] args) {
        // Load the source workbook
        Workbook workbook = new Workbook();
        workbook.loadFromFile("input.xlsx");

        // Access the two worksheets to merge
        Worksheet sheet1 = workbook.getWorksheets().get(0);
        Worksheet sheet2 = workbook.getWorksheets().get(1);

        // Identify the data range in the second sheet
        CellRange sourceRange = sheet2.getAllocatedRange();

        // Determine the destination: one row below the last row of sheet1
        CellRange destRange = sheet1.getCellRange(
            sheet1.getLastRow() + 1, 1
        );

        // Copy data from source range to destination
        sourceRange.copy(destRange);

        // Remove the now-empty second sheet
        sheet2.remove();

        // Save the result
        workbook.saveToFile("MergedSheets.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

Key details:

getAllocatedRange() automatically detects the area containing actual data, so you do not need to hard-code row and column boundaries.
The destination row is calculated as sheet1.getLastRow() + 1, which places the copied data immediately below the existing content.
Removing the source sheet after copying is optional. Skip the remove() call if you prefer to retain the original worksheets.

Excluding duplicate headers: When appending data from multiple sheets, each source sheet may have its own header row. To avoid repeating headers, adjust the source range to exclude the first row, or offset the copied data so only the header from the first sheet is retained.

Batch Processing Files from a Directory

When dealing with many files, you can extend the first approach to process all Excel files in a given folder automatically:

import com.spire.xls.*;
import java.io.File;

public class MergeDirectory {
    public static void main(String[] args) {
        File folder = new File("excel_files/");
        File[] files = folder.listFiles(
            (dir, name) -> name.endsWith(".xlsx") || name.endsWith(".xls")
        );

        Workbook newBook = new Workbook();
        newBook.getWorksheets().clear();
        Workbook tempBook = new Workbook();

        for (File file : files) {
            tempBook.loadFromFile(file.getAbsolutePath());
            for (Worksheet sheet : (Iterable<Worksheet>) tempBook.getWorksheets()) {
                newBook.getWorksheets().addCopy(sheet, WorksheetCopyType.CopyAll);
            }
        }

        newBook.saveToFile("MergedDirectory.xlsx", ExcelVersion.Version2016);
        newBook.dispose();
        tempBook.dispose();
    }
}

This batch approach is useful for automated report generation, monthly data aggregation, or any workflow where files accumulate over time.

Alternative Libraries for Excel Merging

Several other Java libraries can also handle Excel file merging, each with different design philosophies and trade-offs:

Library	License	Characteristics
Apache POI	Apache 2.0 (open source)	Mature and widely adopted; requires more manual code to preserve formatting during copy operations
EasyExcel	Apache 2.0 (open source)	Designed for memory efficiency with large files; uses a streaming approach
Aspose.Cells	Commercial	Offers a broad feature set including advanced chart and formatting support

Apache POI can merge files but typically requires explicit handling of styles and formatting to replicate them accurately. EasyExcel prioritizes low memory consumption and is well-suited for processing large datasets. Aspose.Cells provides functionality comparable to Spire.XLS under a commercial licensing model. The right choice depends on your project's licensing budget, file size requirements, and desired level of API abstraction.

Conclusion

Merging Excel files in Java with Spire.XLS for Java involves two primary strategies: copying entire worksheets between workbooks using the addCopy() method, which preserves all formatting, formulas, and data structures, or appending data ranges to consolidate information into a single sheet. Both approaches handle common challenges such as duplicate sheet names and header row management, and they can be extended with directory-based batch processing for larger volumes of files. The library's API abstracts away many low-level details of worksheet copying, though developers should be aware of the free version's worksheet limits when evaluating it for production use. For further exploration, the library's documentation covers additional merge-related scenarios including handling inconsistent headers across files, converting between formats like CSV to Excel before merging, and applying post-merge formatting adjustments.

Working with Excel Files in Java: A Practical Guide

Pilalo — Tue, 26 May 2026 02:06:49 +0000

Programmatic Excel manipulation is a common requirement in enterprise Java applications. Whether you need to generate reports, process data imports, or automate spreadsheet workflows, the ability to create, read, and update Excel documents reliably is valuable.

This article demonstrates three fundamental Excel operations using Spire.XLS for Java, a library that processes Excel files without requiring Microsoft Office installation on the server.

Project Setup

Add the library to your project using Maven. Include the following repository and dependency in your pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.xls</artifactId>
        <version>16.4.1</version>
    </dependency>
</dependencies>

Refresh your project to download the required JAR files. The library requires Java 8 or later. A free version is available with limitations on the number of worksheets per workbook; a paid license removes these restrictions.

Creating an Excel Workbook

The Workbook class represents an Excel workbook model. You can add worksheets, write data to cells, apply formatting, and save in various Excel formats.

Here's an example that creates a spreadsheet with formatted headers and structured data:

import com.spire.xls.*;

public class CreateSpreadsheet {

    public static void main(String[] args) {

        //Create a Workbook object
        Workbook wb = new Workbook();

        //Remove default worksheets
        wb.getWorksheets().clear();

        //Add a worksheet and name it "Employee"
        Worksheet sheet = wb.getWorksheets().add("Employee");

        //Merge cells A1 to G1 for a title row
        sheet.getRange().get("A1:G1").merge();

        //Write title text and apply formatting
        sheet.getRange().get("A1").setValue("Basic Information of Employees");
        sheet.getRange().get("A1").setHorizontalAlignment(HorizontalAlignType.Center);
        sheet.getRange().get("A1").setVerticalAlignment(VerticalAlignType.Center);
        sheet.getRange().get("A1").getStyle().getFont().isBold(true);
        sheet.getRange().get("A1").getStyle().getFont().setSize(13);

        //Set row height for the title row (1-based index)
        sheet.setRowHeight(1, 30);

        //Define data as a two-dimensional array
        String[][] data = new String[][]{
                {"Name", "Gender", "Birth Date", "Education", "Phone", "Position", "ID"},
                {"Allen", "Male", "1990-02-10", "Bachelor", "24756854", "Mechanic", "0021"},
                {"Patrick", "Male", "1985-06-08", "Master", "59863247", "Mechanic", "0022"},
                {"Jenna", "Female", "1989-11-25", "Bachelor", "79540352", "Sales", "0023"},
                {"Tommy", "Male", "1988-04-16", "Master", "52014060", "Mechanic", "0024"},
                {"Christina", "Female", "1998-01-21", "Bachelor", "35401489", "HR", "0025"}
        };

        //Insert array starting at row 2, column 1
        sheet.insertArray(data, 2, 1);

        //Set row height for data rows
        sheet.getRange().get("A2:G7").setRowHeight(15);

        //Adjust column widths for readability
        sheet.setColumnWidth(2, 15);
        sheet.setColumnWidth(3, 21);
        sheet.setColumnWidth(4, 15);

        //Apply border styles to the data range
        sheet.getRange().get("A2:G7").borderAround(LineStyleType.Medium);
        sheet.getRange().get("A2:G7").borderInside(LineStyleType.Thin);
        sheet.getRange().get("A2:G2").borderAround(LineStyleType.Medium);
        sheet.getRange().get("A2:G7").getBorders().setKnownColor(ExcelColors.Black);

        //Save to an .xlsx file
        wb.saveToFile("output/NewSpreadsheet.xlsx", FileFormat.Version2016);
        wb.dispose();
    }
}

Key methods in this example:

getWorksheets().add() creates a new named worksheet
getRange().get() references specific cells or ranges
setValue() writes content to a cell
insertArray() populates a range from a two-dimensional array in one operation
saveToFile() writes the workbook to disk

Reading Data from a Worksheet

To retrieve data from an existing file, load the workbook, access the target worksheet, and iterate through cells to extract their values.

import com.spire.xls.*;

public class ReadData {

    public static void main(String[] args) {

        //Create a Workbook instance
        Workbook wb = new Workbook();

        //Load an Excel file
        wb.loadFromFile("C:/Users/Administrator/Desktop/NewSpreadsheet.xlsx");

        //Access the first worksheet
        Worksheet sheet = wb.getWorksheets().get(0);

        //Get the range containing actual data
        CellRange locatedRange = sheet.getAllocatedRange();

        //Loop through rows and columns
        for (int i = 0; i < locatedRange.getRows().length; i++) {
            for (int j = 0; j < locatedRange.getColumnCount(); j++) {
                System.out.print(locatedRange.get(i + 1, j + 1).getValue() + "  ");
            }
            System.out.println();
        }
        wb.dispose();
    }
}

The getAllocatedRange() method automatically detects the area of the worksheet that contains data, which is useful when you don't know the exact boundaries in advance. The getValue() method returns cell contents, handling both text and numeric values.

Updating an Existing Workbook

Modifying a workbook follows a straightforward pattern: load the file, change specific cells or ranges, and save the result.

import com.spire.xls.*;

public class UpdateExcel {

    public static void main(String[] args) {

        //Create a Workbook instance
        Workbook wb = new Workbook();

        //Load an Excel file
        wb.loadFromFile("C:/Users/Administrator/Desktop/NewSpreadsheet.xlsx");

        //Access the first worksheet
        Worksheet sheet = wb.getWorksheets().get(0);

        //Update a single cell
        sheet.getRange().get("A1").setValue("Updated Employee Information");

        //Save changes to a new file
        wb.saveToFile("output/Updated.xlsx", FileFormat.Version2016);
        wb.dispose();
    }
}

This approach works well for targeted modifications. For bulk updates, you can combine cell-range iteration with conditional logic to apply changes selectively. When saving, writing to a new file rather than overwriting the original preserves the source data, which can be useful during debugging.

Other Libraries for Excel Processing in Java

Several alternatives exist in the Java ecosystem for Excel manipulation:

Library	License	Notable Characteristics
Apache POI	Apache 2.0 (open source)	Mature project with broad format support; API can be verbose for simple tasks
EasyExcel	Apache 2.0 (open source)	Memory-efficient streaming approach; well-suited for large file processing
Aspose.Cells	Commercial	Extensive feature set including charts and advanced formatting

The choice depends on your project's requirements. Apache POI provides comprehensive functionality without licensing costs but can require more boilerplate code. EasyExcel, originally developed by Alibaba, emphasizes memory efficiency when handling large datasets. Aspose.Cells is a commercial product with support for advanced Excel features beyond basic data manipulation.

Conclusion

Creating, reading, and updating Excel documents in Java with Spire.XLS for Java involves working with the Workbook and Worksheet classes to manipulate cell ranges and their values. The examples in this article covered writing formatted data from arrays, reading cell contents through iteration, and modifying specific cells before saving. These operations serve as fundamental building blocks for more complex Excel automation tasks such as merging multiple workbooks, converting spreadsheets to PDF format, or generating pivot tables. When evaluating this library for your projects, consider the free version's worksheet limitations and whether they align with the scale of your typical documents. For further information, the library's documentation covers additional topics including chart creation, formula calculation, and data import from external sources.

How to Split a PDF File into Multiple PDFs in Java

Pilalo — Thu, 07 May 2026 02:25:02 +0000

Working with PDF documents programmatically is a routine task for many Java developers. Whether you're building a document management system, automating report processing, or creating a content extraction pipeline, PDF manipulation capabilities are often essential.

One of the most common requirements is splitting a multi-page PDF into smaller, more manageable files. For instance, you might need to separate an invoice batch into individual invoices, extract a specific chapter from an eBook, or isolate a single form from a larger document package.

This article demonstrates how to accomplish PDF splitting in Java using a third-party PDF library. We'll cover two practical scenarios: splitting an entire document into single-page PDFs and extracting specific page ranges into new files.

Prerequisites and Setup

Before writing code, you need to add the library to your project. If you use Maven, add the following repository and dependency to your pom.xml file:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.4.4</version>
    </dependency>
</dependencies>

After adding the dependency, refresh your project to download the required JAR files. You'll need a compatible JDK version (Java 8 or later) to use this library.

Scenario 1: Splitting a PDF into Single-Page Files

One of the most straightforward use cases is dividing a multi-page PDF so that each page becomes its own standalone PDF file. This is particularly useful when you need to archive individual pages separately, distribute specific pages to different recipients, or process pages independently in a downstream workflow.

The library provides a split() method that handles this operation. Here's an example:

import com.spire.pdf.PdfDocument;

public class SplitPdfByEachPage {
    public static void main(String[] args) {
        // Specify the input file path
        String inputFile = "C:\\Users\\Administrator\\Desktop\\Terms of Service.pdf";

        // Specify the output directory
        String outputDirectory = "C:\\Users\\Administrator\\Desktop\\Output\\";

        // Create a PdfDocument object
        PdfDocument doc = new PdfDocument();

        // Load a PDF file
        doc.loadFromFile(inputFile);

        // Split the PDF into one-page PDFs
        doc.split(outputDirectory + "output-{0}.pdf", 1);

        // Close the document
        doc.close();
    }
}

How this works: The split() method takes two parameters:

destFilePattern: A string specifying the output file naming pattern. The placeholder {0} is replaced with sequential numbers as each page is saved.
startNumber: The starting index for the numbering sequence. Setting this to 1 means your first output file will be named output-1.pdf.

After running this code, you'll find individual PDF files in your specified output directory, each containing exactly one page from the original document.

Scenario 2: Splitting a PDF by Page Ranges

In many cases, you don't need every page as a separate file. Instead, you might want to extract a specific page range—perhaps the first page as a cover, a middle chapter, or a subset of pages for a particular audience.

While the library does not offer a single method for splitting by page ranges, you can achieve this by creating new PdfDocument objects and selectively importing pages from the source document. Here's an example that extracts the first page into one file and the remaining pages into another:

import com.spire.pdf.PdfDocument;

public class SplitPdfByPageRange {
    public static void main(String[] args) {
        // Specify the input file path
        String inputFile = "C:\\Users\\Administrator\\Desktop\\Terms of Service.pdf";

        // Specify the output directory
        String outputDirectory = "C:\\Users\\Administrator\\Desktop\\Output\\";

        // Load the source PDF file
        PdfDocument sourceDoc = new PdfDocument();
        sourceDoc.loadFromFile(inputFile);

        // Create two new PdfDocument objects
        PdfDocument newDoc_1 = new PdfDocument();
        PdfDocument newDoc_2 = new PdfDocument();

        // Insert the first page of source file to the first document
        newDoc_1.insertPage(sourceDoc, 0);

        // Insert the remaining pages to the second document
        newDoc_2.insertPageRange(sourceDoc, 1, sourceDoc.getPages().getCount() - 1);

        // Save the two documents as separate PDF files
        newDoc_1.saveToFile(outputDirectory + "output-1.pdf");
        newDoc_2.saveToFile(outputDirectory + "output-2.pdf");

        // Close all documents
        sourceDoc.close();
        newDoc_1.close();
        newDoc_2.close();
    }
}

Key points to note:

Zero-based indexing: Pages are indexed starting from 0, so the first page in your PDF corresponds to index 0, the second page to index 1, and so on.
insertPage(PdfDocument doc, int pageIndex) imports a single page at the specified index.
insertPageRange(PdfDocument doc, int startIndex, int endIndex) imports a continuous range of pages.
The method getPages().getCount() returns the total number of pages, making it easy to specify ranges relative to the document's end.

This approach gives you granular control. You can adapt it to extract any combination of pages by modifying the indices or adding more target documents.

Which Approach Should You Choose?

Approach	Best For
`split()` method	When you need every page as a separate file
`insertPage()` / `insertPageRange()`	When you need specific pages or ranges extracted into one or more new documents

If your use case involves splitting a document into equal parts (for example, splitting a 100-page PDF into 10 files of 10 pages each), you can combine the second approach with a loop that increments the start and end indices accordingly.

Important Considerations

Handling large documents: When working with very large PDFs, be mindful of memory usage. Each PdfDocument object holds its content in memory, so processing very large files may require adjusting your JVM heap settings.

File paths and permissions: Ensure your output directory exists and your application has write permissions. The examples above use Windows-style paths; adapt them to your operating system as needed.

Closing resources: Always call the close() method on your PdfDocument objects when you're done with them to release system resources. Alternatively, you can use try-with-resources if the class supports the AutoCloseable interface.

Constructor usage: In the first example, a PdfDocument object is created with the no-argument constructor and then the file is loaded with loadFromFile(). In the second example, for sourceDoc, the same approach is used. The library also supports a constructor that accepts a file path directly, but using loadFromFile() makes the loading step explicit and is compatible with all versions.

Alternative Libraries

While this tutorial uses Spire.PDF for Java, there are other libraries in the Java ecosystem for PDF manipulation, including Apache PDFBox (open-source) and iText (AGPL/commercial licensing). Each has its own API design, feature set, and licensing model. The choice of library depends on your project's specific requirements, budget, and licensing constraints.

If you are evaluating this library, note that it offers a free version with limitations on the number of pages it can process per document. For small documents or evaluation purposes, this can be a practical starting point before deciding whether a paid license is necessary for your use case.

Conclusion

Splitting PDF files programmatically in Java is a straightforward task. The split() method handles the common case of breaking a document into single-page files, while the insertPage() and insertPageRange() methods provide the flexibility to extract specific page ranges for more tailored requirements.

The complete code examples shown here should give you a solid foundation for integrating PDF splitting into your own Java applications.

Combining PDF Documents with Java: A Hands-On Guide

Pilalo — Tue, 28 Apr 2026 02:06:05 +0000

Merging PDF documents is a fundamental operation in many document management workflows. Whether you're aggregating monthly reports into a single file, combining contract sections from different sources, or building an automated archiving system, the ability to programmatically join PDFs is a valuable tool in a Java developer's toolkit. In this article, I'll walk through several approaches to merging PDF files using Spire.PDF for Java, covering full document merges, selective page combining, and stream-based operations.

Common Use Cases for PDF Merging

Before diving into the code, let's consider the scenarios where PDF merging comes into play:

Financial Report Compilation: Banks and accounting firms combining quarterly statements into annual reports.
Legal Document Assembly: Law firms merging contract sections, exhibits, and appendices from various sources.
Invoice Consolidation: E-commerce platforms grouping multiple invoices for batch processing or customer delivery.
Digital Archiving: Organizations merging scanned documents into unified archival records.
Print Job Preparation: Combining multiple documents for efficient batch printing.

Each of these scenarios presents slightly different requirements—sometimes you need the entire document, other times only specific pages, and occasionally the source files aren't even stored on disk.

Setting Up the Library

To include Spire.PDF for Java in your project, add the following dependency to your Maven pom.xml:

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.4.4</version>
    </dependency>
</dependencies>

If you're using Gradle or managing JARs manually, you can obtain the artifact from the vendor's distribution source.

Basic Merge: Combining Complete PDF Files

The simplest scenario is merging entire PDF documents end-to-end. The PdfDocument.mergeFiles() method handles this in a single operation:

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfDocumentBase;

public class MergePdfs {
    public static void main(String[] args) {
        // Define the paths of the PDF files to be merged
        String[] files = new String[] {
            "Sample1.pdf", 
            "Sample2.pdf", 
            "Sample3.pdf"
        };

        // Merge the files into a single PdfDocumentBase object
        PdfDocumentBase pdf = PdfDocument.mergeFiles(files);

        // Save the merged result
        pdf.save("MergedDocument.pdf", FileFormat.PDF);
    }
}

How it works: The mergeFiles() method takes an array of file paths. It processes the files in the array order—first element becomes the first pages, second element follows, and so on. The method returns a PdfDocumentBase object representing the combined result, which you can then save or further manipulate.

This approach works well when you have a relatively small number of files and want all pages from each source document included in the output.

Selective Page Merging: Combining Specific Pages Only

In many real-world scenarios, you don't need every page from every document. You might only want the cover page from one file, the body content from another, and the appendix from a third. The library supports this through insertPage() and insertPageRange() methods:

import com.spire.pdf.PdfDocument;

public class MergeSelectedPages {
    public static void main(String[] args) {
        // Define source files
        String[] files = new String[] {
            "Sample1.pdf", 
            "Sample2.pdf", 
            "Sample3.pdf"
        };

        // Load each source document
        PdfDocument[] pdfs = new PdfDocument[files.length];
        for (int i = 0; i < files.length; i++) {
            pdfs[i] = new PdfDocument(files[i]);
        }

        // Create a new empty PDF as the merge target
        PdfDocument pdf = new PdfDocument();

        // Insert specific pages from each source
        pdf.insertPage(pdfs[0], 0);            // Page 1 from first file
        pdf.insertPageRange(pdfs[1], 1, 3);    // Pages 2-4 from second file
        pdf.insertPage(pdfs[2], 0);            // Page 1 from third file

        // Save the selectively merged document
        pdf.saveToFile("SelectivelyMerged.pdf");

        // Close source documents
        for (PdfDocument source : pdfs) {
            source.close();
        }
        pdf.close();
    }
}

Page indexing note: The insertPage() and insertPageRange() methods use zero-based indexing. So insertPage(pdfs[0], 0) inserts the first page, and insertPageRange(pdfs[1], 1, 3) inserts pages 2 through 4 (indices 1, 2, and 3) from the second document.

This approach gives you precise control over the composition of the final document, which is particularly useful for generating report summaries, extracting specific chapters, or removing unnecessary pages like blank separators.

Stream-Based Merging: Working Without Local Files

Not all PDFs exist as physical files on a disk. In web applications, microservices, or message-driven systems, documents might arrive as input streams from network downloads, database BLOBs, or in-memory generation. The mergeFiles() method also accepts InputStream arrays:

import com.spire.pdf.*;
import java.io.*;

public class MergePdfsByStream {
    public static void main(String[] args) throws IOException {
        // Create FileInputStream objects for each PDF
        FileInputStream stream1 = new FileInputStream(new File("Template_1.pdf"));
        FileInputStream stream2 = new FileInputStream(new File("Template_2.pdf"));
        FileInputStream stream3 = new FileInputStream(new File("Template_3.pdf"));

        // Combine streams into an array
        InputStream[] streams = new FileInputStream[]{
            stream1, stream2, stream3
        };

        // Merge the streams
        PdfDocumentBase pdf = PdfDocument.mergeFiles(streams);

        // Save the result
        pdf.save("MergedByStream.pdf", FileFormat.PDF);

        // Release resources
        pdf.close();
        pdf.dispose();
        stream1.close();
        stream2.close();
        stream3.close();
    }
}

This approach is useful when source files come from non-file sources or when you're working in environments where direct file system access is limited.

Batch Processing: Handling Large Numbers of Files

When dealing with a large collection of PDFs—say, hundreds of files—loading all of them into memory simultaneously can be impractical. A chunked processing strategy can help manage memory usage:

import com.spire.pdf.*;
import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class BatchPdfMerger {
    private static final int CHUNK_SIZE = 20;

    public static void main(String[] args) {
        File inputDir = new File("input-pdfs");
        File[] pdfFiles = inputDir.listFiles(
            (dir, name) -> name.toLowerCase().endsWith(".pdf")
        );

        if (pdfFiles == null || pdfFiles.length == 0) {
            System.out.println("No PDF files found.");
            return;
        }

        List<String> tempFiles = new ArrayList<>();

        // Process in chunks
        for (int i = 0; i < pdfFiles.length; i += CHUNK_SIZE) {
            int end = Math.min(i + CHUNK_SIZE, pdfFiles.length);
            String[] chunk = new String[end - i];

            for (int j = i; j < end; j++) {
                chunk[j - i] = pdfFiles[j].getAbsolutePath();
            }

            // Merge the current chunk
            PdfDocumentBase merged = PdfDocument.mergeFiles(chunk);
            String tempPath = "temp_chunk_" + (i / CHUNK_SIZE) + ".pdf";
            merged.save(tempPath, FileFormat.PDF);
            merged.close();
            tempFiles.add(tempPath);
        }

        // Merge all temp chunks into final output
        if (tempFiles.size() == 1) {
            File tempFile = new File(tempFiles.get(0));
            tempFile.renameTo(new File("FinalMerged.pdf"));
        } else {
            PdfDocumentBase finalPdf = PdfDocument.mergeFiles(
                tempFiles.toArray(new String[0])
            );
            finalPdf.save("FinalMerged.pdf", FileFormat.PDF);
            finalPdf.close();

            // Clean up temp files
            for (String temp : tempFiles) {
                new File(temp).delete();
            }
        }
    }
}

This strategy first merges documents in manageable chunks, writes temporary intermediate files, then merges those intermediate files into the final output. While it adds some disk I/O overhead, it reduces peak memory consumption significantly.

Important Implementation Considerations

Memory Management: PDF merging can be memory-intensive because each source document must be fully loaded and parsed. For large documents or high-volume batch jobs, processing in chunks and promptly closing source documents after use helps prevent OutOfMemoryError exceptions.

Page Indexing: Remember that page indices are zero-based. The first page is index 0. When using insertPageRange(), both start and end indices are inclusive.

Resource Cleanup: Always close PdfDocument objects and input streams when you're done with them. The close() and dispose() methods release native resources. In production code, consider using try-with-resources or try-finally blocks to ensure cleanup even when exceptions occur.

File Order: The mergeFiles() method maintains the order of the input array. The first file in the array becomes the beginning of the merged document, and the last file becomes the end.

Licensing: The library requires a valid license for production use. Without one, the output will contain an evaluation watermark. For development and testing, this is expected behavior.

Alternative Approaches

While this article focuses on Spire.PDF for Java, other libraries in the Java ecosystem offer PDF merging capabilities:

Apache PDFBox: Open-source library providing low-level PDF manipulation. Merging requires more manual code but offers full control over the process.
iText: Widely used library with both open-source (AGPL) and commercial licensing. Provides PdfMerger class for combining documents.
PDFsam: Open-source tool with both GUI and command-line interfaces. The underlying library can be integrated programmatically.

Each library has different trade-offs in terms of ease of use, performance characteristics, and licensing requirements.

Wrapping Up

Merging PDF files in Java is a well-supported operation with the right library. Whether you need simple full-document concatenation, precise page-level selection, or stream-based processing for non-file sources, the API provides consistent methods to accomplish these tasks.

The examples in this guide cover the most common scenarios. As your requirements grow, you might also explore related capabilities like splitting PDFs, adding watermarks during merge, or handling encrypted source documents—features available through the same library.

Generating PDF Files in Java: A Practical Guide

Pilalo — Thu, 23 Apr 2026 01:59:22 +0000

PDF generation is a common requirement in enterprise applications, whether you're producing invoices, reports, contracts, or digital receipts. While Java doesn't include native PDF creation capabilities in its standard library, several third-party libraries fill this gap effectively. In this article, I'll walk through how to generate PDF files programmatically using Spire.PDF for Java, covering several practical scenarios developers frequently encounter.

Why Generate PDFs Programmatically?

Before diving into code, it's worth understanding the scenarios where dynamic PDF generation adds value:

Invoice and Receipt Generation: E-commerce platforms automatically generating order confirmations
Financial Reporting: Banks and investment firms producing account statements
Document Automation: Legal and insurance firms creating contracts from templates
Certificate Creation: Educational platforms issuing completion certificates
Data Export: Converting database query results into formatted PDF reports

Programmatic generation ensures consistency, reduces manual work, and integrates seamlessly into automated workflows.

Setting Up the Library

To use Spire.PDF for Java, add the following dependency to your Maven pom.xml:

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>11.12.16</version>
    </dependency>
</dependencies>

If you're using Gradle or managing JARs manually, you can obtain the artifact from the vendor's repository or distribution source.

Creating a Simple PDF Document

Let's start with a basic example: generating a PDF that contains a title, a paragraph of text, and a simple list. This demonstrates the fundamental pattern of creating a document, adding a page, and drawing content.

import com.spire.pdf.*;
import com.spire.pdf.graphics.*;
import java.awt.*;

public class SimplePdfGenerator {
    public static void main(String[] args) {
        // Create a PdfDocument instance
        PdfDocument doc = new PdfDocument();

        // Configure page settings
        doc.getPageSettings().setSize(PdfPageSize.A4);
        doc.getPageSettings().setMargins(40f);

        // Add a page
        PdfPageBase page = doc.getPages().add();

        // Create fonts and brushes
        PdfFont titleFont = new PdfFont(PdfFontFamily.Helvetica, 18f, PdfFontStyle.Bold);
        PdfFont bodyFont = new PdfFont(PdfFontFamily.Helvetica, 12f);
        PdfSolidBrush brush = new PdfSolidBrush(new PdfRGBColor(Color.BLACK));

        // Draw title
        page.getCanvas().drawString("Monthly Report", titleFont, brush, 0, 0);

        // Draw paragraph
        String paragraph = "This report summarizes the key metrics for the current " +
                "month. All figures are preliminary and subject to final review.";
        page.getCanvas().drawString(paragraph, bodyFont, brush, 0, 40);

        // Draw a simple list
        String[] items = {"Revenue: $125,000", "Expenses: $78,000", "Net Profit: $47,000"};
        float y = 80;
        for (String item : items) {
            page.getCanvas().drawString("• " + item, bodyFont, brush, 10, y);
            y += 20;
        }

        // Save the document
        doc.saveToFile("SimpleReport.pdf");
        doc.close();
    }
}

Key points about this code:

PdfDocument is the root object representing the entire PDF file
PdfPageBase represents a single page; you can add multiple pages as needed
Content is drawn using drawString() with coordinates specifying the position
Fonts and colors are defined using PdfFont and PdfSolidBrush classes

Creating a PDF with Tables

Tables are essential for presenting structured data. Here's how to create a PDF containing a formatted table, which is useful for invoices, financial statements, or any tabular data:

import com.spire.pdf.*;
import com.spire.pdf.graphics.*;
import com.spire.pdf.tables.*;
import java.awt.*;

public class TablePdfGenerator {
    public static void main(String[] args) {
        PdfDocument doc = new PdfDocument();
        PdfPageBase page = doc.getPages().add();

        // Define table data
        String[][] data = {
            {"Product", "Quantity", "Unit Price", "Total"},
            {"Laptop", "2", "$899.00", "$1,798.00"},
            {"Monitor", "3", "$249.00", "$747.00"},
            {"Keyboard", "5", "$49.00", "$245.00"},
            {"Mouse", "5", "$25.00", "$125.00"}
        };

        // Create and configure table
        PdfTable table = new PdfTable();
        table.getStyle().setCellPadding(5f);
        table.getStyle().setBorderPen(new PdfPen(PdfBrushes.getBlack(), 1f));
        table.getStyle().setHeaderRowCount(1);

        // Populate table
        for (String[] row : data) {
            PdfRow pdfRow = table.getRows().add();
            for (String cell : row) {
                pdfRow.getCells().add(cell);
            }
        }

        // Apply header styling
        PdfRow headerRow = table.getRows().get(0);
        headerRow.getStyle().setBackgroundBrush(PdfBrushes.getLightGray());
        headerRow.getStyle().setFont(new PdfFont(PdfFontFamily.Helvetica, 12f, PdfFontStyle.Bold));

        // Draw table on page
        table.draw(page, 0, 30);

        doc.saveToFile("TableReport.pdf");
        doc.close();
    }
}

The PdfTable class provides methods for styling borders, cell padding, and header formatting. Tables automatically calculate column widths based on content unless explicitly specified.

Creating a PDF with Images

Adding images to PDFs is straightforward. This example demonstrates how to embed an image at a specific location:

import com.spire.pdf.*;
import com.spire.pdf.graphics.*;
import java.awt.geom.Rectangle2D;

public class ImagePdfGenerator {
    public static void main(String[] args) {
        PdfDocument doc = new PdfDocument();
        PdfPageBase page = doc.getPages().add();

        // Load image from file
        PdfImage image = PdfImage.fromFile("logo.png");

        // Define position and size
        float x = 50;
        float y = 50;
        float width = 200;
        float height = 100;

        // Draw image on page
        page.getCanvas().drawImage(image, new Rectangle2D.Float(x, y, width, height));

        // Draw caption below image
        PdfFont captionFont = new PdfFont(PdfFontFamily.Helvetica, 10f, PdfFontStyle.Italic);
        page.getCanvas().drawString("Figure 1: Company Logo", captionFont, 
                PdfBrushes.getDarkGray(), x, y + height + 5);

        doc.saveToFile("ImageDocument.pdf");
        doc.close();
    }
}

Images can be loaded from files, streams, or byte arrays. The drawImage() method accepts a Rectangle2D that defines both position and dimensions, allowing you to scale images as needed.

Generating PDF from HTML Content

Sometimes it's more practical to design document layouts using HTML and CSS rather than positioning elements programmatically. The library supports converting HTML strings, files, or URLs directly to PDF :

import com.spire.pdf.graphics.PdfMargins;
import com.spire.pdf.htmlconverter.LoadHtmlType;
import com.spire.pdf.htmlconverter.qt.HtmlConverter;
import com.spire.pdf.htmlconverter.qt.Size;

public class HtmlToPdfGenerator {
    public static void main(String[] args) {
        // HTML content as string
        String htmlContent = "<html>" +
                "<head><style>body { font-family: Arial; } h1 { color: #2c3e50; }</style></head>" +
                "<body>" +
                "<h1>Invoice #INV-2024-001</h1>" +
                "<p>Dear Customer,</p>" +
                "<p>Thank you for your business. Please find your invoice details below.</p>" +
                "<table border='1' style='border-collapse: collapse;'>" +
                "<tr><th>Item</th><th>Price</th></tr>" +
                "<tr><td>Consulting Services</td><td>$1,500.00</td></tr>" +
                "<tr><td>Software License</td><td>$299.00</td></tr>" +
                "</table>" +
                "</body></html>";

        // Specify output file
        String outputFile = "InvoiceFromHtml.pdf";

        // Convert HTML string to PDF
        HtmlConverter.convert(htmlContent, outputFile, 
                true,                    // enable JavaScript
                100000,                  // timeout in milliseconds
                new Size(700, 900),      // page size
                new PdfMargins(0),       // margins
                LoadHtmlType.Source_Code // input type
        );
    }
}

This approach is particularly useful when you already have HTML templates for emails or web pages and want to repurpose them for PDF generation.

Creating PDF from Plain Text

If you have plain text content that needs to be formatted as a PDF document, this can also be accomplished with the library. This is useful for converting log files, configuration data, or any textual output :

import com.spire.pdf.*;
import com.spire.pdf.graphics.*;
import java.awt.*;
import java.awt.geom.Rectangle2D;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TextToPdfGenerator {
    public static void main(String[] args) throws IOException {
        // Read text from file
        String text = readTextFromFile("sample.txt");

        PdfDocument pdf = new PdfDocument();
        PdfPageBase page = pdf.getPages().add();

        // Create font and layout settings
        PdfTrueTypeFont font = new PdfTrueTypeFont(new Font("Arial", Font.PLAIN, 11));
        PdfTextLayout textLayout = new PdfTextLayout();
        textLayout.setBreak(PdfLayoutBreakType.Fit_Page);
        textLayout.setLayout(PdfLayoutType.Paginate);

        // Create text widget and draw
        PdfTextWidget textWidget = new PdfTextWidget(text, font, PdfBrushes.getBlack());
        Rectangle2D.Float bounds = new Rectangle2D.Float();
        bounds.setRect(0, 25, page.getCanvas().getClientSize().getWidth(), 
                page.getCanvas().getClientSize().getHeight());
        textWidget.draw(page, bounds, textLayout);

        pdf.saveToFile("TextConverted.pdf", FileFormat.PDF);
        pdf.close();
    }

    private static String readTextFromFile(String fileName) throws IOException {
        StringBuilder sb = new StringBuilder();
        try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = br.readLine()) != null) {
                sb.append(line).append("\n");
            }
        }
        return sb.toString();
    }
}

The PdfTextWidget class handles text pagination automatically, flowing content across multiple pages when necessary.

Important Implementation Considerations

Font Availability: When using specific fonts, ensure they are available on the system or embed them in the PDF. The PdfTrueTypeFont class allows loading custom font files.

Memory Management: Generating large PDFs with many pages or high-resolution images can consume significant memory. Process documents sequentially and close resources promptly after saving.

Coordinate System: PDF coordinates originate at the top-left corner of the page. Plan your layout accordingly to avoid overlapping elements.

Licensing: The library requires a valid license for production use. Without a license, generated documents will contain an evaluation watermark. For development and testing, this is expected behavior.

Alternative Approaches

Several other libraries in the Java ecosystem offer PDF generation capabilities:

Apache PDFBox: Open-source library providing low-level PDF manipulation. Good for basic generation but requires more code for complex layouts.
iText: Widely used library with both open-source (AGPL) and commercial licensing options. Extensive features for advanced PDF workflows.
Apache FOP: XML-based formatting using XSL-FO templates. Well-suited for batch document generation from structured data.
JasperReports: Reporting library that can export to PDF along with other formats. Ideal for report-centric applications.

Each library has different strengths in terms of learning curve, feature set, and licensing terms.

Wrapping Up

Generating PDF files programmatically in Java is straightforward with the right tooling. Whether you need simple text documents, complex tables, embedded images, or HTML-to-PDF conversion, the API provides consistent methods to achieve your goals.

The examples in this guide cover common scenarios, but the library offers additional capabilities, including form field creation, digital signatures, encryption, and document merging—features that may be valuable as your application's PDF requirements grow.

Have you implemented PDF generation in your Java projects? What approaches have worked well for your use cases? I'd be interested in hearing about your experiences.

A Practical Guide to Converting PDFs to PDF/A in Java

Pilalo — Thu, 16 Apr 2026 01:53:32 +0000

When managing documents for long-term preservation, the standard PDF format has inherent limitations. Fonts may not be embedded, dynamic elements like JavaScript can behave unpredictably, and external references might break over time. For applications in government archives, legal compliance, healthcare records, or financial documentation, these risks are unacceptable.

This is where PDF/A comes in. As an ISO-standardized format (ISO 19005), PDF/A ensures that documents remain self-contained and visually reproducible for decades, regardless of software or hardware changes. In this article, I'll walk through how to programmatically convert standard PDFs to PDF/A using Spire.PDF for Java.

Understanding PDF/A Compliance Levels

Before writing code, it's helpful to understand the different PDF/A variants and when to use each one. PDF/A has evolved through three major versions, each with "a" (accessible) and "b" (basic) conformance levels:

Version	Based On	Key Characteristics
PDF/A-1a / 1b	PDF 1.4	The earliest standard. 1a requires tagged document structure for accessibility; 1b only requires visual consistency. No transparency or layers.
PDF/A-2a / 2b	PDF 1.7	Adds support for transparency, JPEG2000 compression, and layers. Better for modern documents with complex graphics.
PDF/A-3a / 3b	PDF 1.7	Extends PDF/A-2 by allowing arbitrary file attachments (XML, source documents). Useful when preserving associated data alongside the PDF.

For most archiving scenarios, PDF/A-1b or PDF/A-2b is sufficient. PDF/A-1b is the most widely accepted archival standard, while PDF/A-2b is preferred if your documents contain transparency effects or modern compression.

Setting Up the Library

To use Spire.PDF for Java, add the following dependency to your Maven pom.xml:

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.3.9</version>
    </dependency>
</dependencies>

If you're using Gradle or managing JARs manually, you can obtain the artifact from the vendor's repository or distribution source.

Basic Conversion: Single File to PDF/A

The conversion process uses the PdfStandardsConverter class. Here's a complete example that converts a PDF to all available PDF/A variants:

import com.spire.pdf.conversion.PdfStandardsConverter;

public class ConvertPdfToPdfA {
    public static void main(String[] args) {
        // Create a PdfStandardsConverter instance with the source file
        PdfStandardsConverter converter = new PdfStandardsConverter("sample.pdf");

        // Convert to various PDF/A compliance levels
        converter.toPdfA1A("output/ToPdfA1A.pdf");
        converter.toPdfA1B("output/ToPdfA1B.pdf");
        converter.toPdfA2A("output/ToPdfA2A.pdf");
        converter.toPdfA2B("output/ToPdfA2B.pdf");
        converter.toPdfA3A("output/ToPdfA3A.pdf");
        converter.toPdfA3B("output/ToPdfA3B.pdf");

        System.out.println("Conversion complete.");
    }
}

The library handles compliance requirements automatically, so you don't need to manually embed fonts, adjust color spaces, or validate the output against the ISO standard.

Working with Streams

For web applications or service-oriented architectures, you may want to work with OutputStream rather than file paths. The API supports this pattern as well:

import com.spire.pdf.conversion.PdfStandardsConverter;
import java.io.*;

public class ConvertToStream {
    public static void main(String[] args) throws IOException {
        PdfStandardsConverter converter = new PdfStandardsConverter("sample.pdf");

        // Convert to PDF/A-1B and write to an OutputStream
        try (FileOutputStream outputStream = new FileOutputStream("output.pdf")) {
            converter.toPdfA1B(outputStream);
        }

        // Alternatively, work with byte arrays for in-memory processing
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        converter.toPdfA2B(baos);
        byte[] pdfABytes = baos.toByteArray();

        System.out.println("Conversion to stream complete.");
    }
}

This approach is useful when integrating PDF/A generation into REST APIs or message-driven systems where you need to return the converted document directly.

Batch Processing Multiple PDFs

For archiving large document collections, batch processing is essential. Here's a practical script that converts all PDFs in a directory to PDF/A-1b:

import com.spire.pdf.conversion.PdfStandardsConverter;
import java.io.File;

public class BatchConvertToPdfA {
    public static void main(String[] args) {
        File inputDir = new File("input-pdfs");
        File outputDir = new File("output-pdfa");
        outputDir.mkdirs();

        File[] pdfFiles = inputDir.listFiles((dir, name) -> 
            name.toLowerCase().endsWith(".pdf"));

        if (pdfFiles == null) {
            System.out.println("No PDF files found.");
            return;
        }

        int successCount = 0;
        int failCount = 0;

        for (File pdfFile : pdfFiles) {
            try {
                PdfStandardsConverter converter = new PdfStandardsConverter(
                    pdfFile.getAbsolutePath()
                );

                String outputName = pdfFile.getName().replace(".pdf", "") + "_PDFA.pdf";
                String outputPath = new File(outputDir, outputName).getAbsolutePath();

                converter.toPdfA1B(outputPath);

                System.out.println("Converted: " + pdfFile.getName());
                successCount++;
            } catch (Exception e) {
                System.err.println("Failed: " + pdfFile.getName() + " - " + e.getMessage());
                failCount++;
            }
        }

        System.out.println("\nBatch complete. Success: " + successCount + ", Failed: " + failCount);
    }
}

Important Considerations

Choosing the Right Compliance Level: PDF/A-1b offers maximum compatibility with older viewers, while PDF/A-2b supports modern features. If you're unsure, PDF/A-1b is the safest default for long-term archiving.

Post-Conversion Editing: Any modifications made after converting to PDF/A—including adding annotations, watermarks, or form field updates—may break compliance. The recommended workflow is to perform all edits before the final conversion step.

Form Fields and Interactive Elements: Be aware that interactive PDF features like form fields may not behave identically after PDF/A conversion, as the standard restricts dynamic content. Test thoroughly if your use case involves fillable forms.

Memory Usage: When processing very large PDFs or high-volume batches, consider processing files sequentially and releasing references promptly to avoid memory pressure.

Licensing: The library requires a valid license for production use. Without a license, the output will contain an evaluation watermark. For development and testing, this is expected behavior.

Alternative Approaches

While this article focuses on Spire.PDF for Java, other libraries in the Java ecosystem offer PDF/A capabilities:

Apache PDFBox: Open-source, provides low-level PDF manipulation but requires manual implementation of PDF/A compliance checks.
iText: Offers PDF/A conversion in its commercial versions (iText 7 Core with pdfCalligraph add-on).
VeraPDF: An open-source validator for checking PDF/A compliance, useful for verification workflows.

Each approach has different trade-offs in terms of automation, compliance guarantee, and licensing requirements.

Validating the Output

After conversion, you may want to verify that the resulting file meets PDF/A standards. While the library handles compliance internally, you can use a validation tool like VeraPDF for independent verification:

// Conceptual validation workflow
// Use VeraPDF CLI or API to validate the generated file
ProcessBuilder pb = new ProcessBuilder(
    "verapdf", "--format", "text", "output/ToPdfA1B.pdf"
);

This additional step is recommended for archival workflows where compliance must be guaranteed and documented.

Wrapping Up

Converting PDFs to PDF/A is straightforward with the right tooling. The PdfStandardsConverter class abstracts away the complexities of font embedding, metadata generation, and standards compliance, letting you focus on your application logic rather than the intricacies of ISO 19005.

Whether you're building a document management system that requires archival-grade output, migrating legacy content for long-term preservation, or implementing compliance workflows for regulated industries, PDF/A conversion is a valuable capability to have in your Java toolkit.

Have you worked with PDF/A in your projects? What compliance level did you choose, and what challenges did you encounter? I'd be interested in hearing about your experiences.

A Practical Guide to Converting PDFs to Images in Java

Pilalo — Fri, 10 Apr 2026 02:25:55 +0000

When building applications that handle document processing, converting PDF files to images is a common requirement. Whether you're generating thumbnails for a document management system, creating previews for a web application, or preparing content for image-based workflows, having a reliable conversion method is essential. In this article, I'll walk through how to accomplish this using Spire.PDF for Java.

Common Use Cases

Before diving into the code, it's worth understanding why you might need PDF-to-image conversion:

Web Previews: Displaying document thumbnails without requiring users to download the full PDF.
Content Embedding: Inserting document pages into presentations or reports.
Image Processing: Performing OCR or applying image filters to PDF content.
Print Optimization: Converting to formats that printers handle more reliably.

Setting Up the Library

To include Spire.PDF for Java in your project, add the following dependency coordinates to your build configuration.

For Maven users, add the dependency to your pom.xml:

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>11.12.16</version>
    </dependency>
</dependencies>

If you are using Gradle or managing JARs manually, you will need to acquire the artifact from the relevant repository or distribution source.

Basic Conversion: Entire PDF to Multiple Images

The most straightforward approach is converting every page of a PDF into separate image files. Here's how to do it:

import com.spire.pdf.*;
import com.spire.pdf.graphics.PdfImageType;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class PDFtoImage {
    public static void main(String[] args) throws IOException {
        // Create a PdfDocument instance
        PdfDocument pdf = new PdfDocument();

        // Load the PDF file
        pdf.loadFromFile("sample.pdf");

        // Loop through each page
        for (int i = 0; i < pdf.getPages().getCount(); i++) {
            // Convert page to image with DPI settings
            BufferedImage image = pdf.saveAsImage(i, PdfImageType.Bitmap, 500, 500);

            // Save as PNG file
            File file = new File(String.format("output-%d.png", i));
            ImageIO.write(image, "PNG", file);
        }

        pdf.close();
    }
}

Key points about this code:

PdfImageType.Bitmap specifies the image type for conversion.
The DPI parameters (500, 500) control output resolution—higher values produce sharper images but larger file sizes.
ImageIO.write() handles saving the buffered image in your chosen format.

Converting Specific Pages

Sometimes you only need to convert selected pages rather than the entire document. The saveAsImage() method accepts a zero-based page index, making this straightforward:

// Convert only the third page (index 2)
BufferedImage image = pdf.saveAsImage(2, PdfImageType.Bitmap, 500, 500);
ImageIO.write(image, "PNG", new File("page-3.png"));

This approach is efficient when you know exactly which pages you need.

Converting to JPEG Format

While PNG is great for preserving quality and supporting transparency, JPEG is often preferred for smaller file sizes. Converting to JPEG requires an extra step to handle color space correctly:

import com.spire.pdf.PdfDocument;
import com.spire.pdf.graphics.PdfImageType;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class ConvertPdfToJpeg {
    public static void main(String[] args) throws IOException {
        PdfDocument pdf = new PdfDocument();
        pdf.loadFromFile("sample.pdf");

        for (int i = 0; i < pdf.getPages().getCount(); i++) {
            // Get the image as a buffered image
            BufferedImage image = pdf.saveAsImage(i, PdfImageType.Bitmap, 300, 300);

            // Re-create as RGB type for proper JPEG encoding
            BufferedImage rgbImage = new BufferedImage(
                image.getWidth(), 
                image.getHeight(), 
                BufferedImage.TYPE_INT_RGB
            );
            rgbImage.getGraphics().drawImage(image, 0, 0, null);

            // Save as JPEG
            File file = new File(String.format("output-%d.jpg", i));
            ImageIO.write(rgbImage, "JPEG", file);
        }

        pdf.close();
    }
}

The color space conversion is necessary because JPEG doesn't support the alpha channel that PNG does.

Creating Transparent Background Images

For use cases like watermarking or overlaying on colored backgrounds, transparent PNG output is valuable. The library supports this through conversion options:

PdfDocument pdf = new PdfDocument();
pdf.loadFromFile("sample.pdf");

// Set background transparency
pdf.getConvertOptions().setPdfToImageOptions(0);

BufferedImage image = pdf.saveAsImage(0);
ImageIO.write(image, "PNG", new File("transparent-output.png"));

Setting the option to 0 makes the background fully transparent.

Batch Processing Multiple PDFs

In production environments, you'll often need to process multiple files at once. Here's a practical batch conversion approach:

import com.spire.pdf.*;
import com.spire.pdf.graphics.PdfImageType;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class BatchPDFtoImage {
    public static void main(String[] args) throws IOException {
        File folder = new File("input-pdfs");
        File[] pdfFiles = folder.listFiles((dir, name) -> name.toLowerCase().endsWith(".pdf"));

        if (pdfFiles == null) return;

        for (File pdfFile : pdfFiles) {
            PdfDocument pdf = new PdfDocument();
            pdf.loadFromFile(pdfFile.getAbsolutePath());

            for (int i = 0; i < pdf.getPages().getCount(); i++) {
                BufferedImage image = pdf.saveAsImage(i, PdfImageType.Bitmap, 300, 300);
                String outputName = pdfFile.getName().replace(".pdf", "") + "_page_" + (i + 1) + ".png";
                ImageIO.write(image, "PNG", new File("output/" + outputName));
            }

            System.out.println("Processed: " + pdfFile.getName());
            pdf.close();
        }
    }
}

This script processes all PDFs in a directory and creates organized output files with clear naming.

Important Implementation Considerations

DPI Settings: The DPI parameters significantly impact both image quality and file size. For web thumbnails, 150-200 DPI is usually sufficient. For print-quality output, consider 300 DPI or higher.

Memory Management: Converting large PDFs with many pages can consume substantial memory. Consider processing pages individually and releasing resources promptly.

Output Watermark Behavior: It is important to be aware of the library's default behavior. If you run this code without applying a valid license file, the generated image output will automatically contain a diagnostic watermark. For development or evaluation purposes, this is the expected result. For integration into a production deployment where watermarks are not desired, you must follow the vendor's documented procedure for applying a license.

Alternative Approaches

While this article demonstrates integration with Spire.PDF for Java, several other libraries offer similar functionality:

Apache PDFBox: Open-source, good for basic conversions.
iText: Offers both open-source (AGPL) and commercial licensing options.
JPedal: Specialized in high-fidelity rendering.

Each has different strengths in terms of rendering accuracy, performance, and licensing terms.

Wrapping Up

Converting PDF to images in Java is a solvable problem with the right tooling. The library demonstrated here handles the complexity of PDF rendering while giving you control over output format, resolution, and page selection. Whether you need simple PNG thumbnails or transparent-background images for design work, the API provides consistent methods to achieve your goals.

For more advanced scenarios—like converting to TIFF for archival purposes or SVG for vector output—the library offers additional methods such as saveToTiff() and saveToFile() with FileFormat.SVG options.

Have you implemented PDF-to-image conversion in your projects? What challenges did you encounter with different libraries? I'd be interested in hearing about your experiences.

HTML to PDF in Java: A Practical Guide to Document Conversion

Pilalo — Thu, 02 Apr 2026 02:15:53 +0000

Converting HTML to PDF is a common requirement in enterprise applications. Whether it's generating invoices, archiving reports, or creating downloadable documents, the ability to reliably transform web content into portable document format is essential. This article explores practical approaches to HTML-to-PDF conversion in Java, focusing on implementation patterns, common pitfalls, and production-ready considerations.

1. Understanding the Challenge

Before diving into code, it's worth understanding why HTML to PDF conversion isn't as straightforward as it might seem.

Challenge	Description
Layout Engines	Browsers and PDF renderers interpret CSS differently
Font Availability	Server environments often lack fonts used in HTML
Resource Management	Images, stylesheets, and external assets need proper handling
Performance	Large-scale conversion requires careful resource planning

2. Implementation Approaches

Java developers have several options when implementing HTML to PDF conversion. Here's a comparison of the main approaches:

2.1 Document Model Approach

Libraries like Spire.Doc take an indirect approach: they parse HTML into an internal document model (similar to Word documents), then export to PDF. This works well when you need consistency across multiple document formats.

Basic HTML File Conversion:

import com.spire.doc.*;

public class HtmlToPdfDemo {
    public static void main(String[] args) {
        Document doc = new Document();
        doc.loadFromFile("report.html", FileFormat.Html);
        doc.saveToFile("report.pdf", FileFormat.PDF);
        doc.dispose();
    }
}

Converting from HTML String:

public class InlineHtmlConverter {
    public static void main(String[] args) {
        Document doc = new Document();
        Section section = doc.addSection();

        String html = """
            <!DOCTYPE html>
            <html>
            <head><title>Invoice</title></head>
            <body>
                <h1>Order Summary</h1>
                <p>Thank you for your purchase.</p>
                <ul>
                    <li>Item: Laptop</li>
                    <li>Quantity: 1</li>
                    <li>Price: $1,299.99</li>
                </ul>
            </body>
            </html>
            """;

        section.addParagraph().appendHTML(html);
        doc.saveToFile("invoice.pdf", FileFormat.PDF);
        doc.dispose();
    }
}

2.2 Native PDF Generation

Libraries like iText and Apache PDFBox generate PDF directly without an intermediate document model. This approach offers finer control over PDF-specific features.

2.3 Headless Browser Rendering

Tools like Puppeteer (Node.js) or Selenium can be controlled from Java to render HTML in an actual browser engine, then export to PDF. This provides the highest fidelity but introduces external dependencies.

3. Advanced Configuration

Real-world applications often require more than basic conversion. Here are practical configuration patterns.

3.1 Handling External Resources

HTML documents frequently reference external resources. Proper resource loading ensures images and stylesheets appear correctly.

import com.spire.doc.*;
import com.spire.doc.documents.*;

public class ResourceAwareConverter {
    public static void main(String[] args) {
        Document doc = new Document();

        // Set base URL for resolving relative paths
        doc.setBaseUrl("https://yourdomain.com/assets/");

        // Configure HTML load options
        doc.loadFromFile(
            "complex.html", 
            FileFormat.Html, 
            XHTMLValidationType.None  // Looser validation for real-world HTML
        );

        doc.saveToFile("output.pdf", FileFormat.PDF);
        doc.dispose();
    }
}

3.2 Font Management

Font-related issues are among the most common problems in PDF generation.

public class FontManagementExample {
    public static void main(String[] args) {
        Document doc = new Document();

        // Specify custom font directories
        String[] fontPaths = {
            "/usr/share/fonts",           // Linux
            "C:\\Windows\\Fonts",         // Windows
            "/System/Library/Fonts"       // macOS
        };
        doc.setCustomFontsFolders(fontPaths);

        // Font can also be specified in HTML
        String html = """
            <div style="font-family: 'Arial', 'Helvetica', sans-serif;">
                This text will use the first available font.
            </div>
            """;

        doc.getSections().get(0).addParagraph().appendHTML(html);
        doc.saveToFile("output.pdf", FileFormat.PDF);
        doc.dispose();
    }
}

4. Performance Optimization

When processing documents at scale, consider these optimization strategies.

4.1 Resource Management

Always dispose Document objects to prevent memory leaks:

public void convertWithResourceCleanup(String inputPath, String outputPath) {
    Document doc = null;
    try {
        doc = new Document();
        doc.loadFromFile(inputPath, FileFormat.Html);
        doc.saveToFile(outputPath, FileFormat.PDF);
    } finally {
        if (doc != null) {
            doc.dispose();
        }
    }
}

4.2 Batch Processing with Concurrency

For processing multiple documents, use a thread pool with controlled concurrency:

import java.util.concurrent.*;

public class BatchConverter {
    private final ExecutorService executor = Executors.newFixedThreadPool(4);

    public void convertAll(List<String> files, String outputDir) {
        List<Future<?>> futures = new ArrayList<>();

        for (String file : files) {
            futures.add(executor.submit(() -> {
                try (Document doc = new Document()) {
                    doc.loadFromFile(file, FileFormat.Html);
                    String outputPath = outputDir + "/" + 
                        new File(file).getName().replace(".html", ".pdf");
                    doc.saveToFile(outputPath, FileFormat.PDF);
                }
            }));
        }

        // Wait for completion
        for (Future<?> future : futures) {
            try {
                future.get();
            } catch (Exception e) {
                // Log and handle failures
            }
        }

        executor.shutdown();
    }
}

5. Library Comparison

Here's how different libraries compare for HTML to PDF conversion:

Library	Approach	Strengths	Considerations
Spire.Doc	Document model	Simple API, consistent with Word conversion	Free version has page limits (10 pages)
iText 7 + pdfHTML	Native PDF	Excellent CSS support, industry standard	AGPL license for open source use
OpenHTMLtoPDF	Rendering engine	Lightweight, open source	CSS 2.1 level support
Headless Chrome	Browser-based	Highest fidelity, modern CSS support	External process, additional infrastructure

6. Production Considerations

6.1 Error Handling

Implement robust error handling to manage conversion failures gracefully:

public ConversionResult safeConvert(String htmlPath, String pdfPath) {
    try {
        Document doc = new Document();
        doc.loadFromFile(htmlPath, FileFormat.Html);
        doc.saveToFile(pdfPath, FileFormat.PDF);
        doc.dispose();
        return ConversionResult.success(pdfPath);
    } catch (Exception e) {
        logger.error("Conversion failed for {}: {}", htmlPath, e.getMessage());
        return ConversionResult.failure(e.getMessage());
    }
}

6.2 Performance Benchmarks

Typical performance indicators for reference:

Document Size	Page Count	Conversion Time	Memory Usage
Simple HTML	1-2 pages	1-2 seconds	50-80 MB
Complex layout	5-10 pages	3-5 seconds	120-180 MB
Large document	50+ pages	10-15 seconds	300-500 MB

Note: Actual performance varies by content complexity and hardware

6.3 Free Version Limitations

If using a free version of any commercial library, be aware of limitations:

Page restrictions (typically 10 pages)
Watermarks or evaluation notices
Reduced performance or concurrent processing limits

For production deployments, evaluate whether these constraints impact your use case.

7. When to Choose Which Approach

Scenario	Recommended Approach
Simple HTML, internal use	Document library with free version
Complex CSS, pixel-perfect required	Headless browser solution
High-volume batch processing	Native PDF library with optimization
Existing Word/Office workflow	Document model approach for consistency

8. Conclusion

HTML to PDF conversion in Java offers multiple viable approaches, each with distinct trade-offs. The document model approach provides a balanced solution: simple API, consistent handling across formats, and no external process dependencies.

Key takeaways for implementation:

Test with real content: HTML structure varies widely; validate with actual documents
Plan for fonts: Font availability is the most common failure point
Manage resources: Proper cleanup prevents memory issues at scale
Understand limitations: Free versions have constraints; plan accordingly

Start with simple conversion and progressively add configuration as your requirements evolve. Most importantly, test thoroughly with the actual HTML content your application will process before committing to a specific approach.

Java: Convert Word to TIFF – A Developer's Guide

Pilalo — Tue, 31 Mar 2026 02:37:53 +0000

TIFF (Tagged Image File Format) remains widely used in document management systems, archival solutions, and fax integrations. Its support for lossless compression and multi-page storage makes it suitable for scenarios where document fidelity matters. For Java developers, programmatically converting Word documents to TIFF is a common requirement that requires external libraries, as the standard JDK doesn't include built-in capabilities for parsing Word files or generating TIFF output.

This article explores practical approaches to converting Word documents to TIFF using Java, with code examples and implementation considerations.

Why Convert Word to TIFF?

Understanding the use cases helps clarify requirements:

Document Archiving: TIFF supports lossless compression, making it suitable for long-term storage where document integrity is critical
Fax Integration: Many fax servers and gateways accept TIFF as their native input format
Interoperability: TIFF files can be viewed across platforms without specialized office software
Legal and Compliance Requirements: Some industries mandate TIFF for document preservation due to its non-editable nature

Implementation Approaches

Converting Word to TIFF involves two main technical challenges: parsing Word document structure and rendering content as TIFF images. Java's standard library handles neither, so developers typically choose from several third-party options.

Available Libraries

Several libraries can accomplish this task, each with different trade-offs:

Library	License	Approach
Apache POI + ImageIO	Open Source	Parse with POI, render to images, combine with ImageIO
docx4j + PDFBox	Open Source	Convert Word to PDF first, then PDF to TIFF
Commercial SDKs	Commercial	All-in-one solutions with direct Word-to-TIFF support

The choice depends on project budget, required features, and team expertise.

Basic Implementation Example

For this guide, we'll use a library that provides direct Word-to-TIFF conversion. The following pattern applies to most commercial SDKs with similar APIs:

import com.spire.doc.Document;

public class WordToTiffConverter {
    public static void main(String[] args) {
        // Load the Word document
        Document document = new Document();
        document.loadFromFile("document.docx");

        // Export as multi-page TIFF
        document.saveToTiff("output.tiff");
    }
}

Step-by-Step Explanation

Create a document object: This represents the Word file in memory
Load the source file: The library parses and prepares the document
Export to TIFF: The rendering engine converts each page and combines them into a single multi-page TIFF

Maven Setup

If using a library with Maven support, your pom.xml might include:

<repositories>
    <repository>
        <id>vendor-repo</id>
        <url>https://repository-url</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>com.vendor</groupId>
        <artifactId>word-converter</artifactId>
        <version>1.0</version>
    </dependency>
</dependencies>

Specific repository URLs and dependency coordinates vary by library.

Alternative: PDF as an Intermediate Format

Some developers prefer a multi-step approach that uses open-source libraries throughout:

Step 1: Word to PDF

// Using Apache POI + iText or other PDF generation libraries
// This is complex and requires significant code for layout fidelity

Step 2: PDF to TIFF

// Using Apache PDFBox
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;

PDDocument pdf = PDDocument.load(new File("document.pdf"));
PDFRenderer renderer = new PDFRenderer(pdf);

// Render each page and combine into multi-page TIFF
for (int page = 0; page < pdf.getNumberOfPages(); page++) {
    BufferedImage image = renderer.renderImageWithDPI(page, 300);
    // Write to TIFF using ImageIO
}

This approach offers more control and uses only open-source components, but requires more development effort and careful handling of layout fidelity during the Word-to-PDF conversion.

Performance Considerations

Memory Usage

Word documents, especially those with images and complex formatting, consume significant memory when loaded. For batch processing:

java -Xmx1024m -jar application.jar

Batch Processing Example

import java.io.File;

public class BatchConverter {
    public static void main(String[] args) {
        File inputDir = new File("/path/to/word/files");
        File outputDir = new File("/path/to/tiff/output");

        if (!outputDir.exists()) {
            outputDir.mkdirs();
        }

        File[] wordFiles = inputDir.listFiles((dir, name) -> 
            name.endsWith(".docx") || name.endsWith(".doc"));

        for (File wordFile : wordFiles) {
            String outputName = wordFile.getName()
                .replaceAll("\\.docx?$", ".tiff");
            File outputFile = new File(outputDir, outputName);

            try {
                // Library-specific conversion call
                convertWordToTiff(wordFile, outputFile);
                System.out.println("Converted: " + wordFile.getName());
            } catch (Exception e) {
                System.err.println("Error: " + wordFile.getName());
                e.printStackTrace();
            }
        }
    }
}

Common Technical Challenges

Font Handling

When fonts aren't available on the server, rendering may fall back to substitutes. Solutions include:

Installing required fonts on the system
Embedding fonts in documents when possible
Testing with representative documents before deployment

Layout Fidelity

Complex elements like tables, text boxes, and floating objects can be challenging to render accurately. Consider:

Testing with a variety of document structures
Using higher DPI settings for better accuracy
Visually verifying output quality

TIFF Compression

TIFF supports multiple compression algorithms that affect file size:

LZW: Good for documents with text and simple graphics
CCITT Group 4: Ideal for black-and-white documents
JPEG: Better for documents with photographs

Most libraries allow specifying compression type through configuration options.

Implementation Decision Factors

When selecting an implementation approach, consider:

Factor	Open-Source Route	Commercial SDK Route
Cost	Free	License fee
Development Time	Weeks to months	Days to weeks
Layout Fidelity	Variable, requires testing	Typically higher
Maintenance	Self-managed	Vendor-supported
Customization	Full control	Limited to API

Summary

Converting Word documents to TIFF in Java is achievable through multiple approaches, each with distinct trade-offs. The choice between building with open-source components or using integrated libraries depends on your project's budget, timeline, and quality requirements.

When implementing such functionality:

Start with clear requirements for output quality and volume
Prototype with your representative document types
Test performance with expected production loads
Plan for error handling and logging

The examples and considerations in this article provide a foundation for evaluating approaches and implementing a solution that fits your specific needs, whether integrating with archival systems, fax services, or document management platforms.

C#: How to Export Excel Data to Text Files

Pilalo — Fri, 13 Mar 2026 02:06:01 +0000

As data migration demands surge due to AI integration and cloud migrations, developers frequently need to C# Excel to TXT for legacy systems or text-only pipelines. Imagine processing thousands of financial spreadsheets into plain text for compliance audits—traditional methods fail under scale. This guide delivers a precise solution using Spire.XLS for .NET to convert Excel to a text file efficiently.

The Need for Excel to TXT Conversion

Converting Excel (.xlsx/.xls) to TXT is essential for:

Data Interoperability: Legacy apps, scripts, or databases requiring delimited text.
Analytics Prep: Feeding into tools like Python's pandas or R without format dependencies.
Batch Automation: ERP migration projects requiring bulk TXT exports have seen significant growth.

Key Challenges:

Retaining formulas, merged cells, and Unicode.
Scalability for files >500MB amid .NET 8's memory optimizations.
Avoiding Excel Interop's server instability.

Libraries like Spire.XLS for .NET resolve these without Excel installation.

Spire.XLS for .NET: Top Choice for C# Excel to TXT

Spire.XLS for .NET provides native TXT export, supporting Excel 97-, macros, and streaming. Compare with peers:

Feature/Library	Spire.XLS	EPPlus	NPOI	ClosedXML
TXT Export	Native	Custom	None	None
Free Limits	150 rows	10 rows	None	None
Large Files	Stream	Partial	Weak	Fair
.NET 8	Full	Full	Partial	Full
Macros Support	Yes	No	Limited	No

Install via NuGet: dotnet add package Spire.XLS—ideal for production C# Excel to TXT.

Step-by-Step: Convert Excel to Text File in C

Prerequisites

Target .NET 8 console app for optimal performance.

dotnet new console -n ExcelToTxtApp
cd ExcelToTxtApp
dotnet add package Spire.XLS

1. Basic Single-Sheet Conversion

using Spire.Xls;
using System.Text;

class Program
{
    static void Main()
    {
        Workbook workbook = new Workbook();
        workbook.LoadFromFile("input.xlsx");

        Worksheet sheet = workbook.Worksheets[0];
        sheet.SaveToFile("output.txt", " ", Encoding.UTF8);  // Space-delimited

        workbook.Dispose();
        Console.WriteLine("C# Excel to TXT complete.");
    }
}

2. Multi-Sheet and Custom Delimiters

Workbook workbook = new Workbook();
workbook.LoadFromFile("multi.xlsx");

for (int i = 0; i < workbook.Worksheets.Count; i++)
{
    Worksheet sheet = workbook.Worksheets[i];
    string fileName = $"Sheet{i + 1}.txt";
    sheet.SaveToFile(fileName, ",", Encoding.UTF8);  // CSV-style
}

workbook.Dispose();

3. Stream Large Files (Memory-Efficient)

using (FileStream fs = new FileStream("large.xlsx", FileMode.Open))
{
    Workbook workbook = new Workbook();
    workbook.LoadFromStream(fs);

    workbook.Worksheets[0].SaveToFile("streamed.txt", "\t", Encoding.UTF8);
    workbook.Dispose();
}

4. Legacy .xls with Macros

Workbook workbook = new Workbook();
workbook.LoadFromFile("macros.xls", ExcelVersion.Version97to2003);

Worksheet sheet = workbook.Worksheets[0];
sheet.Range["A5"].Text = "Updated Value";  // Optional edit
sheet.SaveToFile("macro-txt.txt", " ", Encoding.ASCII);

workbook.Dispose();

Run: dotnet run—outputs clean TXT with preserved structure.

Best Practices and Performance Optimization

Error Handling:

  try
  {
      var workbook = new Workbook();
      workbook.LoadFromFile("file.xlsx");
      // Process...
  }
  catch (Exception ex)
  {
      Console.WriteLine($"Conversion failed: {ex.Message}");
  }
  finally
  {
      workbook?.Dispose();
  }

Tips:
| Category | Best Practice |
|----------------|-----------------------------------|
| Performance| Stream + .NET 8 AOT (2x faster) |
| Encoding | UTF8 default; ASCII for legacy |
| Delimiters | "," or "\t" for parsers |
| Scale | Process sheets independently |
Use Cases:
- Audit logs to TXT for forensics.
- ML datasets from Excel.
- API endpoints exposing TXT downloads.

Spire.XLS handles 1M+ rows in seconds, outperforming Interop by 10x.

Wrap-Up

Converting Excel files to plain text is a common task for data processing. Spire.XLS for .NET provides a simple API to read Excel workbooks and export them as TXT files with minimal C# code. It handles XLS/XLSX formats without requiring Microsoft Office, making it ideal for data migration and system integration.

Action: Integrate Spire.XLS via NuGet and test with your files. Visit e-iceblue.com for pro features.