xml文件的sax解析

dom4j解析: http://blog.csdn.net/java4found/article/details/8665982

jdom解析:http://blog.csdn.net/java4found/article/details/8665365

dom解析:http://blog.csdn.net/java4found/article/details/8665034

       sax解析xml，采用事件处理方法，它的解析不需要完全加载完文件，可以避免了当xml文件过大时导致内存溢出的情况。sax解析主要包含两部分：解析器与事件处理器。

       java api中已经提供了创建sax解析器的方式。解析器只要解析到xml文档中的一个部分，就会调用事件处理器的某个方法。如下面的person.xml方件，当读到xml的开始，会触发事件处理器的startDocument()方法，当读到<persons>标签时，又会触发事件处理器的startElement()方法。事件处理器是由我们来完成的，都过不同的事件，执行不同的方法，就可以完成对xml文件的解析。

[html] view plaincopy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <persons>  
3.     <person id="328">  
4.         <name>zhangsan</name>  
5.         <age>23</age>  
6.     </person>  
7.     <person id="303">  
8.         <name>lisi</name>  
9.         <age>22</age>  
10.     </person>  
11. </persons>  

如何获取解析器?

     1、得到解析工厂。

     2、得到解析器。

     3、解析xml文件

如何获取事件处理器？

     方法1、实现ContentHandler接口，这个方法要实现很多事件处理方法，不是很方便。

     方法2、继承DefaultHandler类，查看源码可以看到，DefaultHandler实现了ContentHandler接口，只是对其方法空实现，所以我们只需要重写我们要处理的事件。

     

     常用事件：

     1、startDocument() 读到文档开始时触发事件。

     2、endDocument() 读到文档结束时触发事件。

     3、startElement() 读到标签开始时触发事件。

     4、endElement() 读到标签结束时触发事件。

     5、characters() 读到文档字符数据时触发事件。哪怕是空白区域，也会触发这个方法。

下面看一个例子，将上述person.xml保存项目src目录下，并读取后将内容封装成Person对象。

Person类：

[java] view plaincopy

1. public class Person {  
2.     private int id;  
3.     private String name;  
4.     private int age;  
5.   
6.     public int getId() {  
7.         return id;  
8.     }  
9.   
10.     public void setId(int id) {  
11.         this.id = id;  
12.     }  
13.   
14.     public String getName() {  
15.         return name;  
16.     }  
17.   
18.     public void setName(String name) {  
19.         this.name = name;  
20.     }  
21.   
22.     public int getAge() {  
23.         return age;  
24.     }  
25.   
26.     public void setAge(int age) {  
27.         this.age = age;  
28.     }  
29.   
30.     @Override  
31.     public int hashCode() {  
32.         final int prime = 31;  
33.         int result = 1;  
34.         result = prime * result + age;  
35.         result = prime * result + id;  
36.         result = prime * result + ((name == null) ? 0 : name.hashCode());  
37.         return result;  
38.     }  
39.   
40.     @Override  
41.     public boolean equals(Object obj) {  
42.         if (this == obj)  
43.             return true;  
44.         if (obj == null)  
45.             return false;  
46.         if (getClass() != obj.getClass())  
47.             return false;  
48.         Person other = (Person) obj;  
49.         if (age != other.age)  
50.             return false;  
51.         if (id != other.id)  
52.             return false;  
53.         if (name == null) {  
54.             if (other.name != null)  
55.                 return false;  
56.         } else if (!name.equals(other.name))  
57.             return false;  
58.         return true;  
59.     }  
60.   
61.     @Override  
62.     public String toString() {  
63.         return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";  
64.     }  
65.   
66.     public Person(int id, String name, int age) {  
67.         super();  
68.         this.id = id;  
69.         this.name = name;  
70.         this.age = age;  
71.     }  
72.   
73.     public Person() {  
74.         super();  
75.     }  
76. }  

sax解析：

[java] view plaincopy

