解析 XML 文件一般来说有两种底层形式,一种是基于树的结构来解析的称为DOM;另一种是基于事件流的形式称为Sax。而在这两种解析方式的基础上,基于底层api的更高级封装解析器也应用而生,比如面向Java的 JDom和 Dom4J。

 

1、DOM(Document Object Model)

  DOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。由于它是基于信息层次的,因而 DOM 被认为是基于树或基于对象的。

  优点:

    ①、整个 Dom 树都加载到内存中了,所以允许随机读取访问数据。

    ②、允许随机的对文档结构进行增删。

  缺点:

    ①、整个 XML 文档必须一次性解析完,耗时。

    ②、整个 Dom 树都要加载到内存中,占内存。

  适用于:文档较小,且需要修改文档内容

 

2、Sax(Simple API for XML)

  

 

  SAX处理的特点是基于事件流的。分析能够立即开始,而不是等待所有的数据被处理。而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。sax分析器在对xml文档进行分析时,触发一系列的事件,应用程序通过事件处理函数实现对xml文档的访问,因为事件触发是有时序性的,所以sax分析器提供的是一种对xml文档的顺序访问机制,对于已经分析过的部分,不能再重新倒回去处理.此外,它也不能同时访问处理2个tag,sax分析器在实现时,只是顺序地检查xml文档中的字节流,判断当前字节是xml语法中的哪一部分,检查是否符合xml语法并且触发相应的事件.对于事件处理函数的本身,要由应用程序自己来实现. SAX解析器采用了基于事件的模型,它在解析XML文档的时候可以触发一系列的事件,当发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经找到。

  优点:

    ①、访问能够立即进行,不需要等待所有数据被加载。

    ②、只在读取数据时检查数据,不需要保存在内存中

    ③、不需要将整个数据都加载到内存中,占用内存少

    ④、允许注册多个Handler,可以用来解析文档内容,DTD约束等等。

  缺点:

    ①、需要应用程序自己负责TAG的处理逻辑(例如维护父/子关系等),文档越复杂程序就越复杂。

    ②、单向导航,无法定位文档层次,很难同时访问同一文档的不同部分数据,不支持XPath。

    ③、不能随机访问 xml 文档,不支持原地修改xml。

  适用于:文档较大,只需要读取文档数据。

 

 

3、JDOM(Java-based Document Object Model)

  JDOM是处理xml的纯java api.使用具体类而不是接口。JDOM具有树的遍历,又有SAX的java规则。

  JDOM与DOM主要有两方面不同。首先,JDOM仅使用具体类而不使用接口。这在某些方面简化了API,但是也限制了灵活性。第二,API大量使用了Collections类,简化了那些已经熟悉这些类的Java开发者的使用。

  JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档(尽管它还可以将以前构造的DOM表示作为输入)。它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布的开放源码。

  优点:

    ①、使用具体类而不是接口,简化了DOM的API。

    ②、大量使用了Java集合类,方便了Java开发人员。

  缺点:

    ①、不能处理大于内存的文档.

    ②、API 简单,没有较好的灵活性

 

 

4、DOM4J(Document Object Model for Java)

  虽然DOM4J代表了完全独立的开发结果,但最初,它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能,包括集成的XPath,支持XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项,它通过DOM4J API和标准DOM接口具有并行访问功能。从2000下半年开始,它就一直处于开发之中。

      为支持所有这些功能,DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类,但是在许多情况下,它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是,虽然DOM4J付出了更复杂的API的代价,但是它提供了比JDOM大得多的灵活性。

      在添加灵活性、XPath集成和对大文档处理的目标时,DOM4J的目标与JDOM是一样的:针对Java开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案,实现在本质上处理所有Java/XML问题的目标。在完成该目标时,它比JDOM更少强调防止不正确的应用程序行为。

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

  优点:

    ①、大量使用了Java集合类,方便Java开发人员,同时提供一些提高性能的替代方法。

    ②、支持XPath。查找节点特别快

    ③、灵活性高。

  缺点:

    ①、大量的使用了接口,API复杂,理解难。

    ②、移植性差。

 

 注:XPath是一门在 XML 文档中查找信息的语言。

 

比较:

  1、 DOM4J性能最好,连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J,例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性,那就采用DOM4J。

  2、JDOM和DOM在性能测试时表现不佳,在测试10M文档时内存溢出,但可移植。在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题,但是从性能观点来看,它确实没有值得推荐之处。另外,DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础,因为它正式获得W3C推荐(与基于非标准的Java模型相对),所以在某些类型的项目中可能也需要它(如在JavaScript中使用DOM)。

  3、SAX表现较好,这要依赖于它特定的解析方式-事件驱动。一个SAX检测即将到来的XML流,但并没有载入到内存(当然当XML流被读入时,会有部分文档暂时隐藏在内存中)。

  综上所述:如果XML文档较大且不考虑移植性问题建议采用DOM4J;如果XML文档较小则建议采用JDOM;如果需要及时处理而不需要保存数据则考虑SAX。

 

 

实例:

  第一步:建立一个 student.xml 文件,我们以这个文件通过上面的四种解析方式来对比分析。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?xml version="1.0" encoding="UTF-8"?>
