XML PULL解析

 Pull和Sax类似，都是基于流（stream）操作文件，然后根据节点事件回调开发者编写的处理程序。因为是基于流的处理，因此Pull和Sax都比较节约内存资源，不会象Dom那样要把所有节点以对橡树的形式展现在内存中。 但Pull比Sax更简明，而且不需要扫描完整个流。

         他们的区别为：SAX解析器的工作方式是自动将事件推入注册的事件处理器进行处理，因此你不能控制事件的处理主动结束；而Pull解析器的工作方式为允许你的应用程序代码主动从解析器中获取事件，正因为是主动获取事件，因此可以在满足了需要的条件后不再获取事件，结束解析。这是他们主要的区别。如果在一个XML文档中我们只需要前面一部分数据，但是使用SAX方式或DOM方式会对整个文档进行解析，中间不能终止暂停，尽管XML文档中后面的大部分数据我们其实都不需要解析，因此这样实际上就浪费了处理资源。使用PULL方式正合适。

         Pull解析器也提供了类似SAX的事件，开始文档START_DOCUMENT和结束文档END_DOCUMENT，开始元素START_TAG和结束元素END_TAG，遇到元素内容TEXT等，但需要调用next() 方法提取它们（主动提取事件）。

         Android系统中和Pull方式相关的包为org.xmlpull.v1.         PULL是个开源的项目，源码地址http://www.xmlpull.org/

         经常需要使用的类：

          XmlPullParserFactory              工厂类，用来创建pull解析器

          XmlPullParser                           pull解析器

         XmlPullParserException             异常

          XmlSerializer                               该类用来将指定的对象转化为XML文档

          创建XmlPullParser

          创建XmlPullParser方式有两种：

           方式一：通过XmlPullParserFactory创建   

[java] view plaincopy

1. XmlPullParserFactory xpf = XmlPullParserFactory.newInstance();//构造工厂实例  
2. sp;  XmlPullParser parser = xpf.newPullParser();//创建解析对象  

           方法二：通过Android.util.Xml类

[java] view plaincopy

1. XmlPullParser parser = Xml.newPullParser();  

       下面开始用Pull解析

         解析的流程如下：

　　(1)取得pull解析器

　　(2)设置解析器的输入流

　　(3)产生第一个事件

　　(4)开始解析

　　(5)解析结束

         解析XML文件如下：

  

[java] view plaincopy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <rivers>  
3.  <river name="灵渠" length="605">  
4.      <introduction>  
5.       灵渠在广西壮族自治区兴安县境内，是世界上最古老的运河之一，有着“世界古代水利建筑明珠”的美誉。灵渠古称秦凿渠、零渠、陡河、兴安运河，于公元前214年凿成通航，距今已2217年，仍然发挥着功用。  
6.      </introduction>  
7.       <imageurl>  
8.       http://www.2cto.com/uploadfile/2012/0228/20120228094142711.jpg  
9.      </imageurl>  
10.    </river>  
11.     
12.    <river name="胶莱运河" length="200">  
13.      <introduction>  
14.       胶莱运河南起黄海灵山海口，北抵渤海三山岛，流经现胶南、胶州、平度、高密、昌邑和莱州等，全长200公里，流域面积达5400平方公里，南北贯穿山东半岛，沟通黄渤两海。胶莱运河自平度姚家村东的分水岭南北分流。南流由麻湾口入胶州湾，为南胶莱河，长30公里。北流由海仓口入莱州湾,为北胶莱河,长100余公里。  
15.      </introduction>  
16.       <imageurl>  
17.       http://www.2cto.com/uploadfile/2012/0228/20120228094142711.jpg  
18.      </imageurl>  
19.    </river>  
20.     
21.    <river name="苏北灌溉总渠" length="168">  
22.      <introduction>  
23.       位于淮河下游江苏省北部，西起洪泽湖边的高良涧，流经洪泽，青浦、淮安，阜宁、射阳，滨海等六县(区)，东至扁担港口入海的大型人工河道。全长168km。  
24.      </introduction>  
25.       <imageurl>  
26.       http://www.2cto.com/uploadfile/2012/0228/20120228094142711.jpg  
27.      </imageurl>  
28.    </river>  
29.  </rivers>  

           解析过程：

[java] view plaincopy