1. import java.io.IOException;  
2. import java.io.InputStream;  
3. import java.util.ArrayList;  
4. import java.util.List;  
5. import javax.xml.parsers.ParserConfigurationException;  
6. import javax.xml.parsers.SAXParser;  
7. import javax.xml.parsers.SAXParserFactory;  
8. import org.xml.sax.Attributes;  
9. import org.xml.sax.SAXException;  
10. import org.xml.sax.helpers.DefaultHandler;  
11.   
12. public class SaxTest {  
13.   
14.     public static void main(String[] args) {  
15.         try {  
16.             //解析器的获取  
17.             //1、获取sax解析工厂  
18.             SAXParserFactory  sf = SAXParserFactory.newInstance();  
19.             //2、获取解析器  
20.             SAXParser sp = sf.newSAXParser();  
21.               
22.             //创建xml文件的输入流  
23.             InputStream inStream = SaxTest.class.getClassLoader()  
24.                     .getResourceAsStream("person.xml");  
25.             //3、解析xml文件，将事件处理器传入。  
26.             sp.parse(inStream, new PersonHandler());  
27.         } catch (ParserConfigurationException | SAXException e) {  
28.             e.printStackTrace();  
29.         } catch (IOException e) {  
30.             e.printStackTrace();  
31.         }  
32.     }  
33. }  
34.   
35. //事件处理器。  
36. class PersonHandler extends DefaultHandler {  
37.     private String currentTag;  
38.     private List<Person> persons = null;  
39.     private Person person = null;  
40.       
41.     //读到文档开始时触发的事件  
42.     public void startDocument() throws SAXException {  
43.         persons = new ArrayList<Person>();  
44.     }  
45.   
46.     //读到文档开始标签时触发的事件  
47.     public void startElement(String uri, String localName, String qName,  
48.             Attributes attributes) throws SAXException {  
49.         currentTag = qName;  
50.         System.out.println(qName);  
51.         if ("person".equals(qName)) {  
52.             person = new Person();  
53.             String id = attributes.getValue("id");  
54.             person.setId(Integer.parseInt(id));  
55.         }  
56.     }  
57.     //读到字符数据时触发的事件。  
58.     public void characters(char[] ch, int start, int length)  
59.             throws SAXException {  
60.         // if(currentTag.equals("name")) { 容易抛空指针异常  
61.         if ("name".equals(currentTag)) {  
62.             person.setName(new String(ch, start, length));  
63.         }  
64.         if ("age".equals(currentTag)) {  
65.             String age = new String(ch, start, length);  
66.             person.setAge(Integer.parseInt(age));  
67.         }  
68.     }  
69.     //读到结束标签时触发的事件。  
70.     public void endElement(String uri, String localName, String qName)  
71.             throws SAXException {  
72.         System.out.println(qName);  
73.         if ("person".equals(qName)) {  
74.             persons.add(person);  
75.             person = null;  
76.         }  
77.         currentTag = null;  
78.     }  
79.   
80.     public void endDocument() throws SAXException {  
81.         for (Person p : persons) {  
82.             System.out.println(p);  
83.         }  
84.     }  
85. }  

此处再介绍一下XMLReader的用法：

获取解释器之后，我们也可以获取它的XMLReader对象，该对象

1. 增加了查询和设置功能和属性的标准方法；
2. 增加了对名称空间的支持，这是许多高层的 XML 标准所必需的。 

具体方法如下。

[java] view plaincopy

1. //解析器的获取  
2. //1、获取sax解析工厂  
3. SAXParserFactory  sf = SAXParserFactory.newInstance();  
4. //2、获取解析器  
5. SAXParser sp = sf.newSAXParser();  
6. //得到读取器  
7. XMLReader reader = sp.getXMLReader();  
8. //设置读取器的事件处理器对象。  
9. reader.setContentHandler(new PersonHandler());  
10. //开始解析  
11. reader.parse("src/person.xml");