解析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。