解析XML的4種方式及優缺點比較

dom, sax是解析xml的底層接口
而jdom和dom4j則是基於底層api的更高級封裝   
dom是通用的，而jdom和dom4j則是面向java語言的

 

(方法一). DOM解析說明：為 XML 文檔的已解析版本定義了一組接口。解析器讀入整個文檔，然后構建一個駐留內存的樹結
構， 然后代碼就可以使用 DOM 接口來操作這個樹結構。優點：整個文檔樹在內存中，便於操作；支持刪除、修改、重新排列等多種功能；缺點：將整個文檔調入內 存（包括無用的節點），浪費時間和空間；使用場合：一旦解析了文檔還需多次訪問這些數據；硬件資源充足（內存、CPU）.

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class DomDemo {

    private final static String xmlPath = "D:\\WHS01.xml";

    /**
     * 遞歸輸出節點
     * 
     * @param element
     */
    public static void parseElement(Element element) {

        System.out.print("<" + element.getTagName());
        NamedNodeMap map = element.getAttributes();
        if (null != map) {
            for (int i = 0; i < map.getLength(); i++) {
                Attr attr = (Attr) map.item(i);
                System.out.print(" " + attr.getName() + "=\"" + attr.getValue()
                        + "\"");
            }
        }
        System.out.print(">");

        NodeList childList = element.getChildNodes();

        for (int i = 0; i < childList.getLength(); i++) {
            Node node = childList.item(i);

            switch (node.getNodeType()) {
            case Node.ELEMENT_NODE:
                parseElement((Element) node);
                break;
            case Node.TEXT_NODE:
                System.out.print(node.getNodeValue());
                break;
            default:
                break;
            }
        }
        System.out.print("</" + element.getTagName() + ">");
    }

    /**
     * 根據指定路徑獲取Document對象
     * 
     * @param xmlPath
     * @return
     * @throws Exception
     */
    public static Document getDocument(String xmlPath) throws Exception {

        Document document = null;
        if (null == xmlPath || "".equals(xmlPath.trim()))
            return document;

        File file = new File(xmlPath);
        if (file.canRead() && file.exists()) {
            DocumentBuilderFactory factory = DocumentBuilderFactory
                    .newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            document = builder.parse(file);
        }
        return document;
    }

    public static void main(String[] args) {
        Document document = null;
        try {
            document = getDocument(xmlPath);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 傳入根節點
        parseElement(document.getDocumentElement());
    }
}

(方法二)SAX解析說明：為解決DOM的問題，出現了SAX。SAX ，事件驅動。當解析器發現元素開始、元素結束、文本、文檔的

開 始或結束等時，發送事件，程序員編寫響應這些事件的代碼，保存數據。優點：不用事先調入整個文檔，占用資源少；SAX解析器代碼比DOM解析器代碼小，適 於Applet，下載。缺點：不是持久的；事件過后，若沒保存數據，那么數據就丟了；無狀態性；從事件中只能得到文本，但不知該文本屬於哪個元素；使用場 合：Applet;只需XML文檔的少量內容，很少回頭訪問；機器內存少

<?xml version="1.0" encoding="UTF-8"?>
<BOM Code="LM4029">
    <Child Code="LM4029MC">
        <Quantity>2.000000</Quantity>
    </Child>
    <Child Code="LM4029D">
        <Quantity>1.000000</Quantity>
    </Child>
    <Child Code="LM4029PH">
        <Quantity>1.000000</Quantity>
    </Child>
    <Child Code ="LM4029PS">
        <Quantity>1.000000</Quantity>
    </Child>
    <Child Code="LM4029SB">
        <Quantity>1.000000</Quantity>
    </Child>
</BOM>

import java.util.Stack;

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

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

public class SAXDemo {

    private final static String uri = "D:\\bom.xml";

    public static void main(String[] args) {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        try {
            SAXParser parser = factory.newSAXParser();
            parser.parse(uri, new MyHandler());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Child {
    private String code;
    private double quantity;

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public double getQuantity() {
        return quantity;
    }

    public void setQuantity(double quantity) {
        this.quantity = quantity;
    }

}

class MyHandler extends DefaultHandler {

    Stack<String> stack = null;
    Child child = null;

    @Override
    public void startDocument() throws SAXException {
        System.out.println("start document");
        stack = new Stack<String>();
    }

    @Override
    public void endDocument() throws SAXException {
        System.out.println("end document");
        stack = null;
    }

    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        stack.push(qName);
        if ("Child".equals(qName)) {
            child = new Child();
            child.setCode(attributes.getValue("Code"));
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        stack.pop();
        if ("Child".equals(qName)) {
            System.out.println("Code -> " + child.getCode() + ", Quantity -> "
                    + child.getQuantity());
            child = null;
        }
    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        if ("Quantity".equals(stack.peek())) {
            child.setQuantity(Double.parseDouble(new String(ch, start, length)));
        }
    }
}

(方法三)JDOM解析說明：為減少DOM、SAX的編碼量，出現了JDOM；優點：20-80原則，極大減少了代碼量。使用場合：要實現的功能
簡單，如解析、創建等，但在底層，JDOM還是使用SAX（最常用）,DOM

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;

public class JdomDemo {

    private final static String xmlPath = "D:\\bom.xml";

    public static void readXml() throws JDOMException, IOException {
        SAXBuilder builder = new SAXBuilder();
        Document document = builder.build(new File(xmlPath));

        Element element = document.getRootElement();
        List<Element> childList = element.getChildren("Child");

        for (int i = 0; i < childList.size(); i++) {
            String code = childList.get(i).getAttributeValue("Code");
            double quantity = Double.parseDouble(childList.get(i).getChildText(
                    "Quantity"));
            System.out.println("Code -> " + code + ", Quantity -> " + quantity);
        }
    }
}

(方法四)DOM4J解析說明：DOM4J 是一個非常非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同

時它也是一個開放源代碼的軟件。如今你可以看到越來越多的 Java 軟件都在使用 DOM4J 來讀寫 XML

import java.io.File;
import java.io.IOException;
import java.util.Iterator;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.DOMReader;
import org.dom4j.io.SAXReader;
import org.xml.sax.SAXException;

public class Dom4jDemo {

    private final static String xmlPath = "D:\\bom.xml";

    public static void parseElement() throws DocumentException,
            ParserConfigurationException, SAXException, IOException {
        // 方式一 DOM 
        // DocumentBuilderFactory factory =
        // DocumentBuilderFactory.newInstance();
        // DocumentBuilder builder = factory.newDocumentBuilder();
        // org.w3c.dom.Document domDoc = builder.parse(xmlPath);
        // DOMReader domReader = new DOMReader();
        // Document document = domReader.read(domDoc);

        //方式二 SAX（常用）
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(new File(xmlPath));
        Element rootEl = document.getRootElement();

        for (Iterator iterator = rootEl.elementIterator("Child"); iterator
            .hasNext();) {
            Element e = (Element) iterator.next();
            System.out.print("Code -> " + e.attributeValue("Code"));
            System.out.println(" Quantity -> " + e.elementText("Quantity"));
        }
    }

}

總結:

1.DOM, JDOM在性能上不如SAX, DOM4J, 在小文檔情況下還值得考慮使用 DOM 和 JDOM。

2.DOM 實現廣泛應用於多種編程語言。它還是許多其它與 XML 相關的標准的基礎，因為它正式獲得 W3C 推薦（與基於非標准的 Java 模型相對），所以在某些類型的項目中可能也需要它（如在 javascript 中使用 DOM）。

3.SAX 的高效取決於特定的解析方式，不用事先調入整個文檔，占用資源少。

4.如果不考慮可移植性， 首先考慮使用DOM4J。