关于DOM SAX StAX JAXP JDOM DOM4J Xerces Crimson

DOM与SAX

       用于读取和操作 XML 文件的标准是文档对象模型（Document Object Model，DOM）。遗憾的是，DOM 方法涉及读取整个文件并将该文件存储在一个树结构中，而这样可能是低效的、缓慢的，并且很消耗资源。一种替代技术就是 Simple API for XML，或称为 SAX。SAX 允许您在读取文档时处理它，从而不必等待整个文档被存储之后才采取操作。

基于树的处理的优点和缺点（DOM）

        DOM 以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像 SAX 那样是一次性的处理。DOM 使用起来也要简单得多。

另一方面，在内存中构造这样的树涉及大量的开销。大型文件完全占用系统内存容量的情况并不鲜见。此外，创建一棵 DOM 树可能是一个缓慢的过程。

基于事件的处理的优点和缺点(SAX)

       这种处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX 还比它的替代者 DOM 快许多。

另一方面，由于应用程序没有以任何方式存储数据，使用 SAX 来更改数据或在数据流中往后移是不可能的。

如何在 SAX 和 DOM 之间选择

        选择 DOM 还是选择 SAX，这取决于下面几个因素：

应用程序的目的：如果打算对数据作出更改并将它输出为 XML，那么在大多数情况下，DOM 是适当的选择。并不是说使用 SAX 就不能更改数据，但是该过程要复杂得多，因为您必须对数据的一份拷贝而不是对数据本身作出更改。

数据容量： 对于大型文件，SAX 是更好的选择。

数据将如何使用：如果只有数据中的少量部分会被使用，那么使用 SAX 来将该部分数据提取到应用程序中可能更好。 另一方面，如果您知道自己以后会回头引用已处理过的大量信息，那么 SAX 也许不是恰当的选择。

对速度的需要： SAX 实现通常要比 DOM 实现更快。

SAX 和 DOM 不是相互排斥的，记住这点很重要。您可以使用 DOM 来创建 SAX 事件流，也可以使用 SAX 来创建 DOM 树。事实上，用于创建 DOM 树的大多数解析器实际上都使用 SAX 来完成这个任务！

JAXP

        Sun在XML领域总是后知后觉，等到Sun重视XML的时候，XML的API早就满天飞了，尤其是IBM具有非常大的领先优势。不过Sun是规范的制订者，于是参考W3C的标准制订了JAXP规范。

JAXP它只是一个规范，完成了对SAX、DOM的包装，生成了DocumentBuilderFactory、 DocumentBuilder和SAXParserFactory、SAXParser。JAXP的作用就是提出一个统一的接口，让其它的XML API都来遵循JAXP编程。当你严格采用JAXP编程的时候，是遵循W3C的DOM标准的，那么在JAXP底层你实际上可以任意切换不同的DOM实现（也就是解释器），例如Xerces，或者Crimon，再或者其它，切换方法就是配置jaxp.properties。因此JAXP就是一些标准接口而已。具体来说JAXP包括了几个工厂类，这就是JDK1.4里面的javax.xml.parsers 包，用来寻找符合DOM标准的XML API实现类的位置；此外JAXP还包括一整套interface，这就是JDK1.4里面的org.w3c.dom那几个包。工厂类负责加载DOM的实现类。

JAXP应用程序 -> JAXP接口 -> Xerces DOM实现 -> Xerces DOM/SAX 解析器

JAXP应用程序 -> JAXP接口 -> Crimson DOM实现 -> Crimson DOM/SAX 解析器

JAXP应用程序 -> JAXP接口 -> Crimson DOM实现 -> Xerces DOM/SAX 解析器

JDOM与DOM4J

        W3C的DOM标准API难用的让人想撞墙，于是有一帮人开发Java专用的XML API目的是为了便于使用，这就是jdom的由来，开发到一半的时候，另一部分人又分了出来，他们有自己的想法，于是他们就去开发dom4j，形成了今天这样两个API，至于他们之间的性能，功能之比较看看上面我推荐的文章就知道了，jdom全面惨败。

