如何用Java用SAX解析XML？

創建自定義DefaultHandler並重寫startElement、endElement、characters等方法以處理解析事件；2. 使用SAXParserFactory創建SAXParser實例，並通過parse方法將XML文件與自定義處理器關聯進行解析；3. SAX解析基於事件驅動，內存佔用低，適用於大文件，但只能順序讀取且不可修改XML，需手動維護上下文狀態以處理嵌套結構，解析過程從startDocument開始到endDocument結束。

Parsing XML with SAX (Simple API for XML) in Java is a fast and memory-efficient way to process large XML files, as it reads the document sequentially without loading the entire file into memory. SAX uses an event-driven model—callbacks are triggered when the parser encounters elements, attributes, text, etc.

Here's how to parse XML using SAX in Java:

1. Create a Custom DefaultHandler

You need to extend org.xml.sax.helpers.DefaultHandler and override key methods to handle parsing events.

Commonly overridden methods:

• startElement() – Called when an opening tag is encountered.
• endElement() – Called when a closing tag is encountered.
• characters() – Called for text content between tags.
• startDocument() / endDocument() – For document-level events.

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

public class MySAXHandler extends DefaultHandler {

    boolean isFirstName = false;
    boolean isLastName = false;
    boolean isEmail = false;

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        switch (qName.toLowerCase()) {
            case "firstname":
                isFirstName = true;
                break;
            case "lastname":
                isLastName = true;
                break;
            case "email":
                isEmail = true;
                break;
        }
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        String value = new String(ch, start, length).trim();
        if (value.isEmpty()) return;

        if (isFirstName) {
            System.out.println("First Name: " value);
            isFirstName = false;
        } else if (isLastName) {
            System.out.println("Last Name: " value);
            isLastName = false;
        } else if (isEmail) {
            System.out.println("Email: " value);
            isEmail = false;
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        // Optional cleanup if needed
    }

    @Override
    public void startDocument() throws SAXException {
        System.out.println("Parsing started...");
    }

    @Override
    public void endDocument() throws SAXException {
        System.out.println("Parsing ended.");
    }
}

2. Use SAXParserFactory and SAXParser to Parse the XML

Now, use the handler with a SAXParser to process an XML file or input stream.

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

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

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

            // Create your handler
            MySAXHandler handler = new MySAXHandler();

            // Parse the XML file
            File inputFile = new File("input.xml");
            saxParser.parse(inputFile, handler);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. Sample XML (input.xml)

 <?xml version="1.0" encoding="UTF-8"?>
<employees>
    <employee id="1">
        <firstname>John</firstname>
        <lastname>Doe</lastname>
        <email>john.doe@example.com</email>
    </employee>
    <employee id="2">
        <firstname>Jane</firstname>
        <lastname>Smith</lastname>
        <email>jane.smith@example.com</email>
    </employee>
</employees>

Output:

 Parsing started...
First Name: John
Last Name: Doe
Email: john.doe@example.com
First Name: Jane
Last Name: Smith
Email: jane.smith@example.com
Parsing ended.

Key Points to Remember

• Memory Efficient : SAX is ideal for large XML files because it doesn't keep the whole document in memory.
• Read-Only : SAX is for reading only; you can't modify the XML.
• Event Order Matters : You must track context manually (eg, using flags or a stack) if you need hierarchical data.
• No Random Access : You can't jump to a specific element—you process in sequence.

Handling Nested Elements or Complex Structures

For complex XML, maintain a stack or current object state in the handler. For example, create an Employee object when startElement("employee") is called, populate it during parsing, and save it when endElement("employee") is reached.

That's the core of SAX parsing in Java. It's straightforward once you understand the event-based flow. Basically just implement the handler and let the parser do the rest.

以上是如何用Java用SAX解析XML？的詳細內容。更多資訊請關注PHP中文網其他相關文章！