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文件的解析。

 <?xml version="1.0" encoding="UTF-8"?>
 <persons>
     <person id="328">
         <name>zhangsan</name>
         <age>23</age>
     </person>
     <person id="303">
         <name>lisi</name>
         <age>22</age>
     </person>
 </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类：

 public class Person {
     private int id;
     private String name;
     private int age;

     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     @Override
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result + age;
         result = prime * result + id;
         result = prime * result + ((name == null) ? 0 : name.hashCode());
         return result;
     }

     @Override
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
         if (obj == null)
             return false;
         if (getClass() != obj.getClass())
             return false;
         Person other = (Person) obj;
         if (age != other.age)
             return false;
         if (id != other.id)
             return false;
         if (name == null) {
             if (other.name != null)
                 return false;
         } else if (!name.equals(other.name))
             return false;
         return true;
     }

     @Override
     public String toString() {
         return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
     }

     public Person(int id, String name, int age) {
         super();
         this.id = id;
         this.name = name;
         this.age = age;
     }

     public Person() {
         super();
     }
 }

sax解析：

 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.parsers.SAXParser;
 import javax.xml.parsers.SAXParserFactory;
 import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
 import org.xml.sax.helpers.DefaultHandler;

 public class SaxTest {

     public static void main(String[] args) {
         try {
             //解析器的获取
             //1、获取sax解析工厂
             SAXParserFactory  sf = SAXParserFactory.newInstance();
             //2、获取解析器
             SAXParser sp = sf.newSAXParser();

             //创建xml文件的输入流
             InputStream inStream = SaxTest.class.getClassLoader()
                     .getResourceAsStream("person.xml");
             //3、解析xml文件，将事件处理器传入。
             sp.parse(inStream, new PersonHandler());
         } catch (ParserConfigurationException | SAXException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

 //事件处理器。
 class PersonHandler extends DefaultHandler {
     private String currentTag;
     private List<Person> persons = null;
     private Person person = null;

     //读到文档开始时触发的事件
     public void startDocument() throws SAXException {
         persons = new ArrayList<Person>();
     }

     //读到文档开始标签时触发的事件
     public void startElement(String uri, String localName, String qName,
             Attributes attributes) throws SAXException {
         currentTag = qName;
         System.out.println(qName);
         if ("person".equals(qName)) {
             person = new Person();
             String id = attributes.getValue("id");
             person.setId(Integer.parseInt(id));
         }
     }
     //读到字符数据时触发的事件。
     public void characters(char[] ch, int start, int length)
             throws SAXException {
         // if(currentTag.equals("name")) { 容易抛空指针异常
         if ("name".equals(currentTag)) {
             person.setName(new String(ch, start, length));
         }
         if ("age".equals(currentTag)) {
             String age = new String(ch, start, length);
             person.setAge(Integer.parseInt(age));
         }
     }
     //读到结束标签时触发的事件。
     public void endElement(String uri, String localName, String qName)
             throws SAXException {
         System.out.println(qName);
         if ("person".equals(qName)) {
             persons.add(person);
             person = null;
         }
         currentTag = null;
     }

     public void endDocument() throws SAXException {
         for (Person p : persons) {
             System.out.println(p);
         }
     }
 }

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

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

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

具体方法如下。

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