|
本文主要讲解Android开发中如何对XML文件的解析，由于XML文件具有与平台无关，广泛应用于数据通信中，因此解析XML文件就显得很有意义。Android对XML文件解析的方法主要有3种。
通常有三种方式:DOM、SAX和PULL，下面就分别针对这三种方式来进行讨论。
假设我们在开发天气预报应用程序的时候，使用google给我们提供的API，以及天气预报数据，例如我们要获得北京当前的天气预报数据，即可在浏览器中输入如下地址：http://www.google.com/ig/api?&weather=beijing。
则可以看到一个XML文件展现在我们面前，对于此XML文件Google给我们的说明是：
“This XML file does not appear to have
any style informationassociated with it. The document
tree is shown below”.即此XML文件没有任何样式信息，只有文档结构树的显示。
文件内容如下所示：
|
<xml_api_reply version="1">
<weather module_id="0" tab_id="0" mobile_row="0" mobile_zipped="1" row="0" section="0">
<forecast_information>
<city data="Beijing, Beijing"/>
<postal_code data="beijing"/>
<latitude_e6 data=""/>
<longitude_e6 data=""/>
<forecast_date data="2012-07-24"/>
<current_date_time data="2012-07-24 15:30:00 +0000"/>
<unit_system data="SI"/>
</forecast_information>
<current_conditions>
<condition data="多云"/>
<temp_f data="77"/>
<temp_c data="25"/>
<humidity data="湿度： 78%"/>
<icon data="/ig/images/weather/cn_cloudy.gif"/>
<wind_condition data="风向： 东北、风速：2 米/秒"/>
</current_conditions>
<forecast_conditions>
<day_of_week data="周二"/>
<low data="22"/>
<high data="30"/>
<icon data="/ig/images/weather/cn_cloudy.gif"/>
<condition data="多云"/>
</forecast_conditions>
<forecast_conditions>
<day_of_week data="周三"/>
<low data="24"/>
<high data="30"/>
<icon data="/ig/images/weather/chance_of_rain.gif"/>
<condition data="可能有雨"/>
</forecast_conditions>
<forecast_conditions>
<day_of_week data="周四"/>
<low data="25"/>
<high data="29"/>
<icon data="/ig/images/weather/thunderstorm.gif"/>
<condition data="雷阵雨"/>
</forecast_conditions>
<forecast_conditions>
<day_of_week data="周五"/>
<low data="24"/>
<high data="31"/>
<icon data="/ig/images/weather/chance_of_storm.gif"/>
<condition data="可能有暴风雨"/>
</forecast_conditions>
</weather>
</xml_api_reply> |
那么，我们要从中获取到天气的信息，就是要对此XML文件做解析。下面我们就分别用DOM,SAX和PULL三种方式，分别对此XML文件做解析。
DOM方式
DOM方式解析xml是先把xml文档都读到内存中，然后再用DOM API来访问树形结构，并获取数据。由DOM解析的方式可以知道，如果XML文件很大的时候，处理效率就会变得比较低，这也是DOM方式的一个缺点。
现在我们来解析上文中提到的有关天气预报信息相关的xml文件。什么是解析呢？说的通俗一点，就是将这个带标签的XML文件识别出来，并抽取一些相关的，对我们有用的信息来给我们使用。那在这个文件里，时间，天气，温度，以及图标对我们来说是需要得到的。我们要对其做解析。
解析的具体思路是：
1. 将XML文件加载进来。
2. 获取文档的根节点
3. 获取文档根节点中所有子节点的列表
4. 获取子节点列表中需要读取的节点信息
根据这4个步骤，我们进行开发：
首先就是如何加载XML文件，假设此文件来源于网络。
|
String url = "http://www.google.com/ig/api?&weather=beijing";
DefaultHttpClient client = new DefaultHttpClient();
HttpUriRequest req = new HttpGet(url);
HttpResponse resp = client.execute(req);
HttpEntity ent = resp.getEntity();
InputStream stream = ent.getContent();
DocumentBuilder myDocBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document myDoc = myDocBuilder.parse(new InputSource(stream)); |
首先创建一个DocumentBuilderFactory实例
然后加载XML文档（Document）
加载完毕以后，就要进行节点获取操作，即第二步和第三步的操作：
|
//找到根Element
Element root=document.getDocumentElement();
//找到子节点forecast_conditions
NodeList nodes=root.getElementsByTagName(forecast_conditions); |
假设我需要获得该XML文件中周三的最高气温，则可以用下列代码得到：
|
nodes.item(1).getChildNodes().item(2).getAttributes().item(0).getNodeValue(); |
nodes.item(1)表示包含标签forecast_conditions的第二个节点，从0开始计数。getChildNodes().item(2)表示获取标签forecast_conditions子节点的第三个条目节点，即high节点。.getAttributes().item(0)表示high节点的第一个属性，即data，最后的getNodeValue()表示得到此属性的属性值。
SAX方式
SAX是Simple API for XML的缩写。是一个包也可以看成是一些接口。
相比于DOM而言SAX是一种速度更快，更有效，占用内存更少的解析XML文件的方法。它是逐行扫描，可以做到边扫描边解析，因此SAX可以在解析文档的任意时刻停止解析。非常适用于Android等移动设备。
SAX是基于事件驱动的。所谓事件驱动就是说，它不用解析完整个文档，在按内容顺序解析文档过程中，SAX会判断当前读到的字符是否符合XML文件语法中的某部分。如果符合某部分，则会触发事件。所谓触发事件，就是调用一些回调方法。当然android的事件机制是基于回调方法的，在用SAX解析xml文档时候，在读取到文档开始和结束标签时候就会回调一个事件，在读取到其他节点与内容时候也会回调一个事件。在SAX接口中，事件源是org.xml.sax包中的XMLReader，它通过parser()方法来解析XML文档，并产生事件。事件处理器是org.xml.sax包中ContentHander、DTDHander、ErrorHandler，以及EntityResolver这4个接口。
这四个接口的详细说明如下：
| 事件处理器名称 |
事件处理器处理的事件 |
XMLReader注册方法 |
| ContentHander |
XML文档的开始与结束，
XML文档标签的开始与结束，接收字符数据，跳过实体，接收元素内容中可忽略的空白等。 |
setContentHandler(ContentHandler
h) |
| DTDHander |
处理DTD解析时产生的相应事件 |
setDTDHandler(DTDHandler h) |
| ErrorHandler |
处理XML文档时产生的错误 |
setErrorHandler(ErrorHandler h) |
| EntityResolver |
处理外部实体 |
setEntityResolver(EntityResolver e) |
我们用来做内容解析的回调方法一般都定义在ContentHandler接口中。
ContentHandler接口常用的方法：
startDocument()
当遇到文档的开头的时候，调用这个方法，可以在其中做一些预处理的工作。
endDocument()
当文档结束的时候，调用这个方法，可以在其中做一些善后的工作。
startElement(String namespaceURI, String localName,String
qName, Attributes atts)
当读到开始标签的时候，会调用这个方法。namespaceURI就是命名空间，localName是不带命名空间前缀的标签名，qName是带命名空间前缀的标签名。通过atts可以得到所有的属性名和相应的值。
endElement(String uri, String localName, String name)
在遇到结束标签的时候，调用这个方法。
characters(char[] ch, int start, int length)
这个方法用来处理在XML文件中读到的内容。例如：<high data="30"/>主要目的是获取high标签中的值。
第一个参数用于存放文件的内容，后面两个参数是读到的字符串在这个数组中的起始位置和长度，使用new String(ch,start,length)就可以获取内容。
注意：
SAX的一个重要特点就是它的流式处理，当遇到一个标签的时候，它并不会纪录下之前所碰到的标签，即在startElement()方法中，所有能够知道的信息，就是标签的名字和属性，至于标签的嵌套结构，上层标签的名字，是否有子元属等等其它与结构相关的信息，都是不知道的，都需要你的程序来完成。这使得SAX在编程处理上没有DOM方便。
现在我们截取一段XML文件来做解析，其调用方法是这样的：
|
<?xml version="1.0"?> ----------> startDocument()
<weather> ----------> startElement
<forecast_information> ----------> startElement
<city> ----------> startElement
beijing ----------> characters
</city> ----------> endElement
</forecast_information > ----------> endElement
</weather > ----------> endElement
文档结束 ----------> endDocument() |
SAX的解析步骤：
首先需要注意的是：
SAX还为其制定了一个Helper类：DefaultHandler它实现了ContentHandler这个接口，但是其所有的方法体都为空，在实现的时候，你只需要继承这个类，然后重载相应的方法即可。
使用SAX解析XML文件一般有以下五个步骤：
1、创建一个SAXParserFactory对象；
2、调用SAXParserFactory中的newSAXParser方法创建一个SAXParser对象；
3、然后在调用SAXParser中的getXMLReader方法获取一个XMLReader对象；
4、实例化一个DefaultHandler对象
5、连接事件源对象XMLReader到事件处理类DefaultHandler中
6、调用XMLReader的parse方法从输入源中获取到的xml数据
7、通过DefaultHandler返回我们需要的数据集合。
我们仍然来解析上述那个天气预报的XML文件。
编写代码如下：
|
01.mySAX.setOnClickListener(new Button.OnClickListener(){
02. @Override
03. public void onClick(View v) {
04. try{
05. String url = "http://www.google.com/ig/api?&weather=beijing";
06. DefaultHttpClient client = new DefaultHttpClient();
07. HttpUriRequest req = new HttpGet(url);
08. HttpResponse resp = client.execute(req);
09. HttpEntity ent = resp.getEntity();
10. InputStream stream = ent.getContent(); //将文件导入流，因此用InputStream
11.
12. SAXParserFactory saxFactory = SAXParserFactory.newInstance(); //获取一个对象
13. SAXParser saxParser = saxFactory.newSAXParser();//利用获取到的对象创建一个解析器
14. XMLContentHandler handler = new XMLContentHandler();//设置defaultHandler
15. saxParser.parse(stream, handler);//进行解析
16. stream.close();//关闭流
17. /*XMLReader xmlReader = saxFactory.newSAXParser().getXMLReader(); //获取一个XMLReader
18. xmlReader.setContentHandler(handler);
19. xmlReader.parse(new InputSource(stream));
20. stream.close();*/
21. }catch(Exception e){
22. e.printStackTrace();
23. }
24. }
25. });
26. }
27. public class XMLContentHandler extends DefaultHandler {
28. private static final String TAG = "XMLContentHandler";
29.
30. @Override
31. public void characters(char[] ch, int start, int length)
32. throws SAXException {
33. Log.i(TAG, "解析内容："+new String(ch,start,length));
34. }
35. @Override
36. public void endDocument() throws SAXException {
37. super.endDocument();
38. Log.i(TAG, "文档解析完毕。");
39. }
40. @Override
41. public void endElement(String uri, String localName, String qName)
42. throws SAXException {
43. Log.i(TAG, localName+"解析完毕");
44. }
45. @Override
46. public void startDocument() throws SAXException {
47. Log.i(TAG, "开始解析... ...");
48. }
49. @Override
50. public void startElement(String uri, String localName, String qName,
51. Attributes attributes) throws SAXException {
52. Log.i(TAG, "解析元素："+localName);
53.
54. if(localName.equals("high")){
55. Log.i(TAG, "解析元素："+localName);
56. i++;
57. if(i==2){
58. highestTmp.setText(String.valueOf((Integer.parseInt
(attributes.getValue(0))-32)*5/9));
59. }
60. }
61. }
62. } |
上面的那段注释：
|
01./*XMLReader xmlReader =saxFactory.newSAXParser().getXMLReader(); //获取一个XMLReader
02. xmlReader.setContentHandler(handler);
03.xmlReader.parse(newInputSource(stream));
04.stream.close();*/ |
是用XMLReader来做解析的另外一种方法。效果是一样的。这里可以传流，也可以传一个字符串，如下所示：是传字符串。
|
xmlReader.parse(new InputSource(new StringReader(xmlStr))); |
PULL方式
除了可以使用 SAX和DOM解析XML文件，也可以使用Android内置的Pull解析器解析XML文件。
Pull解析器的运行方式与 SAX 解析器相似。它也是事件触发的。Pull解析方式让应用程序完全控制文档该怎么样被解析。比如开始和结束元素事件，使用parser.next()可以进入下一个元素并触发相应事件。通过Parser.getEventType()方法来取得事件的代码值，解析是在开始时就完成了大部分处理。事件将作为数值代码被发送，因此可以使用一个switch对感兴趣的事件进行处理。
Pull解析是一个遍历文档的过程，每次调用next()，nextTag(),
nextToken()和nextText()都会向前推进文档，并使Parser停留在某些事件上面，但是不能倒退。然后把文档设置给Parser。
Android中对Pull方法提供了支持的API，主要是
org.xmlpull.v1.XmlPullParser;
org.xmlpull.v1.XmlPullParserFactory;
二个类，其中主要使用的是XmlPullParser，XmlPullParserFactory是一个工厂，用于构建XmlPullParser对象。
应用程序通过调用XmlPullParser.next()等方法来产生Event，然后再处理Event。
我们仍然拿上述天气预报的XML文件的一部分来做例子。
例如：需要解析的XML文件是：
|
<forecast_conditions>
<day_of_week data="周三"/>
<low data="22"/>
<high data="29"/>
<icon data="/ig/images/weather/chance_of_rain.gif"/>
<condition data="可能有雨"/>
</forecast_conditions> |
这部分XML文件中day_of_week,low,high等是TAG，data是ATTRIBUTEA。当然，如果有<></>夹在开始和结束符号之间的部分，则为TXET。
要想解析文档先要构建一个XmlPullParser对象。
|
final XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
factory.setNamespaceAware(true);
final XmlPullParser parser = factory.newPullParser();
parser.setInput(new StringReader("xmlStr"); |
这里的xmlStr就是上边的XML文件。
此时，文档刚被初始化，所以它应该位于文档的开始，事件为START_DOCUMENT，可以通过XmlPullParser.getEventType()来获取。然后调用next()会产生
START_TAG，这个事件告诉应用程序一个标签已经开始了，调用getName()会返回" day_of_week
";若有TEXT，则再next()会产生TEXT事件，调用getText()会返回TEXT，由于此处没有，所以再next()，会产生END_TAG，这个告诉你一个标签已经处理完了，再next()直到最后处理完TAG，会产生END_DOCUMENT，它告诉你整个文档已经处理完成了。除了next()外，nextToken()也可以使用，只不过它会返回更加详细的事件，比如COMMENT,
CDSECT, DOCDECL, ENTITY等等非常详细的信息。如果程序得到比较底层的信息，可以用nextToken()来驱动并处理详细的事件。需要注意一点的是TEXT事件是有可能返回空白的White
Spaces比如换行符或空格等。
nextTag()--会忽略White Spaces，如果可以确定下一个是START_TAG或END_TAG，就可以调用nextTag()直接跳过去。通常它有二个用处：当START_TAG时，如果能确定这个TAG含有子TAG，那么就可以调用nextTag()产生子标签的START_TAG事件；当END_TAG时，如果确定不是文档结尾，就可以调用nextTag()产生下一个标签的START_TAG。在这二种情况下如果用next()会有TEXT事件，但返回的是换行符或空白符。
nextText()--只能在START_TAG时调用。当下一个元素是TEXT时，TEXT的内容会返回；当下一个元素是END_TAG时，也就是说这个标签的内容为空，那么空字串返回；这个方法返回后，Parser会停在END_TAG上。
核心代码如下所示：
|
01.myPULL.setOnClickListener(new Button.OnClickListener(){
02. @Override
03. public void onClick(View v) {
04. try{
05. String url = "http://www.google.com/ig/api?&weather=beijing";
06. DefaultHttpClient client = new DefaultHttpClient();
07. HttpUriRequest req = new HttpGet(url);
08. HttpResponse resp = client.execute(req);
09. HttpEntity ent = resp.getEntity();
10.
11. InputStream stream = ent.getContent(); //将文件导入流，因此用InputStream
12. XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
13. factory.setNamespaceAware(true);
14. XmlPullParser xpp = factory.newPullParser();
15. xpp.setInput(stream, null);
16. //xpp.setInput( new StringReader ( "Hello World!" ) );
17. int eventType = xpp.getEventType();
18. while (eventType != XmlPullParser.END_DOCUMENT) {
19. if(eventType == XmlPullParser.START_DOCUMENT) {
20. System.out.println("Start document");
21. } else if(eventType == XmlPullParser.START_TAG) {
22. System.out.println("Start tag "+xpp.getName());
23. if(xpp.getName().equals("high")){
24. j++;
25. if(j==2){
26. highestTmp.setText(String.valueOf((Integer.parseInt
(xpp.getAttributeValue(0))-32)*5/9));
27. }
28. }
29. } else if(eventType == XmlPullParser.END_TAG) {
30. System.out.println("End tag "+xpp.getName());
31. } else if(eventType == XmlPullParser.TEXT) {
32. System.out.println("Text "+xpp.getText());
33. }
34. eventType = xpp.next();
35. }
36. System.out.println("End document");
37. }
38. catch(Exception e){
39. e.printStackTrace();
40. }
41. }
42. }); |
小结一下，如果在一个XML文档中我们只需要前面一部分数据，但是使用SAX方式或DOM方式会对整个文档进行解析，尽管XML文档中后面的大部分数据我们其实都不需要解析，因此这样实际上就浪费了处理资源。使用PULL方式正合适。
|
01.//创建XmlPullParser,有两种方式
02. //方式一:使用工厂类XmlPullParserFactory
03. XmlPullParserFactory pullFactory = XmlPullParserFactory.newInstance();
04. XmlPullParser xmlPullParser = pullFactory.newPullParser();
05. //方式二:使用Android提供的实用工具类android.util.Xml
06. XmlPullParser xmlPullParser = Xml.newPullParser();
|
XmlPullParser.setInput(InputStream
inputStream, String inputEncoding) 解析对应的输入文件
XmlPullParser.getEventType() 得到元素
判断元素是否是START_DOCUMENT、END_DOCUMENT、START_TAG、END_TAG、TEXT中的哪种，进行相应解析。
后附上三种方式整合在一起的代码：
|
<p>/*</p><p> * Android开发之XML文件的解析</p>
<p> * SimpleweatherActivity.java </p>
<p> * Created on: 2012-7-24</p>
<p> * Author: blueeagle</p>
<p> * Email:liujiaxiang@gmail.com</p><p> */</p> |
|
01.public class SimpleweatherActivity extends Activity {
02. /** Called when the activity is first created. */
03. Button myDOM;
04. Button mySAX;
05. Button myPULL;
06. XmlPullParser x;
07. TextView highestTmp;
08. int iHighestTmp;
09. int i = 0;
10. int j = 0;
11. @Override
12. public void onCreate(Bundle savedInstanceState) {
13. super.onCreate(savedInstanceState);
14. setContentView(R.layout.main);
15. myDOM = (Button)findViewById(R.id.DOM);
16. mySAX = (Button)findViewById(R.id.SAX);
17. myPULL = (Button)findViewById(R.id.PULL);
18. highestTmp = (TextView)findViewById(R.id.highestTmp);
19.
20. myDOM.setOnClickListener(new Button.OnClickListener(){
21.
22. @Override
23. public void onClick(View v) {
24. try{
25. String url = "http://www.google.com/ig/api?&weather=beijing";
26. DefaultHttpClient client = new DefaultHttpClient();
27. HttpUriRequest req = new HttpGet(url);
28. HttpResponse resp = client.execute(req);
29. HttpEntity ent = resp.getEntity();
30. InputStream stream = ent.getContent();
31. DocumentBuilder myDocBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
32. Document myDoc = myDocBuilder.parse(new InputSource(stream));
33. //找到根Element
34. Element root=myDoc.getDocumentElement();
35. //找到子节点forecast_conditions
36. NodeList nodes=root.getElementsByTagName("forecast_conditions");
37. iHighestTmp = (Integer.parseInt(nodes.item(1).getChildNodes().item(2).getAttributes().
item(0).getNodeValue())-32)*5/9;
38. highestTmp.setText(String.valueOf(iHighestTmp));
39. } catch (Exception e) {
40. e.printStackTrace();
41. }}
42. });
43. mySAX.setOnClickListener(new Button.OnClickListener(){
44. @Override
45. public void onClick(View v) {
46. try{
47. String url = "http://www.google.com/ig/api?&weather=beijing";
48. DefaultHttpClient client = new DefaultHttpClient();
49. HttpUriRequest req = new HttpGet(url);
50. HttpResponse resp = client.execute(req);
51. HttpEntity ent = resp.getEntity();
52. InputStream stream = ent.getContent(); //将文件导入流，因此用InputStream
53.
54. SAXParserFactory saxFactory = SAXParserFactory.newInstance(); //获取一个对象
55. SAXParser saxParser = saxFactory.newSAXParser();//利用获取到的对象创建一个解析器
56. XMLContentHandler handler = new XMLContentHandler();//设置defaultHandler
57. saxParser.parse(stream, handler);//进行解析
58. stream.close();//关闭流
59. /*XMLReader xmlReader = saxFactory.newSAXParser().getXMLReader(); //获取一个XMLReader
60. xmlReader.setContentHandler(handler);
61. xmlReader.parse(new InputSource(stream));
62. stream.close();*/
63. }catch(Exception e){
64. e.printStackTrace();
65. }
66. }
67. });
68. myPULL.setOnClickListener(new Button.OnClickListener(){
69. @Override
70. public void onClick(View v) {
71. try{
72. String url = "http://www.google.com/ig/api?&weather=beijing";
73. DefaultHttpClient client = new DefaultHttpClient();
74. HttpUriRequest req = new HttpGet(url);
75. HttpResponse resp = client.execute(req);
76. HttpEntity ent = resp.getEntity();
77.
78. InputStream stream = ent.getContent(); //将文件导入流，因此用InputStream
79. XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
80. factory.setNamespaceAware(true);
81. XmlPullParser xpp = factory.newPullParser();
82. xpp.setInput(stream, null);
83. //xpp.setInput( new StringReader ( "Hello World!" ) );
84. int eventType = xpp.getEventType();
85. while (eventType != XmlPullParser.END_DOCUMENT) {
86. if(eventType == XmlPullParser.START_DOCUMENT) {
87. System.out.println("Start document");
88. } else if(eventType == XmlPullParser.START_TAG) {
89. System.out.println("Start tag "+xpp.getName());
90. if(xpp.getName().equals("high")){
91. j++;
92. if(j==2){
93. highestTmp.setText(String.valueOf((Integer.parseInt
(xpp.getAttributeValue(0))-32)*5/9));
94. }
95. }
96. } else if(eventType == XmlPullParser.END_TAG) {
97. System.out.println("End tag "+xpp.getName());
98. } else if(eventType == XmlPullParser.TEXT) {
99. System.out.println("Text "+xpp.getText());
100. }
101. eventType = xpp.next();
102. }
103. System.out.println("End document");
104. }
105. catch(Exception e){
106. e.printStackTrace();
107. }
108. }
109. });
110. }
111. public class XMLContentHandler extends DefaultHandler {
112. private static final String TAG = "XMLContentHandler";
113.
114. @Override
115. public void characters(char[] ch, int start, int length)
116. throws SAXException {
117. Log.i(TAG, "解析内容："+new String(ch,start,length));
118. }
119. @Override
120. public void endDocument() throws SAXException {
121. super.endDocument();
122. Log.i(TAG, "文档解析完毕。");
123. }
124. @Override
125. public void endElement(String uri, String localName, String qName)
126. throws SAXException {
127. Log.i(TAG, localName+"解析完毕");
128. }
129. @Override
130. public void startDocument() throws SAXException {
131. Log.i(TAG, "开始解析... ...");
132. }
133. @Override
134. public void startElement(String uri, String localName, String qName,
135. Attributes attributes) throws SAXException {
136. Log.i(TAG, "解析元素："+localName);
137.
138. if(localName.equals("high")){
139. Log.i(TAG, "解析元素："+localName);
140. i++;
141. if(i==2){
142. highestTmp.setText(String.valueOf((Integer.parseInt
(attributes.getValue(0))-32)*5/9));
143. }
144. }
145. }
146. }
147.} |
当点击三种方式的任何一个按钮时，均能够得到相同的结果。 |