<students>
    <student>
        <name>Tom</name>
        <age>11</age>
    </student>
    <student>
        <name>Bob</name>
        <age>22</age>
    </student>
    <student>
        <name>Marry</name>
        <age>23</age>
    </student>
</students>

 

  一、DOM 解析(JDK已经自带jar包,不需要额外导入!)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package com.ys.xml;
 
import java.io.FileOutputStream;
 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
 
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
 
public class DomParser{
     
    /**
     * 解析器读入整个文档,然后构建一个驻留内存的树结构,
     * 该方法返回 Document 对象,然后我们可以通过 这个对象来操作文档
     */
    public Document getDocument(String fileName) throws Exception{
        //1.创建解析工厂
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        //2.得到解析器
        DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
        //3.得到文档对象
        Document document = dBuilder.parse(fileName);
         
        return document;
    }
     
    //读取xml文档中的数据
    public void read(String fileName) throws Exception{
        //获取 Document 对象
        Document document = new DomParser().getDocument(fileName);
         
        //获取<name></name>的节点
        NodeList nameNode = document.getElementsByTagName("name");
        //获取<name sex="xxx"></name>节点的sex属性
        Element element = (Element) document.getElementsByTagName("name").item(0);
        System.out.println(element.getAttribute("sex"));//xxx
         
        for(int i = 0 ; i < nameNode.getLength() ;i++){
            System.out.println(nameNode.item(i).getTextContent());
        }
        /**结果为
         * Tom
         * Bob
         * Marry
         */
         
        //获取文档的根元素对象
        Element rootElementName = document.getDocumentElement();
        System.out.println(rootElementName.getNodeName()); //students
         
        //得到根节点
        Node root = document.getElementsByTagName(rootElementName.getNodeName()).item(0);
        list(root);
         
    }
     
    //打印所有标签
    private void list(Node root) {
        if(root instanceof Element){
            System.out.println(root.getNodeName());
        }
        NodeList list = root.getChildNodes();
        for(int i = 0 ; i < list.getLength() ; i++){
            Node child = list.item(i);
            list(child);
        }
    }
     
    //向 xml 文件中增加节点和属性
    public void add(String fileName) throws Exception{
        //获取 Document 对象
        Document document = new DomParser().getDocument(fileName);
         
        //创建节点
        Element sex = document.createElement("sex");
        sex.setTextContent("男");
         
        //把创建的节点添加到第一个<student></student>标签上
        Element student = (Element) document.getElementsByTagName("student").item(0);
        student.appendChild(sex);
         
        //在<name></name>中增加属性 <name address="xxx"></name>
        Element name = (Element) document.getElementsByTagName("name").item(0);
        name.setAttribute("address", "xxx");
         
        //把更新后的内存写入xml文档中
        TransformerFactory tfFactory = TransformerFactory.newInstance();
        Transformer tFormer = tfFactory.newTransformer();
        tFormer.transform(new DOMSource(document),
                new StreamResult(new FileOutputStream("src/student.xml")));
    }
     
    //向 xml 文件中删除节点和属性
    public void delete(String fileName) throws Exception{
        //获取 Document 对象
        Document document = new DomParser().getDocument(fileName);
         
        //得到要删除的第一个<name></name>节点
        Element name = (Element) document.getElementsByTagName("name").item(0);
        //得到要删除的第一个<name></name>节点的父节点
        //Element student = (Element) document.getElementsByTagName("student").item(0);
        //student.removeChild(name);
        //上面两步可以简写为
        name.getParentNode().removeChild(name);
         
        //在<name></name>中删除属性 <name address="xxx"></name>
        name.removeAttribute("address");
         
        //把更新后的内存写入xml文档中
        TransformerFactory tfFactory = TransformerFactory.newInstance();
        Transformer tFormer = tfFactory.newTransformer();
        tFormer.transform(new DOMSource(document),
                new StreamResult(new FileOutputStream("src/student.xml")));
    }
 
     
    //向 xml 文件中更新节点和属性
    public void update(String fileName) throws Exception{
        //获取 Document 对象
        Document document = new DomParser().getDocument(fileName);
         
        //得到要删除的第一个<name></name>节点
        Element name = (Element) document.getElementsByTagName("name").item(0);
        //在<name></name>中更新属性 <name address="xxx"></name>为<name address="yyy"></name>
        name.setAttribute("address", "yyy");
        //更新name节点的文字为VAE,即<name>vae</name>
        name.setTextContent("vae");
         
        //把更新后的内存写入xml文档中
        TransformerFactory tfFactory = TransformerFactory.newInstance();
        Transformer tFormer = tfFactory.newTransformer();
        tFormer.transform(new DOMSource(document),
                new StreamResult(new FileOutputStream("src/student.xml")));
    }
}

  

  

  二、SAX 解析(JDK已经自带jar包,不需要额外导入!)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package com.ys.xml;
 
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
 
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
 
 
public class SaxParser{
     