JDOM、DOM4J与JAXP都是对DOM、SAX的封装，但是JAXP具备跨平台性，JDOM、DOM4J是具体的应用，采用dom4j/jdom编写的应用程序，不具备可移植性。

JDOM、DOM4J相当于上面的JAXP接口＋DOM实现部分，它本身没有解析器，它可以使用Xerces或者Crimson的解析器。

jdom应用程序 -> jdom API -> Xerces/Crimson解析器

dom4j应用程序 -> dom4j API -> Xerces/Crimson解析器

dom4j应用程序 -> dom4j API -> Alfred2解析器

DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，例如大名鼎鼎的 Hibernate 也用 DOM4J 来读取 XML 配置文件，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。

xerces解释器

        在xerces中对jaxp中定义的SAXParser、SAXParserFactory、DocumentBuilder、DocumentBuilderFactory进行了继承，对应SAXParserImpl、SAXParserFactoryImpl、DocumentBuilderImpl、DocumentBuilderFactoryImpl
这就是为什么你的classpath中只要有xerces.jar（其中包含了sax dom jaxp ）和 xercesImpl.jar就可以的原因了

 

STAX

是一种新的处理技术，它与SAX不同之处在于它是iterator模式，SAX是观察者模式。

JDK6的新特性StAX(JSR 173)是JDK6.0中除了DOM和SAX之外的又一种处理XML文档的API 。
StAX的来历 
在JAXP1.3(JSR 206)有两种处理XML文档的方法:DOM(Document Object Model)和SAX(Simple API forXML).由于JDK6.0中的JAXB2(JSR 222)和JAX-WS 2.0(JSR224)都会用到StAX所以Sun决定把StAX加入到JAXP家族当中来，并将JAXP的版本升级到1.4(JAXP1.4是JAXP1.3的维护版本),JDK6里面JAXP的版本就是1.4。 
StAX是The Streaming API for XML的缩写，一种利用拉模式解析(pull-parsing)XML文档的API.StAX通过提供一种基于事件迭代器(Iterator)的API让程序员去控制xml文档解析过程,程序遍历这个事件迭代器去处理每一个解析事件，解析事件可以看做是程序拉出来的，也就是程序促使解析器产生一个解析事件然后处理该事件，之后又促使解析器产生下一个解析事件，如此循环直到碰到文档结束符；SAX也是基于事件处理xml文档，但却是用推模式解析，解析器解析完整个xml文档后，才产生解析事件，然后推给程序去处理这些事件；DOM采用的方式是将整个xml文档映射到一颗内存树，这样就可以很容易地得到父节点和子结点以及兄弟节点的数据，但如果文档很大，将会严重影响性能。 

以下是各种方式解析XML的java实例： 

1.DOM解析XML

package com.xml.parseXml;   

import java.io.IOException;   
import java.io.InputStream;   
import javax.xml.parsers.DocumentBuilder;   
import javax.xml.parsers.DocumentBuilderFactory;   
import javax.xml.parsers.ParserConfigurationException;   
import org.w3c.dom.Document;   
import org.w3c.dom.Element;   
import org.w3c.dom.NodeList;   
import org.xml.sax.SAXException;   
  
import com.test.bean.Address;   
import com.test.bean.ReadXmlFileStream;   
  
public class DOMParseXml {   
  
    private static Address address = new Address();   
       
    public static void main(String[] args) {   
          long lasting = System.currentTimeMillis();   
           
        try {   
            InputStream in = ReadXmlFileStream.getXmlFileStream();   
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();   
            DocumentBuilder builder = factory.newDocumentBuilder();   
            Document document = builder.parse(in);   
            Element root = document.getDocumentElement();   
            NodeList valueNode = root.getElementsByTagName("value");   
            System.out.println("addresses:" + root + root.getChildNodes() + valueNode.getLength());   
               
            for( int i=0; i<valueNode.getLength(); i++) {   
                System.out.println(i);   
                address.setNo(root.getElementsByTagName("no").item(i).getFirstChild().getNodeValue());   
                address.setAddr(root.getElementsByTagName("addr").item(i).getFirstChild().getNodeValue());   
                System.out.println(address);   
            }   
               
        } catch (ParserConfigurationException e) {   
            e.printStackTrace();   
        } catch (SAXException e) {   
            e.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        }   
        System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");   
    }   
}  

 
2.SAX解析XML

