解析XML三种方式（PULL、SAX、DOM）

本篇博客重点介绍Android中三种解析XML的方式，包括PULL、SAX、DOM，当然不止这些，还可以用第三方的jar包提供的解析，只是这三种在Android中比较常用吧。再顺便介绍一下AndroidTestCase的用法，用来测试所写的解析业务逻辑是否正确。

本篇博客使用的xml文件如下：

student.xml

[html]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>    
2. <students>    
3.     <student id="1003">    
4.         <name>ZhangSan</name>    
5.         <age>23</age>  
6.         <score>89</score>    
7.     </student>  
8.     <student id="1004">    
9.         <name>LiSi</name>    
10.         <age>24</age>  
11.         <score>72</score>    
12.     </student>  
13.     <student id="1005">    
14.         <name>WangWu</name>    
15.         <age>25</age>  
16.         <score>79</score>    
17.     </student>  
18. </students>  

各字体属性应该很清楚了，这里不再介绍，也不是重点。

此xml文件放在Android工程下面的assets目录下面，等待解析。。。

再建一个类Student.java

[java]  view plain copy

1. package com.and.xml;  
2.   
3. public class Student {  
4.   
5.     private int id;  
6.     private String name;  
7.     private int age;  
8.     private float score;  
9.   
10.     public Student() {  
11.         super();  
12.     }  
13.   
14.     public Student(int id, String name, int age, float score) {  
15.         super();  
16.         this.id = id;  
17.         this.name = name;  
18.         this.age = age;  
19.         this.score = score;  
20.     }  
21.   
22.     public int getId() {  
23.         return id;  
24.     }  
25.   
26.     public void setId(int id) {  
27.         this.id = id;  
28.     }  
29.   
30.     public String getName() {  
31.         return name;  
32.     }  
33.   
34.     public void setName(String name) {  
35.         this.name = name;  
36.     }  
37.   
38.     public int getAge() {  
39.         return age;  
40.     }  
41.   
42.     public void setAge(int age) {  
43.         this.age = age;  
44.     }  
45.   
46.     public float getScore() {  
47.         return score;  
48.     }  
49.   
50.     public void setScore(float score) {  
51.         this.score = score;  
52.     }  
53.   
54.     @Override  
55.     public String toString() {  
56.         // TODO Auto-generated method stub  
57.         return "Id:" + this.id + ",Name:" + this.name + ",Age" + this.age  
58.                 + ",Score:" + this.score;  
59.     }  
60. }  

下面分别介绍三种解析方式。

第一种：PULL解析

PullParseService

[java]  view plain copy

1. package com.and.xml;  
2.   
3. import java.io.InputStream;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6.   
7. import org.xmlpull.v1.XmlPullParser;  
8. import org.xmlpull.v1.XmlPullParserFactory;  
9. /** 
10.  * PULL解析示例 
11.  * @author Administrator 
12.  * 
13.  */  
14. public class PullParseService {  
15.     public static List<Student> getStudents(InputStream input) throws Exception {  
16.         List<Student> data = null;  
17.         Student stu = null;  
18.   
19.         XmlPullParserFactory fac = XmlPullParserFactory.newInstance();  
20.         fac.setNamespaceAware(true);  
21.         XmlPullParser parser = fac.newPullParser();  
22.         parser.setInput(input, "UTF-8");  
23.         int eventType = parser.getEventType();  
24.         while (eventType != XmlPullParser.END_DOCUMENT) {  
25.             switch (eventType) {  
26.             case XmlPullParser.START_DOCUMENT:  
27.                 System.out.println("START_DOCUMENT");  
28.                 data = new ArrayList<Student>();  
29.                 break;  
30.             case XmlPullParser.START_TAG:  
31.                 if ("student".equals(parser.getName())) {  
32.                     stu = new Student();  
33.                     stu.setId(Integer.parseInt(parser.getAttributeValue(0)));  
34.                 }  
35.                 if (stu != null) {  
36.                     if ("name".equals(parser.getName())) {  
37.                         stu.setName(parser.nextText());  
38.                     } else if ("age".equals(parser.getName())) {  
39.                         stu.setAge(Integer.parseInt(parser.nextText()));  
40.                     } else if ("score".equals(parser.getName())) {  
41.                         stu.setScore(Float.parseFloat(parser.nextText()));  
42.                     }  
43.                 }  
44.                 break;  
45.             case XmlPullParser.END_TAG:  
46.                 if ("student".equals(parser.getName())) {  
47.                     if (data != null && stu != null) {  
48.                         data.add(stu);  
49.                         stu = null;  
50.                     }  
51.                 }  
52.                 break;  
53.             }  
54.             eventType = parser.next();// 注意：此处勿要写成parser.next();不要理解成指针  
55.         }  
56.   
57.         return data;  
58.     }  
59. }  

