最近学到了XML的解析，想请问一下。

XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？

a: 两种形式 dtd schema
b: 本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)
c:有DOM,SAX,STAX等 DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文  件之前把整个文档装入内存,适合对XML的随机访问 SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。
当遇到像文件开头，文档结  束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问  STAX:Streaming API for XML (StAX) xml文档有两种定义方法： dtd：数据类型定义（data type definition），用以描述XML文档的文档结构，是早期的XML文档定义形式。 schema：其本身是基于XML语言编写的，在类型和语法上的限定能力比dtd强，处理也比较方便，因为此正逐渐代替dtd成为新的模式  定义语言。

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. <书架>
   
3.   <书>
   
4.     <书名 name="test1">111</书名>
   
5.     <价格>222元</价格>
   
6.     <作者>aaa</作者>
   
7.   </书>
   
8.   <书>
   
9.     <书名 name="shu4">444</书名>
   
10.     <作者>bbb</作者>
    
11.     <价格>555元</价格>
    
12.   </书>
    
13. </书架>

复制代码

以这个XML为例，下面是XML解析方式：

一种是dom（Document Object Model，即文档对象模型，W3C组织推荐），在使用dom解析XML文档时，需要读取整个XML文档，在内存中架构代表整个dom树的document对象，从而再对XML文档进行操作。如果XML文档特别大，就会大量消耗计算机的内存，甚至可能导致内存溢出。

一种是sax（Simple API for XML，不是官方标准，但所有XML解析器都支持它）。sax解析允许读取文档的时候，就对文档进行处理，而不必等到整个文档都读进内存再进行操作。
XML解析开发包：Jaxp（sun）、Jdom、dom4j。
首先是Jaxp解析XML，Jaxp开发包是J2SE的一部分，由javax.xml、org.w3c.dom、org.xml.sax包以及其子包组成。
示例读取xml标签内容：

1.         public void read() throws Exception {
   
2.                 //用工厂方法获将xml解析成document
   
3.                 //创建工厂
   
4.                 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
   
5.                 //得到DOM解析器
   
6.                 DocumentBuilder builder = factory.newDocumentBuilder();
   
7.                 //解析xml文档，得到document
   
8.                 Document doc = builder.parse("src/xml/book.xml");
   
9.                 //得到所有<书>标签
   
10.                 NodeList list = doc.getElementsByTagName("书");
    
11.                 //获得第二个<书>标签
    
12.                 Node node = list.item(1);
    
13.                 //获取标签内容
    
14.                 String s = node.getTextContent();
    
15.                
    
16.                 System.out.println(s);
    
17.         }

复制代码

然后是sax解析XML，sax采用事件处理的方式解析XML文件，利用sax解析XML文件，需要解析器和事件处理器。解析器可以使用Jaxp的API创建，创建好sax解析器后就可以制定解析器去解析某个XML文档。在这个过程中，sax同时会去调用一个事件处理器的方法，并把解析的XML文件内容当做方法参数传递给事件处理器。

1. package xml.sax;
   
2. 
   
3. import javax.xml.parsers.ParserConfigurationException;
   
4. import javax.xml.parsers.SAXParser;
   
5. import javax.xml.parsers.SAXParserFactory;
   
6. 
   
7. import org.xml.sax.Attributes;
   
8. import org.xml.sax.ContentHandler;
   
9. import org.xml.sax.Locator;
   
10. import org.xml.sax.SAXException;
    
11. import org.xml.sax.XMLReader;
    
12. 
    
13. public class SaxDemo1 {
    
14. 
    
15.         public static void main(String[] args) throws Exception {
    
16.                 // 1.创建解析工厂
    
17.                 SAXParserFactory factory = SAXParserFactory.newInstance();
    
18.                 // 2.得到解析器
    
19.                 SAXParser sp = factory.newSAXParser();
    
20.                 // 3.得到读取内容
    
21.                 XMLReader reader = sp.getXMLReader();
    
22.                 // 4.设置内容处理器
    
23.                 reader.setContentHandler(new ListHandler());
    
24.                 // 5.读取xml文档内容
    
25.                 reader.parse("src/xml/book.xml");
    
26.         }
    
27. }
    
28. 
    
29. //创建自己的事件处理器
    
30. class ListHandler implements ContentHandler {
    
31. 
    
32.         //开始标签
    
33.         public void startElement(String uri, String localName, String qName,
    
34.                         Attributes atts) throws SAXException {
    
35.                 // TODO Auto-generated method stub
    
36.                 String name = "<" + qName;
    
37.                 for (int i = 0; atts != null && i < atts.getLength(); i++) {
    
38.                         name += " " + atts.getQName(i) + "=" + atts.getValue(i);
    
39.                 }
    
40.                 System.out.println(name + ">");
    
41.         }
    
42.         //标签内容
    
43.         public void characters(char[] ch, int start, int length)
    
44.                         throws SAXException {
    
45.                 // TODO Auto-generated method stub
    
46.                 System.out.println(new String(ch, start, length));
    
47.         }
    
48.         //结束标签
    
49.         public void endElement(String uri, String localName, String qName)
    
50.                         throws SAXException {
    
51.                 // TODO Auto-generated method stub
    
52.                 System.out.println("</" + qName + ">");
    
53.         }
    
54. 
    
55.         public void endDocument() throws SAXException {
    
56.                 // TODO Auto-generated method stub
    
57. 
    
58.         }
    
59. 
    
60.         public void endPrefixMapping(String prefix) throws SAXException {
    
61.                 // TODO Auto-generated method stub
    
62. 
    
63.         }
    
64. 
    
65.         public void ignorableWhitespace(char[] ch, int start, int length)
    
66.                         throws SAXException {
    
67.                 // TODO Auto-generated method stub
    
68. 
    
69.         }
    
70. 
    
71.         public void processingInstruction(String target, String data)
    
72.                         throws SAXException {
    
73.                 // TODO Auto-generated method stub
    
74. 
    
75.         }
    
76. 
    
77.         public void setDocumentLocator(Locator locator) {
    
78.                 // TODO Auto-generated method stub
    
79. 
    
80.         }
    
81. 
    
82.         public void skippedEntity(String name) throws SAXException {
    
83.                 // TODO Auto-generated method stub
    
84. 
    
85.         }
    
86. 
    
87.         public void startDocument() throws SAXException {
    
88.                 // TODO Auto-generated method stub
    
89. 
    
90.         }
    
91. 
    
92.         public void startPrefixMapping(String prefix, String uri)
    
93.                         throws SAXException {
    
94.                 // TODO Auto-generated method stub
    
95. 
    
96.         }
    
97. 
    
98. }

复制代码

最后是dom4j解析XML，一个优秀的Java XML API，虽然API相对上边的两种要复杂一些，但胜在灵活易用且更能强大。
使用dom4j开发，需要下载相应的jar文件。

1.         public void read() throws Exception{
   
2.                 //创建解析器
   
3.                 SAXReader reader = new SAXReader();
   
4.                 //解析XML文档，获得document
   
5.                 Document doc = reader.read(new File("src/xml/book.xml"));
   
6.                 //获得根节点
   
7.                 Element root = doc.getRootElement();
   
8.                 //获取根节点下面的指定节点<书>
   
9.                 Element book = (Element)root.elements("书").get(1);
   
10.                 //获取<书>节点下，指定节点<作者>的内容
    
11.                 String author = book.element("作者").getText();
    
12.                 //打印输出
    
13.                 System.out.println(author);
    
14.         }

复制代码