package com.xml.parseXml;   
  
import java.io.InputStream;   
import java.util.Stack;   
import javax.xml.parsers.SAXParser;   
import javax.xml.parsers.SAXParserFactory;   
import org.xml.sax.Attributes;   
import org.xml.sax.InputSource;   
import org.xml.sax.SAXException;   
import org.xml.sax.helpers.DefaultHandler;   
  
import com.test.bean.Address;   
import com.test.bean.ReadXmlFileStream;   
  
public class SAXParseXml extends DefaultHandler {   
  
    private static Address address = new Address();   
    private Stack tags = new Stack();   
  
    public SAXParseXml() {   }   
  
    @Override  
    public void characters(char[] ch, int start, int length)   
            throws SAXException {   
  
        String tag = (String) tags.peek();   
        if (tag.equals("no")) {   
            address.setNo(new String(ch, start, length));   
            System.out.println(address.getNo());   
        }   
        if (tag.equals("addr")) {   
            address.setAddr(new String(ch, start, length));   
            System.out.println(address.getAddr());   
        }   
    }   
  
    @Override  
    public void startElement(String uri, String localName, String qName,   
            Attributes attrs) throws SAXException {   
        tags.push(qName);   
    }   
  
    public static void main(String[] args) {   
  
        long lasting = System.currentTimeMillis();   
  
        try {   
            SAXParserFactory factory = SAXParserFactory.newInstance();   
            SAXParser sp = factory.newSAXParser();   
            SAXParseXml reader = new SAXParseXml();   
            InputStream in = ReadXmlFileStream.getXmlFileStream();   
            sp.parse(new InputSource(in), reader);   
            System.out.println("运行时间：" + (System.currentTimeMillis() - lasting)    + " 毫秒");   
  
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
    }   
  
}  
 
3.DOM4J解析XML

package com.xml.parseXml;   
  
import java.io.InputStream;   
import java.io.InputStreamReader;   
import java.io.Reader;   
import java.util.Iterator;   
import org.dom4j.Document;   
import org.dom4j.Element;   
import org.dom4j.io.SAXReader;   
  
import com.test.bean.Address;   
import com.test.bean.ReadXmlFileStream;   
  
  
public class DOM4JParseXml {   
  
    private static Address address = new Address();   
  
    public static void main(String[] args) {   
        long starttime = System.currentTimeMillis();   
  
        try {   
            InputStream in = ReadXmlFileStream.getXmlFileStream();   
            Reader reader = new InputStreamReader(in, "utf-8");  // 注意编码问题   
            SAXReader SaxReader = new SAXReader();   
            Document doc = SaxReader.read(reader);   
            Element root = doc.getRootElement();   
            Element childNode = null;   
           //枚举名称为value的节点   
            for (Iterator it = root.elementIterator("value"); it.hasNext();) {   
                childNode = (Element) it.next();   
                address.setNo(childNode.elementText("no"));   
                address.setAddr(childNode.elementText("addr"));   
                System.out.println(address);   
            }   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
        System.out.println("运行时间：" + (System.currentTimeMillis() - starttime)   + " 毫秒");   
    }   
}  
 
4.JDOM解析XML

package com.xml.parseXml;   
  
import java.io.IOException;   
import java.io.InputStream;   
import java.util.List;   
import org.jdom.Document;   
import org.jdom.Element;   
import org.jdom.JDOMException;   
import org.jdom.input.SAXBuilder;   
  
import com.test.bean.Address;   
import com.test.bean.ReadXmlFileStream;   
  
public class JDOMParseXml {   
  
    private static Address address = new Address();   
  