1.  private List<River> parserXMLPULL(InputStream is)  
2.    {  
3.      List<River> list = null;  
4.      River river = null;  
5. //     XmlPullParserException  
6. //     XmlSerializer  
7.   
8. //     方式一：  
9. //     XmlPullParser parser = Xml.newPullParser();  
10. //     方法二：  
11.        XmlPullParserFactory xpf = null;  
12.        XmlPullParser parser = null;  
13.        try {  
14.             xpf = XmlPullParserFactory.newInstance();  
15.             parser = xpf.newPullParser();  
16. //          将XML文件以流的形式加入，并设置XML文件的编码方式  
17. //          parser.setInput(InputStrean inputStream, String inputEncoding)  
18. //          parser.setInput(Reader reader)  
19.             parser.setInput(is, "UTF-8");  
20. //          此时文档刚初始化，所以解析的位置在文档的开头  
21.                  
22.             int type = parser.getEventType();//此时返回０，也就是在START_DOCUMENT  
23.               
24. //          返回类型START_DOCUMENT,END_DOCUMENT,START_TAG,END_TAG,TEXT  
25.            while(type!= XmlPullParser.END_DOCUMENT)  
26.            {  
27.                switch(type)  
28.                {  
29.                case XmlPullParser.START_DOCUMENT:  
30.                    //做一些初始化工作  
31.                    list = new ArrayList<River>();     
32.                    break;  
33.                case XmlPullParser.START_TAG:  
34.                    //rivers  
35.                    String name = parser.getName();  
36.                    if(name.equals("river"))  
37.                    {  
38.                        String attrName = parser.getAttributeValue(0);  
39.                        int attrLen = Integer.parseInt(parser.getAttributeValue(1));  
40.                        river = new River();  
41.                        river.setName(attrName);  
42.                        river.setLength(attrLen);  
43.                    }   
44.                    if(parser.getName().equals("introduction")&&river!=null)  
45.                    {  
46.                        String intro = parser.nextText();  
47.                        river.setIntro(intro);     
48.                    }  
49.                    if("imageurl".equals(parser.getName())&&river!=null)  
50.                    {  
51.                        String url = parser.nextText();  
52.                        river.setUrl(url);  
53.                    }  
54.                          
55.                    
56.                    
57.                    break;  
58.                case XmlPullParser.END_TAG:  
59.                    String value = parser.getName();  
60.                    if(value.equals("river")&&river!=null&&list!=null)  
61.                    {  
62. //                     添加对象到list中  
63.                        list.add(river);  
64.                        river = null;  
65.                    }  
66.                    break;  
67.                }  
68.               type = parser.next();//当前解析位置结束，指向下一个位置  
69.            }  
70.           
71.               
72.             } catch (IOException e) {  
73.                 // TODO Auto-generated catch block  
74.                 e.printStackTrace();  
75.            } catch (XmlPullParserException e) {  
76.             // TODO Auto-generated catch block  
77.              e.printStackTrace();  
78.            }  
79.   
80.          return list;        
81.    }  

River 类很简单

[java] view plaincopy

1. package com.liupan.parse;  
2.   
3. public class River {  
4.     private String name;  
5.     private int length;  
6.     private String intro;  
7.     private String url;  
8.     public String getName() {  
9.         return name;  
10.     }  
11.     public void setName(String name) {  
12.         this.name = name;  
13.     }  
14.     public int getLength() {  
15.         return length;  
16.     }  
17.     public void setLength(int length) {  
18.         this.length = length;  
19.     }  
20.     public String getIntro() {  
21.         return intro;  
22.     }  
23.     public void setIntro(String intro) {  
24.         this.intro = intro;  
25.     }  
26.     public String getUrl() {  
27.         return url;  
28.     }  
29.     public void setUrl(String url) {  
30.         this.url = url;  
31.     }  
32.   
33. }  

            XmlSerializer类的使用

[java] view plaincopy

1. public  String createXML(Writer writer  ,List<River> list) throws Exception  
2.  {  
3.   XmlSerializer serial =Xml.newSerializer();  
4.     
5.   //设置输出流的位置,本句会抛出异常  
6.   serial.setOutput(writer);  
7.   //以下开始创建XML文件  
8.     
9.   serial.startDocument("utf-8", true);//对应之前解析时出现的事件  
10.   serial.startTag("", "rivers");  
11.     
12.   //将list的内容写入XML文件  
13.   if(list!=null)  
14.   {  
15.    for(River river : list)  
16.    {  
17.        //创建river标签  
18.        serial.startTag("", "river");  
19.          
20.        //为river标签添加属性 name 和length  
21.        serial.attribute("", "name",river.getName());  
22.        serial.attribute("", "length",""+river.getLength());  
23.          
24.        serial.startTag("", "introduction");  
25.        serial.text(river.getIntro());  
26.        serial.endTag("", "introduction");  
27.          
28.        serial.startTag("", "imageurl");  
29.        serial.text(river.getUrl());  
30.        serial.endTag("", "imageurl");  
31.          
32.        serial.endTag("","river");  
33.          
34.          
35.          
36.    }  
37.   }  
38.   
39.   serial.endTag("", "rivers");  
40.   serial.endDocument();  
41.     
42.        刷新输出的缓冲区  
43.   writer.flush();  
44.   //关闭输出流  
45.   writer.close();  
46.   return writer.toString();  
47.  }