XSLT - Integrating XSLT with Java Applications Using Saxon

1. Introduction

XSLT (Extensible Stylesheet Language Transformations) is a language used to transform XML documents into other formats, such as HTML, XML, text, and other structured data. Java is a widely used programming language for developing enterprise applications, web applications, and data-processing systems.

Although XSLT can be executed independently using an XSLT processor, it is often necessary to perform XML transformations directly within Java applications. This integration allows developers to automate XML processing without depending on external command-line tools.

Saxon is a popular XSLT and XQuery processing library that enables Java applications to execute XSLT stylesheets. It supports different XSLT versions, including XSLT 2.0, 3.0, and, depending on the edition and release, newer capabilities.

By integrating Saxon with Java, developers can read XML documents, apply transformation rules, generate output files, and process XML data programmatically.

2. What Is Saxon?

Saxon is an XSLT and XQuery processor developed by Saxonica. It provides an implementation of XSLT standards and allows developers to perform XML transformations efficiently.

Java applications can use the Saxon library to process XML documents and convert them into different output formats.

For example, consider an organization that stores employee information in XML format. The organization may want to convert this information into an HTML report for displaying employee details on a website.

Instead of manually processing the XML document using Java code, developers can create an XSLT stylesheet and use Saxon to perform the transformation.

The main features of Saxon include:

• Supports XSLT transformations.

• Supports XPath expressions for selecting and processing XML elements.

• Provides integration with Java applications.

• Supports XML document processing and validation workflows.

• Allows developers to generate HTML, XML, and text output.

• Provides advanced transformation capabilities through different Saxon editions.

3. Why Integrate XSLT with Java Applications?

Integrating XSLT with Java makes XML processing more flexible and automated.

Java applications frequently exchange information using XML, particularly in enterprise systems, web services, and data integration platforms.

The integration provides several advantages:

1. Automated XML Transformation

Java applications can automatically transform XML documents without requiring users to execute separate transformation commands.

2. Reusability

Developers can create reusable XSLT stylesheets and apply them to multiple XML documents.

3. Reduced Programming Complexity

Instead of writing lengthy Java code to navigate XML elements and generate output, developers can define transformation rules in XSLT.

4. Flexible Output Generation

The same XML document can be transformed into HTML, XML, or plain text depending on application requirements.

5. Enterprise Application Integration

Saxon allows Java-based enterprise applications to process XML data received from external systems.

4. Requirements for Integrating Saxon with Java

Before performing an XSLT transformation using Saxon, developers need the following components:

Saxon can be added to a Java project using Maven or Gradle dependency management, or by including the appropriate Saxon JAR file.

For example, the following Maven dependency adds Saxon-HE to a Java project:

<dependency>
    <groupId>net.sf.saxon</groupId>
    <artifactId>Saxon-HE</artifactId>
    <version>12.9</version>
</dependency>

The version shown is an example; developers should select a compatible release for their project.

5. How XSLT Transformation Works in Java Using Saxon

When Saxon is integrated with Java, the transformation process generally follows these steps:

1. The Java application loads the Saxon processing library.

2. The application creates a Saxon processor.

3. The XML source document is identified.

4. The XSLT stylesheet is loaded.

5. Saxon compiles the stylesheet into an executable form.

6. The Java application executes the transformation.

7. The transformed output is generated and saved or returned to the application.

The following diagram illustrates the process:

6. Practical Example of Integrating XSLT with Java Using Saxon

Consider an organization that maintains employee information in an XML document. The organization wants to convert the employee details into an HTML table.

This example demonstrates how Java and Saxon work together to perform the transformation.

Step 1: Create an XML Document

Create a file named employees.xml.

<?xml version="1.0" encoding="UTF-8"?>

<employees>
    <employee>
        <id>101</id>
        <name>Rahul</name>
        <department>IT</department>
        <salary>45000</salary>
    </employee>

    <employee>
        <id>102</id>
        <name>Ananya</name>
        <department>HR</department>
        <salary>40000</salary>
    </employee>

    <employee>
        <id>103</id>
        <name>Arun</name>
        <department>Finance</department>
        <salary>50000</salary>
    </employee>
</employees>

The XML document contains three employee records. Each employee has an ID, name, department, and salary.

Step 2: Create an XSLT Stylesheet

Create a file named employees.xsl.

<?xml version="1.0" encoding="UTF-8"?>

<xsl:stylesheet
    version="2.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

    <xsl:output method="html" indent="yes"/>

    <xsl:template match="/">

        <html>
            <head>
                <title>Employee Details</title>
            </head>

            <body>

                <h2>Employee Information</h2>

                <table border="1">

                    <tr>
                        <th>ID</th>
                        <th>Name</th>
                        <th>Department</th>
                        <th>Salary</th>
                    </tr>

                    <xsl:for-each select="employees/employee">

                        <tr>
                            <td><xsl:value-of select="id"/></td>
                            <td><xsl:value-of select="name"/></td>
                            <td><xsl:value-of select="department"/></td>
                            <td><xsl:value-of select="salary"/></td>
                        </tr>

                    </xsl:for-each>

                </table>

            </body>
        </html>

    </xsl:template>

