Android用Sax，Pull，Dom解析xml

Android解析xml的三种方式。分别有Sax，Pull，Dom。

来看他们各是怎么实现的。

这是项目结构：

解析文件为Person.xml:

 1 <?xml version="1.0" encoding="UTF-8"?>

 2 <persons>

 3     <person id="1">

 4         <name>cxa</name>

 5         <age>30</age>

 6     </person>

 7     <person id="2">

 8         <name>acs</name>

 9         <age>25</age>

10     </person>

11     <person id="3">

12         <name>hgf</name>

13         <age>30</age>

14     </person>

15     <person id="4">

16         <name>rty</name>

17         <age>25</age>

18     </person>

19     <person id="5">

20         <name>gfj</name>

21         <age>30</age>

22     </person>

23     <person id="6">

24         <name>qty</name>

25         <age>25</age>

26     </person>

27     <person id="7">

28         <name>bdf</name>

29         <age>30</age>

30     </person>

31     <person id="8">

32         <name>liu</name>

33         <age>25</age>

34     </person>

35 </persons> 

分别来看各个文件实现。

XmlParserActivity.java:

 1 package com.jayce.xmlparser;

 2 

 3 import java.io.InputStream;

 4 import java.util.List;

 5 

 6 import android.app.Activity;

 7 import android.os.Bundle;

 8 import android.util.Log;

 9 

10 public class XmlParserActivity extends Activity {

11     private static final String TAG = "XmlParserActivity";

12     

13     /** Called when the activity is first created. */

14     @Override

15     public void onCreate(Bundle savedInstanceState) {

16         super.onCreate(savedInstanceState);

17         setContentView(R.layout.main);

18         InputStream in = this.getResources().openRawResource(R.raw.person);

19         List<Person> person = Pull.readXML(in);

20         if(null != person)

21         {

22             for(int i = 0; i < person.size(); i++)

23             {

24                 Log.i(TAG, "index:" + i);

25                 Person p = person.get(i);

26                 Log.i(TAG, "id:" + p.getID());

27                 Log.i(TAG, "name:" + p.getName());

28                 Log.i(TAG, "age:" + p.getAge());

29             }

30         }

31     }

32 }

Person.java:

 1 package com.jayce.xmlparser;

 2 

 3 public class Person

 4 {

 5     private Integer mID;

 6     private String mName;

 7     private Short mAge;

 8     

 9     public Integer getID()

10     {

11         return mID;

12     }

13     

14     public void setID(Integer id)

15     {

16         this.mID = id;

17     }

18     

19     public String getName()

20     {

21         return mName;

22     }

23     

24     public void setName(String name)

25     {

26         this.mName = name;

27     }

28     

29     public Short getAge()

30     {

31         return mAge;

32     }

33     

34     public void setAge(Short age)

35     {

36         this.mAge = age;

37     }

38 }

Sax.java:

 1 package com.jayce.xmlparser;

 2 

 3 import java.io.IOException;

 4 import java.io.InputStream;

 5 import java.util.ArrayList;

 6 import java.util.List;

 7 

 8 import javax.xml.parsers.ParserConfigurationException;

 9 import javax.xml.parsers.SAXParser;

10 import javax.xml.parsers.SAXParserFactory;

11 

12 import org.xml.sax.Attributes;

13 import org.xml.sax.SAXException;

14 import org.xml.sax.helpers.DefaultHandler;

15 

16 public class Sax

17 {

18     public static List<Person> readXML(InputStream in)

19     {

20         SAXParserFactory spf = SAXParserFactory.newInstance();

21         try {

22             SAXParser saxParser = spf.newSAXParser();

23             //saxParser.setProperty("http://xml.org/sax/features/namespaces", true);

24             //saxParser.setProperty("http://xml.org/sax/features/namespace-prefixes", false);

25             XMLContentHandler handler = new XMLContentHandler();

26             saxParser.parse(in, handler);

27             in.close();

28             return handler.getPersons();

29         } catch (ParserConfigurationException e) {

30             // TODO Auto-generated catch block

31             e.printStackTrace();

32         } catch (SAXException e) {

33             // TODO Auto-generated catch block

34             e.printStackTrace();

35         } catch (IOException e) {

36             // TODO Auto-generated catch block

37             e.printStackTrace();

38         }

39         return null;

40     }

41 }

42 

43 class XMLContentHandler extends DefaultHandler

44 {

45     private List<Person> persons = null;

46     private Person currentPerson;

47     private String tagName = null;

48     

49     public List<Person> getPersons()

50     {

51         return persons;

52     }

53     

54     public void startDocument() throws SAXException

55     {

56         persons = new ArrayList<Person>();

57     }

58     

59     public void characters(char[] ch, int start, int length)

60     {

61         if(null != tagName)

62         {

63             String data = new String(ch, start, length);

64             if(tagName.equalsIgnoreCase("name"))

65             {

66                 this.currentPerson.setName(data);

67             }

68             else if(tagName.equalsIgnoreCase("age"))

69             {

70                 this.currentPerson.setAge(new Short(data));

71             }

72         }

73     }

74     

75     public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException

76     {

77         this.tagName = localName;

78         if(tagName.equalsIgnoreCase("person"))

79         {

80             currentPerson = new Person();

81             currentPerson.setID(new Integer(atts.getValue("id")));

82         }

83     }

84     

85     public void endElement(String uri, String localName, String name) throws SAXException

86     {

87         if(localName.equalsIgnoreCase("person"))

88         {

89             persons.add(currentPerson);

90             currentPerson = null;

91         }

92         this.tagName = null;

93     }

94 }

