Using SAX (Simple API for XML) | Generated by AI

Home PDF

To use the org.xml.sax package in Java for parsing XML documents, you can follow a straightforward process using the SAX (Simple API for XML) parsing approach. SAX is an event-driven parser that reads an XML document sequentially and triggers callback methods as it encounters various parts of the document, such as elements or text content. This makes it memory-efficient, especially for large XML files, since it doesn’t load the entire document into memory like DOM does. Below is a step-by-step guide to using org.xml.sax.

Step 1: Set Up the SAX Parser

To start parsing XML with SAX, you need to create a SAXParser instance using the SAXParserFactory class. This factory allows you to configure the parser’s behavior before creating it.

Here’s how to create a SAXParser:

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

public class SAXExample {
    public static void main(String[] args) {
        try {
            // Create a SAXParserFactory instance
            SAXParserFactory factory = SAXParserFactory.newInstance();

            // Optional: Configure the factory (e.g., enable namespace awareness)
            factory.setNamespaceAware(true); // Set to true if your XML uses namespaces

            // Create a SAXParser
            SAXParser parser = factory.newSAXParser();

            // Next steps will go here
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Step 2: Create a Handler for XML Events

SAX parsing relies on a handler to process the XML events it encounters, such as the start of an element, the end of an element, or text content. The primary interface for this is ContentHandler, but for simplicity, you can extend the DefaultHandler class, which provides empty implementations of ContentHandler and other handler interfaces (ErrorHandler, DTDHandler, etc.). You only need to override the methods you care about.

Here’s an example of a custom handler:

import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;

public class MyHandler extends DefaultHandler {
    // Variable to accumulate text content
    private StringBuilder content = new StringBuilder();

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) {
        // Clear content buffer for the new element
        content.setLength(0);
        System.out.println("Start element: " + qName);

        // If the element has attributes, process them
        for (int i = 0; i < attributes.getLength(); i++) {
            System.out.println("Attribute: " + attributes.getQName(i) + " = " + attributes.getValue(i));
        }
    }

    @Override
    public void characters(char[] ch, int start, int length) {
        // Accumulate text content (may be called multiple times per element)
        content.append(ch, start, length);
    }

    @Override
    public void endElement(String uri, String localName, String qName) {
        // Process accumulated text content
        String text = content.toString().trim();
        if (!text.isEmpty()) {
            System.out.println("Content: " + text);
        }
        System.out.println("End element: " + qName);
        content.setLength(0); // Reset for the next element
    }

    @Override
    public void startDocument() {
        System.out.println("Document parsing started");
    }

    @Override
    public void endDocument() {
        System.out.println("Document parsing completed");
    }
}

Step 3: Parse the XML

With the parser and handler ready, you can parse an XML source (e.g., a file, InputStream, or string) by calling the parse method on the SAXParser and passing your handler.

Here’s how to parse an XML file:

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.File;

public class SAXExample {
    public static void main(String[] args) {
        try {
            // Create the parser
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser parser = factory.newSAXParser();

            // Create the handler
            MyHandler handler = new MyHandler();

            // Parse an XML file
            File xmlFile = new File("example.xml");
            parser.parse(xmlFile, handler);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

For an XML string instead of a file, use InputSource:

import org.xml.sax.InputSource;
import java.io.StringReader;

// Inside main method
String xml = "<book><title>XML Parsing</title></book>";
InputSource inputSource = new InputSource(new StringReader(xml));
parser.parse(inputSource, handler);

Step 4: Handle Exceptions

SAX parsing involves several exceptions you should handle:

Wrap your code in a try-catch block:

try {
    SAXParserFactory factory = SAXParserFactory.newInstance();
    SAXParser parser = factory.newSAXParser();
    MyHandler handler = new MyHandler();
    parser.parse(new File("example.xml"), handler);
} catch (ParserConfigurationException e) {
    System.err.println("Parser configuration error: " + e.getMessage());
} catch (SAXException e) {
    System.err.println("SAX error: " + e.getMessage());
} catch (IOException e) {
    System.err.println("IO error: " + e.getMessage());
}

Step 5: Optional Features

Error Handling

DefaultHandler also implements ErrorHandler. Override its methods to handle parsing errors:

public class MyHandler extends DefaultHandler {
    @Override
    public void error(SAXParseException e) {
        System.err.println("Parsing error: " + e.getMessage());
    }

    @Override
    public void fatalError(SAXParseException e) throws SAXException {
        System.err.println("Fatal error: " + e.getMessage());
        throw e; // Stop parsing
    }

    @Override
    public void warning(SAXParseException e) {
        System.out.println("Warning: " + e.getMessage());
    }
    // Other methods as above
}

Namespace Handling

If your XML uses namespaces, set factory.setNamespaceAware(true) and use uri and localName in your handler methods instead of qName to identify elements correctly.

Validation

To validate XML against a DTD or schema, set factory.setValidating(true). You may also need an ErrorHandler to manage validation errors.

Example XML and Output

For an XML file example.xml:

<book id="123">
    <title>XML Parsing</title>
    <author>John Doe</author>
</book>

Running the code above might output:

Document parsing started
Start element: book
Attribute: id = 123
Start element: title
Content: XML Parsing
End element: title
Start element: author
Content: John Doe
End element: author
End element: book
Document parsing completed

Summary

To use org.xml.sax:

  1. Create a SAXParser using SAXParserFactory.
  2. Implement a handler by extending DefaultHandler and overriding methods like startElement, endElement, and characters.
  3. Parse the XML by calling parser.parse() with your handler and XML source.
  4. Handle exceptions (SAXException, IOException, ParserConfigurationException).
  5. Optionally configure namespace awareness, validation, or error handling.

This approach is ideal for efficiently parsing large XML documents when you only need to extract specific data without building an in-memory tree.

Back 2025.03.05 Donate