至此，PULL解析的核心业务完成了，怎样来测试有没有问题呢？一般情况下，都是在Activity输出调试日志，根据调试日志判断是否解析成功。这里换一种方式，用Android的测试用例来测试一下。

TestParseService.java

[java]  view plain copy

1. package com.and.test;  
2.   
3. import java.io.InputStream;  
4. import java.util.List;  
5.   
6. import javax.xml.parsers.SAXParserFactory;  
7.   
8. import org.xml.sax.InputSource;  
9. import org.xml.sax.XMLReader;  
10.   
11. import com.and.xml.DomParseService;  
12. import com.and.xml.PullParseService;  
13. import com.and.xml.SaxParserService;  
14. import com.and.xml.Student;  
15.   
16. import android.test.AndroidTestCase;  
17. import android.util.Log;  
18.   
19. /** 
20.  * 测试三种解析方式（Pull、SAX、Dom） 
21.  *  
22.  * @author And 2012-02-29 
23.  */  
24. public class TestParseService extends AndroidTestCase {  
25.     private static final String TAG = "testService";  
26.     InputStream input;  
27.     List<Student> students;  
28.   
29.     public void init() throws Exception {  
30.         input = this.getContext().getAssets().open("students.xml");  
31.     }  
32.   
33.     // 测试Pull解析方式  
34.     public void testPull() throws Exception {  
35.         init();  
36.         students = PullParseService.getStudents(input);  
37.         for (Student stu : students) {  
38.             Log.i(TAG, stu.toString());  
39.         }  
40.     }  
41.   
42.     // 测试SAX解析方式  
43.     public void testSAX() throws Exception {  
44.         init();  
45.         SAXParserFactory fac = SAXParserFactory.newInstance();  
46.         XMLReader reader = fac.newSAXParser().getXMLReader();  
47.         SaxParserService saxHandler = new SaxParserService();  
48.         reader.setContentHandler(saxHandler);  
49.         reader.parse(new InputSource(input));  
50.         students = saxHandler.getParseData();  
51.         for (Student stu : students) {  
52.             Log.i(TAG, stu.toString());  
53.         }  
54.     }  
55.   
56.     // 测试DOM解析方式  
57.     public void testDom() throws Exception {  
58.         init();  
59.         students = DomParseService.getPersonsByParseXml(input);  
60.         for (Student stu : students) {  
61.             Log.i(TAG, stu.toString());  
62.         }  
63.     }  
64.   
65. }  

注意一定要继承自 AndroidTestCase 这个类。这个文件中写了所有三种解析的测试方法，其它的忽视吧，只看testPull方法，它是用来测试上面所写的PULL解析业务的 。

那么怎样测试呢？

鼠标选中testPull方法名——>右键——>Run As——>Anroid JUnit Test

会提示以下错误：

大概意思就是没有配置running tests.控制台输出：

XmlParseDemo does not specify a android.test.InstrumentationTestRunner instrumentation or does not declare uses-library android.test.runner in its AndroidManifest.xml

从上面的提示信息可知，需要在AndroidManifest.xml中作一些配置，包括instrumentation和uses-library的配置

在AndroidManifest.xml文件中添加如下两行

[html]  view plain copy

1. <instrumentation android:name="android.test.InstrumentationTestRunner" android:targetPackage="com.and.pull"></instrumentation>  

[html]  view plain copy