Pull.java:

 1 package com.jayce.xmlparser;

 2 

 3 import java.io.IOException;

 4 import java.io.InputStream;

 5 import java.util.ArrayList;

 6 import java.util.List;

 7 

 8 import org.xmlpull.v1.XmlPullParser;

 9 import org.xmlpull.v1.XmlPullParserException;

10 

11 import android.util.Xml;

12 

13 public class Pull

14 {

15     public static List<Person> readXML(InputStream in)

16     {

17         XmlPullParser parser = Xml.newPullParser();

18         

19         try {

20             parser.setInput(in, "UTF-8");

21             int eventType = parser.getEventType();

22             Person currentPerson = null;

23             List<Person> persons = null;

24             while(eventType != XmlPullParser.END_DOCUMENT)

25             {

26                 switch(eventType)

27                 {

28                     case XmlPullParser.START_DOCUMENT:

29                     {

30                         persons = new ArrayList<Person>();

31                     }

32                     break;

33                     case XmlPullParser.START_TAG:

34                     {

35                         String tag = parser.getName();

36                         if(tag.equalsIgnoreCase("person"))

37                         {

38                             currentPerson = new Person();

39                             currentPerson.setID(new Integer(parser.getAttributeValue(null, "id")));

40                         }

41                         else if(currentPerson != null)

42                         {

43                             if(tag.equalsIgnoreCase("name"))

44                             {

45                                 currentPerson.setName(parser.nextText());

46                             }

47                             else if(tag.equalsIgnoreCase("age"))

48                             {

49                                 currentPerson.setAge(new Short(parser.nextText()));

50                             }

51                         }

52                     }

53                     break;

54                     case XmlPullParser.END_TAG:

55                     {

56                         if(parser.getName().equalsIgnoreCase("person") && null != currentPerson)

57                         {

58                             persons.add(currentPerson);

59                             currentPerson = null;

60                         }

61                     }

62                     break;

63                 }

64                 eventType = parser.next();

65             }

66             in.close();

67             return persons;

68         } catch (XmlPullParserException e) {

69             // TODO Auto-generated catch block

70             e.printStackTrace();

71         } catch (IOException e) {

72             // TODO Auto-generated catch block

73             e.printStackTrace();

74         }

75         

76         return null;

77     }

78 }

Dom.java:

 1 package com.jayce.xmlparser;

 2 

 3 import java.io.IOException;

 4 import java.io.InputStream;

 5 import java.util.ArrayList;

 6 import java.util.List;

 7 

 8 import javax.xml.parsers.DocumentBuilder;

 9 import javax.xml.parsers.DocumentBuilderFactory;

10 import javax.xml.parsers.ParserConfigurationException;

11 

12 import org.w3c.dom.Document;

13 import org.w3c.dom.Element;

14 import org.w3c.dom.Node;

15 import org.w3c.dom.NodeList;

16 import org.xml.sax.SAXException;

17 

18 public class Dom

19 {

20     public static List<Person> readXML(InputStream in)

21     {

22         List<Person> persons = new ArrayList<Person>();

23         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

24         try {

25             DocumentBuilder builder = factory.newDocumentBuilder();

26             Document dom = builder.parse(in);

27             Element root = dom.getDocumentElement();

28             NodeList items = root.getElementsByTagName("person");

29             for(int i = 0; i < items.getLength(); i++)

30             {

31                 Person person = new Person();

32                 Element personNode = (Element)items.item(i);

33                 person.setID(new Integer(personNode.getAttribute("id")));

34                 NodeList childsNodes = personNode.getChildNodes();

35                 for(int j = 0; j < childsNodes.getLength(); j++)

36                 {

37                     Node node = (Node)childsNodes.item(j);

38                     if(Node.ELEMENT_NODE == node.getNodeType())

39                     {

40                         if("name".equalsIgnoreCase(node.getNodeName()))

41                         {

42                             person.setName(node.getFirstChild().getNodeValue());

43                         }

44                         else  if("age".equalsIgnoreCase(node.getNodeName()))

45                         {

46                             person.setAge(new Short(node.getFirstChild().getNodeValue()));

47                         }

48                     }

49                 }

50                 persons.add(person);

51             }

52             in.close();

53         } catch (ParserConfigurationException e) {

54             // TODO Auto-generated catch block

55             e.printStackTrace();

56         } catch (IOException e) {

57             // TODO Auto-generated catch block

58             e.printStackTrace();

59         } catch (SAXException e) {

60             // TODO Auto-generated catch block

61             e.printStackTrace();

62         }

63         return persons;

64     }

65 }