    public static void main(String[] args) {   
        long lasting = System.currentTimeMillis();   
        try {   
            SAXBuilder builder = new SAXBuilder();   
            InputStream in = ReadXmlFileStream.getXmlFileStream();   
            Document doc = builder.build(in);   
  
            Element root = doc.getRootElement();   
  
            List allChildren = root.getChildren();   
  
            for (int i = 0; i < allChildren.size(); i++) {   
                address.setNo(((Element) allChildren.get(i)).getChild("no").getTextTrim());   
                address.setAddr(((Element) allChildren.get(i)).getChild("addr").getTextTrim());   
                System.out.println(address);   
            }   
        } catch (JDOMException e) {   
            e.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        }   
        System.out.println("运行时间：" + (System.currentTimeMillis() - lasting)   + " 毫秒");   
    }   
}  

5.StAX解析XML

package com.xml.parseXml;   
  
import java.io.InputStream;   
import javax.xml.stream.XMLEventReader;   
import javax.xml.stream.XMLInputFactory;   
import javax.xml.stream.events.StartElement;   
import javax.xml.stream.events.XMLEvent;   
  
import com.test.bean.Address;   
import com.test.bean.ReadXmlFileStream;   
  
public class StAXParseXml {   
    private static Address address = new Address();   
  
    public static void main(String[] args) {   
        long lasting = System.currentTimeMillis();   
  
        try {   
            InputStream in = ReadXmlFileStream.getXmlFileStream();   
  
            XMLInputFactory xmlif = XMLInputFactory.newInstance();   
            // 用于解析 XML 事件的顶层接口   
            XMLEventReader reader = xmlif.createXMLEventReader(in);   
            // 处理标记事件的基础事件接口   
            XMLEvent event = null;   
  
            while (reader.hasNext()) {   
                event = reader.nextEvent();   
                if (event.isStartElement()) { // 起始元素   
                    StartElement startElt = event.asStartElement();   
                    if (startElt.getName().getLocalPart().equals("no")) {   
                        address.setNo(reader.getElementText());   
                    } else if (startElt.getName().getLocalPart().equals("addr")) {   
                        address.setAddr(reader.getElementText());   
                        System.out.println(address);   
                    }   
                } else if (event.isCharacters()) { // 文本内容   
                    // 相邻标记之间都是文本内容   
                    System.out.println("解析的是文本内容:" + event.asCharacters().getData());   
                } else if (event.isEndElement()) { // 结束元素   
                    System.out.println("解析的是结束标记:"  + event.asEndElement().getName());   
                }   
            }   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
        System.out.println("运行时间：" + (System.currentTimeMillis() - lasting)  + " 毫秒");   
    }   
}  
 
依赖的类：

1.Address .java

package com.test.bean;   
  
public class Address {   
  
    private String no;   
    private String addr;   
    /**  
     * @return the no  
     */  
    public String getNo() {   
        return no;   
    }   
    /**  
     * @param no the no to set  
     */  
    public void setNo(String no) {   
        this.no = no;   
    }   
    /**  
     * @return the addr  
     */  
    public String getAddr() {   
        return addr;   
    }   
    /**  
     * @param addr the addr to set  
     */  
    public void setAddr(String addr) {   
        this.addr = addr;   
    }   
    @Override  
    public String toString() {   
        return "编号:" + this.no + "，地址：" + this.addr;   
    }   
       
       
}  


 2.ReadXmlFileStream .java

package com.test.bean;   
  
import java.io.InputStream;   
  
public class ReadXmlFileStream {   
  
    private static final String XML_FILE = "com/xml/bean/addresses.xml";   
  
    public static InputStream getXmlFileStream() {   
        return Thread.currentThread().getContextClassLoader()   
                .getResourceAsStream(XML_FILE);   
    }   
  
}  
 
被解析的XML结构：addresses.xml

<?xml version="1.0" encoding="UTF-8"?>  
<addresses>  
    <value>  
        <no>A100</no>  
        <addr>广州天河区天河路</addr>  
    </value>  
    <value>  
        <no>A101</no>  
        <addr>广州天河区五山路</addr>  
    </value>  
</addresses>