1. <uses-library android:name="android.test.runner"/>  

注意添加位置：

第一句跟application节点同级。

第二句跟activity同级。

上面介绍的方法是手动代码添加，下面介绍一种图形化的方式，只需要点击鼠标就可以搞定。

打开AndroidManifest.xml文件

点击Add...

这样，use-library就添加好了

同样的方法添加instrumentation属性

注意Target package后面的内容：com.and.xml包

整个工程目录结构如图：

然后查看一下AndroidManifest.xml的内容，已经包含了刚才添加的那两句了：

[html]  view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
3.     package="com.and.xml"  
4.     android:versionCode="1"  
5.     android:versionName="1.0" >  
6.   
7.     <uses-sdk android:minSdkVersion="7" />  
8.     <instrumentation android:targetPackage="com.and.test" android:name="android.test.InstrumentationTestRunner"></instrumentation>  
9.   
10.     <application  
11.         android:icon="@drawable/ic_launcher"  
12.         android:label="@string/app_name" >  
13.         <activity  
14.             android:label="@string/app_name"  
15.             android:name="com.and.xml.MainActivity" >  
16.             <intent-filter >  
17.                 <action android:name="android.intent.action.MAIN" />  
18.   
19.                 <category android:name="android.intent.category.LAUNCHER" />  
20.             </intent-filter>  
21.         </activity>  
22.         <uses-library android:name="android.test.runner"/>  
23.     </application>  
24.   
25. </manifest>  

OK，然后继续之前的操作“鼠标选中testPull方法名——>右键——>Run As——>Anroid JUnit Test”

如果出现类似这样的页面，就表示测试用例建立成功，并且测试方法通过

左上角的绿色条，表示测试方法通过，右下角的调试日志输出，通过判断可以知道解析成功。

第二种：SAX解析

SaxParserService.java

[java]  view plain copy

1. package com.and.xml;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. import org.xml.sax.Attributes;  
7. import org.xml.sax.SAXException;  
8. import org.xml.sax.helpers.DefaultHandler;  
9.   
10. /** 
11.  * SAX解析示例 
12.  *  
13.  * @author Administrator 
14.  *  
15.  */  
16. public class SaxParserService extends DefaultHandler {  
17.   
18.     List<Student> data = null;  
19.     Student stu = null;  
20.     String tag = "";  
21.   
22.     @Override  
23.     public void characters(char[] ch, int start, int length) throws SAXException {  
24.         super.characters(ch, start, length);  
25.         if (stu != null) {  
26.             String str = new String(ch, start, length);  
27.             if (tag.equals("name")) {  
28.                 stu.setName(str);  
29.             } else if (tag.equals("age")) {  
30.                 stu.setAge(Integer.parseInt(str));  
31.             } else if (tag.equals("score")) {  
32.                 stu.setScore(Float.parseFloat(str));  
33.             }  
34.         }  
35.     }  
36.   
37.     @Override  
38.     public void endDocument() throws SAXException {  
39.         super.endDocument();  
40.     }  
41.   
42.     @Override  
43.     public void endElement(String uri, String localName, String qName)  
44.             throws SAXException {  
45.         super.endElement(uri, localName, qName);  
46.         if (localName.equals("student") && stu != null) {  
47.             data.add(stu);  
48.             stu = null;  
49.         }  
50.         tag = "";  
51.     }  
52.   
53.     @Override  
54.     public void startDocument() throws SAXException {  
55.         super.startDocument();  
56.         data = new ArrayList<Student>();  
57.     }  
58.   
59.     @Override  
60.     public void startElement(String uri, String localName, String qName,  
61.             Attributes attributes) throws SAXException {  
62.         super.startElement(uri, localName, qName, attributes);  
63.         tag = localName;  
64.         if (localName.equals("student")) {  
65.             stu = new Student();  
66.         }  
67.         if (attributes.getValue(0) != null) {  
68.             stu.setId(Integer.parseInt(attributes.getValue(0)));  
69.         }  
70.     }  
71.   
72.     public List<Student> getParseData() {  
73.         return data;  
74.     }  
75.   
76. }  