    public static void main(String[] args) throws Exception {
        //1.创建解析工厂
        SAXParserFactory spFactory = SAXParserFactory.newInstance();
        //2.得到解析器
        SAXParser sParser = spFactory.newSAXParser();
        //3.得到读取器
        XMLReader xmlReader = sParser.getXMLReader();
         
        //4.设置内容处理器
        xmlReader.setContentHandler(new TagDefaultHandler());
         
        //5.读取 XML 文档内容
        xmlReader.parse("src/student.xml");
    }
}
 
//第一种方法:继承接口ContentHandler 得到 XML 文档所有内容
class ListHandler implements ContentHandler{
 
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes atts) throws SAXException {
        System.out.println("<"+qName+">");
    }
 
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        System.out.println(new String(ch,start,length));
    }
     
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        System.out.println("</"+qName+">");
    }
 
    @Override
    public void setDocumentLocator(Locator locator) {
    }
 
    @Override
    public void startDocument() throws SAXException {
    }
 
    @Override
    public void endDocument() throws SAXException {
    }
 
    @Override
    public void startPrefixMapping(String prefix, String uri)
            throws SAXException {
    }
 
    @Override
    public void endPrefixMapping(String prefix) throws SAXException {
    }
 
    @Override
    public void ignorableWhitespace(char[] ch, int start, int length)
            throws SAXException {
    }
 
    @Override
    public void processingInstruction(String target, String data)
            throws SAXException {
    }
 
    @Override
    public void skippedEntity(String name) throws SAXException {
    }
     
}
 
 
//使用继承类 DefaultHandler 更好
class TagDefaultHandler extends DefaultHandler{
    //当前解析的是什么标签
    private String currentTag;
    //想获得第几个标签的值
    private int tagNumber=0;
    //当前解析的是第几个标签
    private int currentNumber=0;
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        currentTag = qName;
        //当前解析的name 标签是第几个
        if("name".equals(currentTag)){
            currentNumber++;
            System.out.println(currentNumber);
        }
    }
     
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        //打印所有name标签的值
        if("name".equals(currentTag)){
            System.out.println(new String(ch,start,length));
        }
        //想获得 第二个name标签的值
        tagNumber = 2;
        if("name".equals(currentTag)&&currentNumber==tagNumber){
            System.out.println(new String(ch,start,length));
        }      
    }
     
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        currentTag = null;
    }
}

  

  三、DOM4J 解析

  JAR包下载链接:http://pan.baidu.com/s/1b5L9AA 密码:wg2l

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package com.ys.xml;
 
import java.io.File;
import java.io.FileOutputStream;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
 
public class DOM4JParser {
     
    //读取第二个<name><name>
    @Test
    public void read() throws Exception{
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/student.xml"));
         
        //得到根节点
        Element root = document.getRootElement();
        //得到第二个<student><student>节点
        Element student = (Element)root.elements("student").get(1);
        //获取<name><name>中间的值
        String value = student.element("name").getText();
        System.out.println(value);//Bob
        //获取<name sex="xxx"><name>中间的sex值
        String sexValue = student.element("name").attributeValue("sex");
        System.out.println(sexValue);//xxx
    }
     
     
    //增加节点
    @Test
    public void add() throws Exception{
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/student.xml"));
         
        Element student = document.getRootElement().element("student");
        student.addElement("schoolName").setText("湖北");
         
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");
         
        XMLWriter writer = new XMLWriter(new FileOutputStream("src/student.xml"),format);
        writer.write(document);
        writer.close();
         
    }
     
 
    //删除节点
    @Test
    public void delete() throws Exception{
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/student.xml"));
         
        Element student = (Element)document.getRootElement().elements("student").get(1);
        student.element("schoolName").setText("湖南");
         
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");
         
        XMLWriter writer = new XMLWriter(new FileOutputStream("src/student.xml"),format);
        writer.write(document);
        writer.close();
         
    }
     
    //修改节点
    @Test
    public void update() throws Exception{
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/student.xml"));
         
        Element student = document.getRootElement().element("student");
        Element schoolName = student.element("schoolName");
        schoolName.getParent().remove(schoolName);
         
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");
         
        XMLWriter writer = new XMLWriter(new FileOutputStream("src/student.xml"),format);
        writer.write(document);
        writer.close();
         
    }
 
}

  

 

XPath 简介:

   由于 DOM4J 是支持 XPath,那么 XPath 是什么呢?

  XPath 是一门在 XML 文档中查找信息的语言。使用路径表达式来选取 XML 文档中的节点或者节点集。这些路径表达式和我们在常规的电脑文件系统中看到的表达式非常相似。

  

 

  

我们以一个例子看一下用法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com.ys.xml;
 
import java.io.File;
import java.util.List;
 
import org.dom4j.Document;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
 
public class XPathParser {
     
    public static void main(String[] args) throws Exception {
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/student.xml"));
         
        //得到第一个 name 节点的值
        String nameValue = document.selectSingleNode("//name").getText();
        System.out.println(nameValue); //Tom
         
        //得到所有 name 节点的值
        List<Node> nameValues = document.selectNodes("//name");
        for(Node obj : nameValues){
            System.out.println(obj.getText());//Tom   Bob  Marry
        }
         
    }
 
}