在Android平台上可以使用Simple API for XML(SAX) 、 Document Object Model(DOM)和Android附带的pull解析器解析XML文件。
下面是本例子要解析的XML文件：itcast.xml
[html] view plain copy
1. <?xml version="1.0" encoding="UTF-8"?>
2. <persons>
3. <person id="23">
4. <name>李明</name>
5. <age>30</age>
6. </person>
7. <person id="20">
8. <name>李向梅</name>
9. <age>25</age>
10. </person>
11. </persons>例子定义了一个javabean用于存放上面解析出来的xml内容， 这个javabean为Person，代码：
[java] view plain copy
1. public class Person {
2.
3. private Integer id;
4. private String name;
5. private Short age;
6.
7. public Integer getId() {
8. return id;
9. }
10.
11. public void setId(Integer id) {
12. this.id = id;
13. }
14.
15. public String getName() {
16. return name;
17. }
18.
19. public void setName(String name) {
20. = name;
21. }
22.
23. public Short getAge() {
24. return age;
25. }
26.
27. public void setAge(Short age) {
28. this.age = age;
29. }
30. }
1. SAX解析XML文件
SAX是一个解析速度快并且占用内存少的xml解析器，非常适合用于Android等移动设备。 SAX解析XML文件采用的是事件驱动，也就是说，它并不需要解析完整个文档，在按内容顺序解析文档的过程中，SAX会判断当前读到的字符是否合法XML语法中的某部分，如果符合就会触发事件。所谓事件，其实就是一些回调（callback）方法，这些方法(事件)定义在ContentHandler接口。
[java] view plain copy
1. public static List<Person> readXML(InputStream inStream) {
2. try {
3. //创建解析器
4. SAXParserFactory spf = SAXParserFactory.newInstance();
5. SAXParser saxParser = spf.newSAXParser();
6.
7. //设置解析器的相关特性，true表示开启命名空间特性
8. "http:///sax/features/namespaces",true);
9. new XMLContentHandler();
10. saxParser.parse(inStream, handler);
11. inStream.close();
12.
13. return handler.getPersons();
14. catch (Exception e) {
15. e.printStackTrace();
16. }
17.
18. return null;
19. }
20.
21.
22. //SAX类：DefaultHandler，它实现了ContentHandler接口。在实现的时候，只需要继承该类，重载相应的方法即可。
23. public class XMLContentHandler extends DefaultHandler {
24.
25. private List<Person> persons = null;
26. private Person currentPerson;
27. private String tagName = null;//当前解析的元素标签
28.
29. public List<Person> getPersons() {
30. return persons;
31. }
32.
33. //接收文档开始的通知。当遇到文档的开头的时候，调用这个方法，可以在其中做一些预处理的工作。
34. @Override
35. public void startDocument() throws SAXException {
36. new ArrayList<Person>();
37. }
38.
39. //接收元素开始的通知。当读到一个开始标签的时候，会触发这个方法。其中namespaceURI表示元素的命名空间；
40. //localName表示元素的本地名称（不带前缀）；qName表示元素的限定名（带前缀）；atts 表示元素的属性集合
41. @Override
42. public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
43.
44. if(localName.equals("person")){
45. new Person();
46. "id")));
47. }
48.
49. this.tagName = localName;
50. }
51.
52. //接收字符数据的通知。该方法用来处理在XML文件中读到的内容，第一个参数用于存放文件的内容，
53. //后面两个参数是读到的字符串在这个数组中的起始位置和长度，使用new String(ch,start,length)就可以获取内容。
54. @Override
55. public void characters(char[] ch, int start, int length) throws SAXException {
56.
57. if(tagName!=null){
58. new String(ch, start, length);
59. if(tagName.equals("name")){
60. this.currentPerson.setName(data);
61. else if(tagName.equals("age")){
62. this.currentPerson.setAge(Short.parseShort(data));
63. }
64. }
65. }
66.
67. //接收文档的结尾的通知。在遇到结束标签的时候，调用这个方法。其中，uri表示元素的命名空间；
68. //localName表示元素的本地名称（不带前缀）；name表示元素的限定名（带前缀）
69. @Override
70. public void endElement(String uri, String localName, String name) throws SAXException {
71.
72. if(localName.equals("person")){
73. persons.add(currentPerson);
74. null;
75. }
76.
77. this.tagName = null;
78. }
79. }2. DOM解析XML文件
DOM解析XML文件时，会将XML文件的所有内容读取到内存中，然后允许您使用DOM API遍历XML树、检索所需的数据。使用DOM操作XML的代码看起来比较直观，并且，在某些方面比基于SAX的实现更加简单。但是，因为DOM需要将XML文件的所有内容读取到内存中，所以内存的消耗比较大，特别对于运行Android的移动设备来说，因为设备的资源比较宝贵，所以建议还是采用SAX来解析XML文件，当然，如果XML文件的内容比较小采用DOM是可行的。
[java] view plain copy
1. public static List<Person> readXML(InputStream inStream) {
2.
3. new ArrayList<Person>();
4.
5. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
6.
7. try {
8. DocumentBuilder builder = factory.newDocumentBuilder();
9. Document dom = builder.parse(inStream);
10.
11. Element root = dom.getDocumentElement();
12.
13. "person");//查找所有person节点
14.
15. for (int i = 0; i < items.getLength(); i++) {
16. new Person();
17.
18. //得到第一个person节点
19. Element personNode = (Element) items.item(i);
20.
21. //获取person节点的id属性值
22. new Integer(personNode.getAttribute("id")));
23.
24. //获取person节点下的所有子节点(标签之间的空白节点和name/age元素)
25. NodeList childsNodes = personNode.getChildNodes();
26.
27. for (int j = 0; j < childsNodes.getLength(); j++) {
28. //判断是否为元素类型
29.
30. if(node.getNodeType() == Node.ELEMENT_NODE){
31. Element childNode = (Element) node;
32.
33. //判断是否name元素
34. if ("name".equals(childNode.getNodeName())) {
35. //获取name元素下Text节点,然后从Text节点获取数据
36. else if (“age”.equals(childNode.getNodeName())) {
37. new Short(childNode.getFirstChild().getNodeValue()));
38. }
39. }
40. }
41.
42. persons.add(person);
43. }
44.
45. inStream.close();
46. catch (Exception e) {
47. e.printStackTrace();
48. }
49.
50. return persons;
51. }
3.Pull解析器解析XML文件
Pull解析器的运行方式与 SAX 解析器相似。它提供了类似的事件，如：开始元素和结束元素事件，使用parser.next()可以进入下一个元素并触发相应事件。事件将作为数值代码被发送，因此可以使用一个switch对感兴趣的事件进行处理。当元素开始解析时，调用parser.nextText()方法可以获取下一个Text类型元素的值。
[java] view plain copy
1. //读取XML
2. public static List<Person> readXML(InputStream inStream) {
3.
4. XmlPullParser parser = Xml.newPullParser();
5.
6. try {
7. "UTF-8");
8. int eventType = parser.getEventType();
9.
10. null;
11. null;
12.
13. while (eventType != XmlPullParser.END_DOCUMENT) {
14. switch (eventType) {
15. case XmlPullParser.START_DOCUMENT://文档开始事件,可以进行数据初始化处理
16. new ArrayList<Person>();
17. break;
18.
19. case XmlPullParser.START_TAG://开始元素事件
20. String name = parser.getName();
21. if (name.equalsIgnoreCase("person")) {
22. new Person();
23. new Integer(parser.getAttributeValue(null, "id")));
24. else if (currentPerson != null) {
25. if (name.equalsIgnoreCase("name")) {
26. // 如果后面是Text元素,即返回它的值
27. else if (name.equalsIgnoreCase("age")) {
28. new Short(parser.nextText()));
29. }
30. }
31. break;
32.
33. case XmlPullParser.END_TAG://结束元素事件
34. if (parser.getName().equalsIgnoreCase("person") && currentPerson != null) {
35. persons.add(currentPerson);
36. null;
37. }
38.
39. break;
40. }
41.
42. eventType = parser.next();
43. }
44.
45. inStream.close();
46. return persons;
47. catch (Exception e) {
48. e.printStackTrace();
49. }
50.
51. return null;
52. }
53.
54.
55. //成XML文件
56. //使用Pull解析器生成一个与itcast.xml文件内容相同的myitcast.xml文件。
57. public static String writeXML(List<Person> persons, Writer writer){
58.
59. XmlSerializer serializer = Xml.newSerializer();
60.
61. try {
62. serializer.setOutput(writer);
63. "UTF-8", true);
64.
65. //第一个参数为命名空间,如果不使用命名空间,可以设置为null
66. "", "persons");
67.
68. for (Person person : persons){
69. "", "person");
70. "", "id", person.getId().toString());
71. "", "name");
72. serializer.text(person.getName());
73. "", "name");
74. "", "age");
75. serializer.text(person.getAge().toString());
76. "", "age");
77. "", "person");
78. }
79.
80. "", "persons");
81. serializer.endDocument();
82.
83. return writer.toString();
84. catch (Exception e) {
85. e.printStackTrace();
86. }
87.
88. return null;
89. }
90.
91.
92. //使用代码如下（生成XML文件）：
93.
94. File xmlFile = new File("myitcast.xml");
95. FileOutputStream outStream = new FileOutputStream(xmlFile);
96. OutputStreamWriter outStreamWriter = new OutputStreamWriter(outStream, "UTF-8");
97. BufferedWriter writer = new BufferedWriter(outStreamWriter);
98.
99. writeXML(persons, writer);
100. writer.flush();
101. writer.close();
102.
103.
104. //如果只想得到生成的xml内容，可以使用StringWriter：
105. StringWriter writer = new StringWriter();
106. writeXML(persons, writer);
107. String content = writer.toString();4.SAX和PULL使用
区别为：SAX解析器的工作方式是自动将事件推入事件处理器进行处理，因此你不能控制事件的处理主动结束；而Pull解析器的工作方式为允许你的应用程序代码主动从解析器中获取事件，正因为是主动获取事件，因此可以在满足了需要的条件后不再获取事件，结束解析。
你随便找个sax和pull的例子比较一下就可以发现，pull是一个while循环，随时可以跳出，而sax不是，sax是只要解析了，就必须解析完成。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