注意一定要继承自DefaultHandler，然复写里面的方法，这些方法名字根据字面意思很容易理解它的作用。

然后通过上面的的测试文件，按照类似的方法测试一下testSAX()方法，如果出现绿条和日志输出的话，表明解析业务逻辑成功。

第三种：DOM解析

DomParseService.java

[java]  view plain copy

1. package com.and.xml;  
2.   
3. import java.io.InputStream;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6. import javax.xml.parsers.DocumentBuilder;  
7. import javax.xml.parsers.DocumentBuilderFactory;  
8. import org.w3c.dom.Document;  
9. import org.w3c.dom.Element;  
10. import org.w3c.dom.Node;  
11. import org.w3c.dom.NodeList;  
12.   
13. /** 
14.  * DOM解析示例 
15.  */  
16. /** 
17.  * DOM解析器在解析XML文档时，会把文档中的所有元素，按照其出现的层次关系，解析成一个个Node对象(节点)。Node对象提供了一系列常量来代表结点的类型 
18.  * ，当开发人员获得某个Node类型后，就可以把Node节点转换成相应节点对象(Node的子类对象)，以便于调用其特有的方法。 
19.  * Node对象提供了相应的方法去获得它的父结点或子结点。编程人员通过这些方法就可以读取整个XML文档的内容、或添加、修改、删除XML文档的内容. 
20.  *  
21.  * 缺点： 一次性的完全加载整个xml文件，需要消耗大量的内存。 
22.  */  
23. public class DomParseService {  
24.   
25.     public static List<Student> getPersonsByParseXml(InputStream is) throws Exception {  
26.         List<Student> persons = new ArrayList<Student>();  
27.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
28.         try {  
29.             DocumentBuilder builder = factory.newDocumentBuilder();  
30.             Document document = builder.parse(is);  
31.             Element root = document.getDocumentElement();  
32.             NodeList items = root.getElementsByTagName("student");// 得到所有person节点  
33.             for (int i = 0; i < items.getLength(); i++) {  
34.                 Student Student = new Student();  
35.                 Element personNode = (Element) items.item(i);  
36.                 Student.setId(new Integer(personNode.getAttribute("id")));  
37.                 // 获取person节点下的所有子节点(标签之间的空白节点和name/age元素)  
38.                 NodeList childsNodes = personNode.getChildNodes();  
39.                 for (int j = 0; j < childsNodes.getLength(); j++) {  
40.                     Node node = (Node) childsNodes.item(j); // 判断是否为元素类型  
41.                     if (node.getNodeType() == Node.ELEMENT_NODE) {  
42.                         Element childNode = (Element) node;  
43.                         // 判断是否name元素  
44.                         if ("name".equals(childNode.getNodeName())) {  
45.                             // 获取name元素下Text节点,然后从Text节点获取数据  
46.                             Student.setName(childNode.getFirstChild().getNodeValue());  
47.                         } else if ("age".equals(childNode.getNodeName())) {  
48.                             Student.setAge(new Short(childNode.getFirstChild().getNodeValue()));  
49.                         } else if ("score".equals(childNode.getNodeName())) {  
50.                             Student.setScore(Float.parseFloat(childNode.getFirstChild().getNodeValue()));  
51.                         }  
52.                     }  
53.                 }  
54.                 persons.add(Student);  
55.             }  
56.             is.close();  
57.         } catch (Exception e) {  
58.             e.printStackTrace();  
59.         }  
60.         return persons;  
61.     }  
62. }  

类似的测试方法。。。

至此，三种解析方式全部完成了，如果分别测试这三种方法的时候，一路绿条的话，那么恭喜，解析业务逻辑成功。否则，可能还有哪里有问题，请仔细检查。

对比这三种解析方式，我个人认为PULL和SAX解析方式类似，都是事件触发型的，就是当解析到某个节点的时候触发相应的事件。说明一下DOM解析，会把文档中的所有元素，按照其出现的层次关系，解析成一个个Node对象(节点)，可见它会有点占内存，但是如果待解析的xml文件相对较小的话，使用DOM解析 优点还是很明确的。