Convert XHTML to PDF in Java

In modern software development, there are often requirements to convert XHTML (Extensible Hypertext Markup Language) documents into PDF (Portable Document Format) files. Java, being a popular and versatile programming language, provides several libraries and techniques to achieve this conversion. This blog post will guide you through the process of converting XHTML to PDF using Java, covering core concepts, typical usage scenarios, common pitfalls, and best practices.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Common Libraries for Conversion
  4. Code Examples
  5. Common Pitfalls
  6. Best Practices
  7. Conclusion
  8. FAQ
  9. References

Core Concepts#

XHTML#

XHTML is an XML-based markup language that follows stricter syntax rules compared to HTML. It is designed to be more modular, extensible, and compatible with XML parsers. XHTML documents are well-formed XML documents, which means they must have a root element, proper nesting of tags, and all tags must be closed.

PDF#

PDF is a file format developed by Adobe Systems. It is widely used for presenting and exchanging documents in a format that preserves the layout, fonts, graphics, and other visual elements across different platforms and devices. PDF files are self-contained and can include text, images, vector graphics, and interactive elements.

Conversion Process#

The process of converting XHTML to PDF involves parsing the XHTML document, interpreting its structure and styling information, and then rendering it into a PDF file. This typically requires a library that can handle both XHTML parsing and PDF generation.

Typical Usage Scenarios#

Report Generation#

Many applications need to generate reports in a printable format. By creating the report content in XHTML, developers can easily convert it to PDF for distribution. For example, an accounting application might generate financial reports in XHTML and then convert them to PDF for clients.

Archiving#

XHTML pages can be archived as PDF files for long-term storage. This ensures that the content remains accessible and retains its formatting over time. For instance, a news website might archive its articles in PDF format for historical reference.

E - Book Creation#

XHTML is a common format for creating e - book content. Converting XHTML e - book chapters to PDF allows for easy distribution and reading on various devices, especially those that support PDF readers.

Common Libraries for Conversion#

Flying Saucer#

Flying Saucer is a Java library that can render XHTML and CSS to PDF. It uses the open-source XML parser Xerces and the PDF library iText. Flying Saucer is known for its good support of CSS and HTML standards.

Apache FOP#

Apache FOP (Formatting Objects Processor) is another popular library for converting XML-based documents, including XHTML, to PDF. It uses the XSL-FO (Extensible Stylesheet Language Formatting Objects) standard to define the layout of the output document.

iText#

iText is a powerful PDF library for Java. While it doesn't directly support XHTML conversion, it can be combined with other libraries like Flying Saucer or used with a custom XHTML parser to convert XHTML to PDF.

Code Examples#

Using Flying Saucer#

import org.xhtmlrenderer.pdf.ITextRenderer;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
 
public class XHTMLToPDFWithFlyingSaucer {
    public static void main(String[] args) {
        try {
            // Path to the input XHTML file
            String inputFile = "input.xhtml";
            // Path to the output PDF file
            String outputFile = "output.pdf";
 
            // Create an OutputStream for the PDF file
            OutputStream os = new FileOutputStream(new File(outputFile));
 
            // Create an ITextRenderer instance
            ITextRenderer renderer = new ITextRenderer();
 
            // Set the base URL for resolving relative paths in the XHTML file
            renderer.setDocument(new File(inputFile));
 
            // Layout the document
            renderer.layout();
 
            // Write the PDF content to the output stream
            renderer.createPDF(os);
 
            // Close the output stream
            os.close();
 
            System.out.println("XHTML converted to PDF successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Using Apache FOP#

import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.apps.Fop;
import org.apache.fop.apps.FopFactory;
import org.apache.fop.apps.MimeConstants;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.stream.StreamSource;
import java.io.*;
 
public class XHTMLToPDFWithFOP {
    public static void main(String[] args) {
        try {
            // Create a FopFactory instance
            FopFactory fopFactory = FopFactory.newInstance(new File(".").toURI());
 
            // Create a FOUserAgent instance
            FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
 
            // Create a new Fop instance
            OutputStream out = new FileOutputStream(new File("output.pdf"));
            Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, out);
 
            // Parse the XHTML file
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.parse(new InputSource(new FileInputStream("input.xhtml")));
 
            // Create a TransformerFactory instance
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer(new StreamSource(new File("xhtml2fo.xsl")));
 
            // Set the output properties
            transformer.setOutputProperty(OutputKeys.METHOD, "xml");
            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
 
            // Transform the XHTML to FO and then to PDF
            DOMSource source = new DOMSource(doc);
            SAXResult result = new SAXResult(fop.getDefaultHandler());
            transformer.transform(source, result);
 
            // Close the output stream
            out.close();
 
            System.out.println("XHTML converted to PDF successfully.");
        } catch (ParserConfigurationException | SAXException | IOException | TransformerException e) {
            e.printStackTrace();
        }
    }
}

Common Pitfalls#

CSS Compatibility#

Not all CSS features are supported by the conversion libraries. For example, some advanced CSS3 animations or JavaScript-dependent styles may not be rendered correctly in the PDF output.

Font Issues#

If the fonts used in the XHTML document are not available on the system where the conversion is taking place, the PDF may display incorrect or missing characters.

Image Loading#

Relative image paths in the XHTML document may not be resolved correctly if the base URL is not set properly. This can result in missing images in the PDF.

Best Practices#

Test CSS Carefully#

Before converting a large number of XHTML documents, test the CSS styles with the conversion library to ensure that they are rendered correctly. Use only the CSS features that are supported by the library.

Embed Fonts#

To avoid font issues, embed the fonts used in the XHTML document in the PDF. Most PDF libraries provide options for font embedding.

Set the Base URL#

When using relative paths for images or other resources in the XHTML document, make sure to set the base URL correctly in the conversion code.

Conclusion#

Converting XHTML to PDF in Java is a common task with several libraries available to simplify the process. By understanding the core concepts, typical usage scenarios, common pitfalls, and best practices, developers can effectively convert XHTML documents to PDF files. Whether it's for report generation, archiving, or e - book creation, Java provides the tools needed to achieve high-quality PDF output.

FAQ#

Q1: Which library is better, Flying Saucer or Apache FOP?#

A1: It depends on your specific requirements. Flying Saucer is easier to use and has good support for CSS. Apache FOP is more suitable for complex layout requirements and adheres to the XSL-FO standard.

Q2: Can I convert XHTML with JavaScript to PDF?#

A2: Most conversion libraries do not execute JavaScript during the conversion process. So, JavaScript-dependent functionality in the XHTML document will not be included in the PDF output.

Q3: How can I handle encoding issues during the conversion?#

A3: Make sure to set the correct encoding in the XHTML document and in the conversion code. Most libraries allow you to specify the encoding when reading the input document and writing the output PDF.

References#

2025-10