DOM和SAX解析XML文件

DOM解析XML文件：

1.javax.xml.parsers 包中的DocumentBuilderFactory用于创建DOM模式的解析器对象 ， DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance方法 ，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象并返回

2.调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。
3.调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象。
4.调用 DOM 解析器对象的 parse() 方法解析 XML 文档，得到代表整个文档的 Document 对象，进行可以利用DOM特性对整个XML文档进行操作了。

案例1.遍历xml文件中跟节点下面的所有子节点.

1.xml的约束文件java.dtd

[html]  view plain copy

1. <!ELEMENT classes (java班,net班,php班,ios班)>  
2. <!ELEMENT java班 (teachers?,students?)>  
3. <!ELEMENT net班 (teachers?,students?)>  
4. <!ELEMENT php班 (teachers?,students?)>  
5. <!ELEMENT ios班 (teachers?,students?)>  
6. <!ELEMENT teachers (teacher*)>  
7. <!ELEMENT teacher EMPTY>  
8. <!ELEMENT students (student*)>  
9. <!ELEMENT student (name,sex,age)>  
10. <!ATTLIST java班 name CDATA #IMPLIED>  
11. <!ATTLIST net班 name CDATA #IMPLIED>  
12. <!ATTLIST php班 name CDATA #IMPLIED>  
13. <!ATTLIST ios班 name CDATA #IMPLIED>  
14. <!ATTLIST teacher name CDATA #IMPLIED>  
15. <!ATTLIST teacher sex CDATA #IMPLIED>  
16. <!ATTLIST teacher age CDATA #IMPLIED>  
17. <!ELEMENT name (#PCDATA)>  
18. <!ELEMENT sex (#PCDATA)>  
19. <!ELEMENT age (#PCDATA)>  
20. <!ATTLIST student id ID #IMPLIED>  

2.xml文件内容如下java.xml

[html]  view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE classes SYSTEM "bin//parsers//java.dtd">  
3. <classes>  
4.     <java班 name="CSDNJava01班">  
5.         <teachers>  
6.             <teacher name="军哥" sex="男" age="28" />  
7.             <teacher name="刘丽华" sex="女" age="28" />  
8.         </teachers>  
9.         <students>  
10.             <student id="x121">  
11.                 <name>王亮</name>  
12.                 <sex>女</sex>  
13.                 <age>28</age>  
14.             </student>  
15.         </students>  
16.     </java班>  
17.     <!-- 注释0 -->  
18.     <net班 name="CSDNNet01班">xxx</net班>  
19.     <php班 name="CSDNPhp01班"></php班>  
20.     <ios班 name="CSDNIos01班"></ios班>  
21. </classes>  
22. <!-- 对java.xml文件进行CRUD的操作 -->  
23. <!-- 节点  
24.         nodeName            nodeValue        nodeType  
25. element  标签名               null             1  
26. Attr     属性名              属性值            2  
27. text     #text               文本的值          3  
28.  -->  

3.遍历xml文件的操作

//1.获取XML的根节点对象

[java]  view plain copy

1. @Test  
2.     public void test() throws ParserConfigurationException, SAXException, IOException{  
3.         //调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂  
4.         DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();  
5.         //调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象  
6.         DocumentBuilder builder =  builderFactory.newDocumentBuilder();  
7.         //通过文件的方式获取Document对象  
8.         /*File file = new File("src//parsers//java.xml"); 
9.         System.out.println(file+"----"); 
10.         Document document = builder.parse(file);*/  
11.         //解析指定的文件  
12.         InputStream is= this.getClass().getClassLoader()  
13.                               .getResourceAsStream("parsers//java.xml");  
14.         Document document = builder.parse(is);  
15.           
16.         //document.getDocumentElement()获取根节点的元素对象  
17.         Element root = document.getDocumentElement();  
18.         //遍历根节点下面的所有子节点  
19.         listNodes(root);  
20.     }  

//2.遍历节点对象的方法

[java]  view plain copy

1. /** 
2.      * 遍历根据节点对象下面的所有的节点对象 
3.      * @param node 
4.      */  
5.     public void listNodes(Node node) {  
6.         // 节点是什么类型的节点  
7.         if (node.getNodeType() == Node.ELEMENT_NODE) {// 判断是否是元素节点  
8.             Element element = (Element) node;  
9.             //判断此元素节点是否有属性  
10.             if(element.hasAttributes()){  
11.                 //获取属性节点的集合  
12.                 NamedNodeMap namenm =   element.getAttributes();//Node  
13.                 //遍历属性节点的集合  
14.                 for(int k=0;k<namenm.getLength();k++){  
15.                     //获取具体的某个属性节点  
16.                     Attr attr = (Attr) namenm.item(k);  
17.                     System.out.println("name:::"+attr.getNodeName()+" value::"  
18.                                      +attr.getNodeValue()+"  type::"+attr.getNodeType());  
19.                 }  
20.             }  
21.             //获取元素节点的所有孩子节点  
22.             NodeList listnode = element.getChildNodes();  
23.             //遍历  
24.             for (int j = 0; j < listnode.getLength(); j++) {  
25.                 //得到某个具体的节点对象  
26.                 Node nd = listnode.item(j);  
27.                 System.out.println("name::" + nd.getNodeName() + "  value:::"  
28.                         + nd.getNodeValue() + "  type:::" + nd.getNodeType());  
29.                 //重新调用遍历节点的操作的方法  
30.                 listNodes(nd);  
31.             }  
32.   
33.         }  
34.     }  

4.查询某个节点对象(简单列举一些案例)

[java]  view plain copy

1. /** 
2.  * 根据标签的名称查找所有该名称的节点对象 
3.  */  
4. public void findNode(Document document) {  
5.     //根据标签名称获取该名称的所有节点对象  
6.     NodeList nodelist = document.getElementsByTagName("teacher");  
7.     //遍历  
8.     for (int i = 0; i < nodelist.getLength(); i++) {  
9.         //得到具体的某个节点对象  
10.         Node node = nodelist.item(i);  
11.         System.out.println(node.getNodeName());  
12.     }  
13. }  
14.   
15. /** 
16.  * 根据属性的值 查询某个节点对象 
17.  * 属性值是唯一（假设） 
18.  * @param document 
19.  * @param value 
20.  * @return 
21.  */  
22. public Node findNodeByAttrValue(Document document, String value) {  
23.     //根据标签名称获取该名称的节点对象集合  
24.     NodeList nodelist = document.getElementsByTagName("teacher");  
25.     //遍历  
26.     for (int i = 0; i < nodelist.getLength(); i++) {  
27.         //获取某个具体的元素节点对象  
28.         Element node = (Element) nodelist.item(i);  
29.         //根据属性名称获取该节点的属性节点对象  
30.         Attr attr = node.getAttributeNode("name");  
31.         //获取属性节点的值是否给指定的节点属性值相同  
32.         if (attr.getNodeValue().equals(value)) {  
33.             //返回此节点  
34.             return node;  
35.         }  
36.     }  
37.     return null;  
38. }  
39.   
40. /** 
41.  * 根据id获取某个节点对象 
42.  *  
43.  * @param document 
44.  * @param id 
45.  * @return 
46.  */  
47. public Node findNodeById(Document document, String id) {  
48.     return document.getElementById(id);  
49. }  

5.删除指定的节点对象

[java]  view plain copy

1. /** 
2.      * 删除某个节点对象 
3.      *  
4.      * @param document 
5.      * @param id 
6.      * @throws TransformerException 
7.      */  
8.     public void deleteNodeById(Document document, String id)  
9.             throws TransformerException {  
10.         //获取删除的节点对象  
11.         Node node = document.getElementById(id);  
12.         // 是通过父节点调用removeChild(node)把子节点给删除掉  
13.         Node node1 = node.getParentNode().removeChild(node);  
14.           
15.         //创建TransformerFactory对象  
16.         TransformerFactory transformerFactory = TransformerFactory  
17.                 .newInstance();  
18.         //Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出  
19.         //Transformer对象通过TransformerFactory获得  
20.         Transformer transformer = transformerFactory.newTransformer();  
21.         // 把Document对象又重新写入到一个XML文件中。  
22.         transformer.transform(new DOMSource(document), new StreamResult(  
23.                 new File("src//a.xml")));  
24.     }  

6.更新某个节点对象

[java]  view plain copy

1. /** 
2.  * 更新某个节点 
3.  *  
4.  * @param document 
5.  * @param id 
6.  * @throws TransformerException 
7.  */  
8. public void updateNodeById(Document document, String id)  
9.         throws TransformerException {  
10.     //根据id获取元素指定的元素节点对象  
11.     Element node = document.getElementById(id);  
12.     //获取元素节点的id属性节点对象  
13.     Attr attr = node.getAttributeNode("id");  
14.     //修改元素节点的属性值  
15.     attr.setValue("x122");  
16.   
17.     //获取该节点对象的所有孩子节点对象name、age、sex节点  
18.     NodeList nodelist = node.getChildNodes();  
19.        //遍历  
20.     for (int i = 0; i < nodelist.getLength(); i++) {  
21.         //得到具体的节点对象  
22.         Node n = nodelist.item(i);  
23.         //判断是否是元素节点对象  
24.         if (n.getNodeType() == Node.ELEMENT_NODE) {  
25.             //看是否是name节点  
26.             if (n.getNodeName().equals("name")) {  
27.                 n.setTextContent("君君");//修改其值  
28.             } else if (n.getNodeName().equals("age")) {//看看是否是age节点  
29.                 n.setTextContent("80");//修改其值  
30.             } else if (n.getNodeName().equals("sex")) {//看看是否是sex节点  
31.                 n.setTextContent("男");//修改其值  
32.             } else {  
33.                 System.out.println("不做处理");  
34.             }  
35.         }  
36.     }  
37.   
38.     //创建TransformerFactory对象  
39.     TransformerFactory transformerFactory = TransformerFactory  
40.             .newInstance();  
41.     //Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出  
42.     //Transformer对象通过TransformerFactory获得  
43.     Transformer transformer = transformerFactory.newTransformer();  
44.     //把Document对象又重新写入到一个XML文件中。  
45.     transformer.transform(new DOMSource(document), new StreamResult(  
46.             new File("src//b.xml")));  
47. }  

7.在某个节点的下方添加新的节点

[java]  view plain copy

1. /** 
2.  * 在指定的节点下方添加新得某个节点 
3.  *  
4.  * @param document 
5.  * @param id 
6.  * @throws TransformerException 
7.  */  
8. public void addNodeById(Document document, String id)  
9.         throws TransformerException {  
10.     //获取要添加位置节点的兄弟节点对象  
11.     Element node = document.getElementById(id);  
12.     //获取其父节点对象  
13.     Node parentNode = node.getParentNode();  
14.     //创建元素节点  
15.     Element nd = document.createElement("student");  
16.     //设置元素节点的属性值  
17.     nd.setAttribute("id", "x123");  
18.     //创建name元素节点  
19.     Node name = document.createElement("name");  
20.     //设置name节点的文本值  
21.     name.appendChild(document.createTextNode("陈红军"));  
22.     //创建age元素节点  
23.     Node age = document.createElement("age");  
24.     //设置age节点的文本值  
25.     age.appendChild(document.createTextNode("20"));  
26.     //创建sex元素节点  
27.     Node sex = document.createElement("sex");  
28.     //设置sex节点的文本值  
29.     sex.appendChild(document.createTextNode("男"));  
30.     //在nd节点中添加3个子节点  
31.     nd.appendChild(name);  
32.     nd.appendChild(age);  
33.     nd.appendChild(sex);  
34.     //在父节点中添加nd节点  
35.     parentNode.appendChild(nd);  
36.   
37.     //创建TransformerFactory对象  
38.     TransformerFactory transformerFactory = TransformerFactory  
39.             .newInstance();  
40.     //Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出  
41.     //Transformer对象通过TransformerFactory获得  
42.     Transformer transformer = transformerFactory.newTransformer();  
43.     //把Document对象又重新写入到一个XML文件中。  
44.     transformer.transform(new DOMSource(document), new StreamResult(  
45.             new File("src//c.xml")));  
46. }  

SAX解析XML文件：

SAX解析XML文件采用事件驱动的方式进行，也就是说，SAX是逐行扫描文件，遇到符合条件的设定条件后就会触发特定的事件，回调你写好的事件处理程序。使用SAX的优势在于其解析速度较快，相对于DOM而言占用内存较少。而且SAX在解析文件的过程中得到自己需要的信息后可以随时终止解析，并不一定要等文件全部解析完毕。凡事有利必有弊，其劣势在于SAX采用的是流式处理方式，当遇到某个标签的时候，它并不会记录下以前所遇到的标签，也就是说，在处理某个标签的时候，比如在startElement方法中，所能够得到的信息就是标签的名字和属性，至于标签内部的嵌套结构，上层标签、下层标签以及其兄弟节点的名称等等与其结构相关的信息都是不得而知的。实际上就是把XML文件的结构信息丢掉了，如果需要得到这些信息的话，只能你自己在程序里进行处理了。所以相对DOM而言，SAX处理XML文档没有DOM方便，SAX处理的过程相对DOM而言也比较复杂。

        SAX采用事件处理的方式解析XML文件，利用 SAX 解析 XML 文档，涉及两个部分：解析器和事件处理器：
解析器可以使用JAXP的API创建，创建出SAX解析器后，就可以指定解析器去解析某个XML文档。
解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的xml文件内容作为方法的参数传递给事件处理器。
事件处理器由程序员编写，程序员通过事件处理器中方法的参数，就可以很轻松地得到sax解析器解析到的数据，从而可以决定如何对数据进行处理。

备注说明：SAX API中主要有四种处理事件的接口，它们分别是ContentHandler，DTDHandler， EntityResolver 和 ErrorHandler 

 这里使用最多的就是ContentHandler,仔细阅读 API文档，了解常用方法：startElement、endElement、characters等

 1.startElement方法说明

[java]  view plain copy

1. void startElement(String uri,  
2.                   String localName,  
3.                   String qName,  
4.                   Attributes atts)  
5.                   throws SAXException  
6. 方法说明:  
7. 解析器在 XML 文档中的每个元素的开始调用此方法；对于每个 startElement 事件都将有相应的 endElement 事件（即使该元素为空时）。所有元素的内容都将在相应的 endElement 事件之前顺序地报告。  
8.   
9. 参数说明:  
10. uri - 名称空间 URI，如果元素没有名称空间 URI，或者未执行名称空间处理，则为空字符串  
11. localName - 本地名称（不带前缀），如果未执行名称空间处理，则为空字符串  
12. qName - 限定名（带有前缀），如果限定名不可用，则为空字符串  
13. atts - 连接到元素上的属性。如果没有属性，则它将是空 Attributes 对象。在 startElement 返回后，此对象的值是未定义的  

 2.endElement方法说明

[java]  view plain copy

1. void endElement(String uri,  
2.                 String localName,  
3.                 String qName)  
4.                 throws SAXException接收元素结束的通知。   
5. SAX 解析器会在 XML 文档中每个元素的末尾调用此方法；对于每个 endElement 事件都将有相应的 startElement 事件（即使该元素为空时）。  
6.   
7. 参数：  
8. uri - 名称空间 URI，如果元素没有名称空间 URI，或者未执行名称空间处理，则为空字符串  
9. localName - 本地名称（不带前缀），如果未执行名称空间处理，则为空字符串  
10. qName - 限定的 XML 名称（带前缀），如果限定名不可用，则为空字符串  

3.characters方法

[java]  view plain copy

1. void characters(char[] ch,  
2.                 int start,  
3.                 int length)  
4.                 throws SAXException  
5. 接收字符数据的通知,可以通过new String(ch,start,length)构造器，创建解析出来的字符串文本.  
6. 参数：  
7. ch - 来自 XML 文档的字符  
8. start - 数组中的开始位置  
9. length - 从数组中读取的字符的个数   

其它方法请参考api数据

下面我们就具体讲解sax解析的操作.

一.我们通过XMLReaderFactory、XMLReader完成,步骤如下

[java]  view plain copy

1. 1.通过XMLReaderFactory创建XMLReader对象  
2. XMLReader reader = XMLReaderFactory.createXMLReader();  
3. 2. 设置事件处理器对象  
4. reader.setContentHandler(new MyDefaultHandler());  
5. 3.读取要解析的xml文件  
6. FileReader fileReader =new FileReader(new File("src\\sax\\startelement\\web.xml"));  
7. 4.指定解析的xml文件  
8. reader.parse(new InputSource(fileReader));  

案例:通过案例对uri、localName、qName和attribute参数有更加深入的了解

1.首先创建要解析的web.xml文件,内容如下

[html]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="2.5"   
3.     xmlns:csdn="http://java.sun.com/xml/ns/javaee"   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
5.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
6.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
7.   <csdn:display-name></csdn:display-name>     
8. </web-app>  
9. <!--   
10. uri - 名称空间 URI，如果元素没有任何名称空间 URI，或者没有正在执行名称空间处理，则为空字符串。  
11. xml namespace-xmlns  
12. localName - 本地名称（不带前缀），如果没有正在执行名称空间处理，则为空字符串。  
13. qName - 限定的名称（带有前缀），如果限定的名称不可用，则为空字符串。  
14. attributes - 附加到元素的属性。如果没有属性，则它将是空的 Attributes 对象。   
15.  -->  

2.创建解析测试类及事件处理的内部类代码如下

[java]  view plain copy

1. package sax.startelement;  
2.   
3. import java.io.File;  
4. import java.io.FileReader;  
5.   
6. import org.junit.Test;  
7. import org.xml.sax.Attributes;  
8. import org.xml.sax.InputSource;  
9. import org.xml.sax.SAXException;  
10. import org.xml.sax.XMLReader;  
11. import org.xml.sax.helpers.DefaultHandler;  
12. import org.xml.sax.helpers.XMLReaderFactory;  
13.   
14. public class Demo3 {  
15.   
16.     @Test  
17.     public void test() throws Exception {  
18.         // 通过XMLReaderFactory创建XMLReader对象  
19.         XMLReader reader = XMLReaderFactory.createXMLReader();  
20.         // 设置事件处理器对象  
21.         reader.setContentHandler(new MyDefaultHandler());  
22.         // 读取要解析的xml文件  
23.         FileReader fileReader = new FileReader(new File(  
24.                 "src\\sax\\startelement\\web.xml"));  
25.         // 指定解析的xml文件  
26.         reader.parse(new InputSource(fileReader));  
27.     }  
28.   
29.     // 自定义的解析类,通过此类中的startElement了解uri,localName,qName,Attributes的含义  
30.     class MyDefaultHandler extends DefaultHandler {  
31.   
32.         @Override  
33.         public void startElement(String uri, String localName, String qName,  
34.                 Attributes attributes) throws SAXException {  
35.             super.startElement(uri, localName, qName, attributes);  
36.             System.out  
37.                     .println("--------------startElement开始执行--------------------------");  
38.             System.out.println("uri:::" + uri);  
39.             System.out.println("localName:::" + localName);  
40.             System.out.println("qName:::" + qName);  
41.             for (int i = 0; i < attributes.getLength(); i++) {  
42.                 String value = attributes.getValue(i);// 获取属性的value值  
43.                 System.out.println(attributes.getQName(i) + "-----" + value);  
44.             }  
45.             System.out  
46.                     .println("------------------startElement执行完毕---------------------------");  
47.         }  
48.   
49.     }  
50. }  

3.程序运行的结果如下:

通过运行结果，希望你对uri,localName,qName有更加深入的了解.

二.我们通过SAXParserFactory、SAXParser、XMLReader完成,步骤如下

1.使用SAXParserFactory创建SAX解析工厂
SAXParserFactory spf = SAXParserFactory.newInstance();
2.通过SAX解析工厂得到解析器对象
SAXParser sp = spf.newSAXParser();
3.通过解析器对象得到一个XML的读取器
XMLReader xmlReader = sp.getXMLReader();
4.设置读取器的事件处理器
xmlReader.setContentHandler(new BookParserHandler());
5.解析xml文件
xmlReader.parse("book.xml");

说明：如果只是使用SAXParserFactory、SAXParser他们完成只需要如下3步骤

1.获取sax解析器的工厂对象
SAXParserFactory factory = SAXParserFactory.newInstance();
2.通过工厂对象 SAXParser创建解析器对象
SAXParser saxParser = factory.newSAXParser();
3.通过解析saxParser的parse()方法设定解析的文件和自己定义的事件处理器对象
saxParser.parse(new File("src//sax//sida.xml"), new MyDefaultHandler());

案例：解析出"作者"元素标签中的文本内容

1.需要解析的sida.xml文件

[html]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE 四大名著[  
3. <!ELEMENT 四大名著 (西游记,红楼梦)>  
4. <!ATTLIST 西游记 id ID #IMPLIED>  
5. ]>  
6. <四大名著>  
7.     <西游记 id="x001">  
8.         <作者>吴承恩</作者>  
9.     </西游记>  
10.     <红楼梦 id="x002">  
11.         <作者>曹雪芹</作者>  
12.     </红楼梦>  
13. </四大名著>  

2.解析测试类和事件处理器类的实现代码

[java]  view plain copy

1. package sax;  
2.   
3. import java.io.File;  
4.   
5. import javax.xml.parsers.SAXParser;  
6. import javax.xml.parsers.SAXParserFactory;  
7.   
8. import org.junit.Test;  
9. import org.xml.sax.Attributes;  
10. import org.xml.sax.SAXException;  
11. import org.xml.sax.helpers.DefaultHandler;  
12.   
13. public class SaxTest {  
14.   
15.     @Test  
16.     public void test() throws Exception {  
17.         // 1.获取sax解析器的工厂对象  
18.         SAXParserFactory factory = SAXParserFactory.newInstance();  
19.         // 2.通过工厂对象 SAXParser创建解析器对象  
20.         SAXParser saxParser = factory.newSAXParser();  
21.         // 3.通过解析saxParser的parse()方法设定解析的文件和自己定义的事件处理器对象  
22.         saxParser.parse(new File("src//sax//sida.xml"), new MyDefaultHandler());  
23.   
24.     }  
25.   
26.     // 自己定义的事件处理器  
27.     class MyDefaultHandler extends DefaultHandler {  
28.   
29.         // 解析标签开始及结束的的标识符  
30.         boolean isOk = false;  
31.   
32.         @Override  
33.         public void startElement(String uri, String localName, String qName,  
34.                 Attributes attributes) throws SAXException {  
35.             super.startElement(uri, localName, qName, attributes);  
36.             // 当解析作者元素开始的时候,设置isOK为true  
37.             if ("作者".equals(qName)) {  
38.                 isOk = true;  
39.             }  
40.         }  
41.   
42.         @Override  
43.         public void characters(char[] ch, int start, int length)  
44.                 throws SAXException {  
45.             // TODO Auto-generated method stub  
46.             super.characters(ch, start, length);  
47.             // 当解析的标识符为true时,打印元素的内容  
48.             if (isOk) {  
49.                 System.out.println(new String(ch, start, length));  
50.             }  
51.         }  
52.           
53.         @Override  
54.         public void endElement(String uri, String localName, String qName)  
55.                 throws SAXException {  
56.             super.endElement(uri, localName, qName);  
57.             // 当解析作者元素的结束的时候,设置isOK为false  
58.             if ("作者".equals(qName)) {  
59.                 isOk = false;  
60.             }  
61.         }  
62.   
63.     }  
64. }  

3.程序运行结果如下：

1.sax与Dom解析的区别

dom是w3c指定的一套规范标准，核心是按树形结构处理数据，dom解析器读入xml文件并在内存中建立一个结构一模一样的“树”，这树各节点和xml各标记对应，通过操纵此“树”来处理xml中的文件。xml文件很大时，建立的“树”也会大，所以会大量占用内存。sax解析器占内存少，效率高。sax解析器核心是事件处理机制。例如解析器发现一个标记的开始标记时，将所发现的数据会封装为一个标记开始事件，并把这个报告给事件处理器，事件处理器再调用方法（startElement）处理发现的数据。事件处理器可以自己编写也可以从父类继承。

上图中描述了SAX和DOM的不同。

SAX适于处理下面的问题：

1、对大型文件进行处理；

2、只需要文件夹的部分内容，或者只需从文件中得到特定信息。

3、想建立自己的对象模型的时候。

DOM适于处理下面的问题：

1、需要对文件进行修改；

2、需要随机对文件进行存取

2.如果用(二的解析方式解析web.xml)会有什么样的输出结果？