</xsl:stylesheet>

This stylesheet defines how employee information should be displayed in an HTML table.

The xsl:template element defines the transformation template, while xsl:for-each processes each employee record.

Step 3: Create a Java Program

Create a Java file named XSLTExample.java.

import net.sf.saxon.s9api.*;

import java.io.File;
import java.io.FileOutputStream;

public class XSLTExample {

    public static void main(String[] args) {

        try {

            // Create Saxon processor
            Processor processor = new Processor(false);

            // Create XSLT compiler
            XsltCompiler compiler =
                processor.newXsltCompiler();

            // Load XSLT stylesheet
            XsltExecutable executable =
                compiler.compile(
                    new StreamSource(
                        new File("employees.xsl")
                    )
                );

            // Create transformer
            XsltTransformer transformer =
                executable.load();

            // Set XML source document
            transformer.setSource(
                new StreamSource(
                    new File("employees.xml")
                )
            );

            // Set output destination
            Serializer serializer =
                processor.newSerializer(
                    new File("employees.html")
                );

            transformer.setDestination(serializer);

            // Execute transformation
            transformer.transform();

            System.out.println(
                "Transformation completed successfully!"
            );

        } catch (Exception e) {

            e.printStackTrace();

        }

    }
}

The program uses Saxon's Java API to load the stylesheet, read the XML document, perform the transformation, and generate an HTML file.

In this example, StreamSource must also be imported from javax.xml.transform. Add the following import to the Java program:

import javax.xml.transform.stream.StreamSource;

Step 4: Execute the Java Program

After configuring the Java project and adding the Saxon dependency, execute the XSLTExample program.

The program reads:

• employees.xml as the input document.

• employees.xsl as the transformation stylesheet.

It generates a new file named employees.html.

Step 5: View the Output

The generated HTML file displays the employee information in a table.

Expected output:

The table above represents the information displayed by the generated HTML file.

7. Important Java Classes Used in Saxon

Saxon provides several Java classes that help developers perform XML transformations.

These classes work together to perform the complete transformation process.

8. Handling Errors During Transformation

Errors may occur while integrating XSLT with Java. These errors can be caused by missing XML files, incorrect stylesheet syntax, invalid XML structures, or incompatible XSLT features.

Common errors include:

1. File Not Found Error

This occurs when the Java application cannot locate the XML document or XSLT stylesheet.

Solution: Verify the file paths and ensure that the required files are available in the correct project directory.

2. Stylesheet Compilation Error

This occurs when the XSLT stylesheet contains invalid syntax or unsupported instructions.

Solution: Check the stylesheet for syntax errors and verify compatibility with the selected Saxon edition.

3. XML Parsing Error

This occurs when the source XML document is incorrectly structured.

Solution: Validate the XML document and ensure that all elements are properly opened and closed.

4. Transformation Error

This occurs when the transformation process encounters an execution problem.

Solution: Use exception handling and examine the error messages to identify the source of the problem.

In production applications, developers should also configure secure XML processing and restrict access to untrusted external resources.

9. Real-World Applications

Integrating XSLT with Java using Saxon is useful in several industries and application environments.

1. Banking Applications

Banks use XML documents to exchange customer information, transaction records, and financial reports. Java applications can use Saxon to convert these documents into readable reports.

2. E-Commerce Applications

Online shopping platforms can transform product information stored in XML into HTML pages for displaying product details.

3. Healthcare Systems

Healthcare applications can process XML-based patient records and generate structured reports for medical administration systems.

4. Enterprise Resource Planning (ERP)

ERP systems exchange information between different departments. XSLT and Java can help transform data between different XML formats.

5. Government Applications

Government departments may use XML to exchange administrative records and generate standardized documents through automated transformation processes.

10. Advantages and Limitations

Advantages

• Simplifies XML processing in Java applications.

• Supports reusable transformation stylesheets.

• Reduces the need for extensive XML-processing code.

• Supports multiple output formats.

• Helps automate enterprise data-processing workflows.

• Provides support for advanced XSLT functionality, depending on the Saxon edition.

Limitations

• Requires knowledge of both Java and XSLT.

• Additional libraries must be configured in the Java project.

• Complex transformations may require more processing resources.

• Some advanced features require commercial Saxon editions.

• Incorrect configuration can create XML security vulnerabilities.

11. Conclusion

Integrating XSLT with Java applications using Saxon provides an effective method for processing and transforming XML documents programmatically. Saxon acts as the transformation engine, while Java controls the execution process and manages the input and output files.

By using classes such as Processor, XsltCompiler, XsltExecutable, and XsltTransformer, developers can integrate XML transformation capabilities into Java applications without writing extensive XML-processing logic.

This approach is particularly useful in enterprise applications, banking systems, healthcare platforms, e-commerce websites, and other environments where XML data must be processed and converted into different formats.