XML 解析

昨天有人在博问，问Android 如何解析XML. http://q.cnblogs.com/q/37961/#c288754 

在博客园搜了下，参考http://www.cnblogs.com/devinzhang/archive/2012/01/16/2323668.html ，都是现成的Java API,不是Android特有。

虽然是重复造轮子，自己试试总能加深理解：

需要解析的XML如下

<?xml version="1.0" encoding="utf-8"?>
<books>
<book>
<name>水浒传</name>
<price value = "45"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic1.jpg"></pic>
</book>
<book>
<name>希腊神话</name>
<price value = "36"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic2.jpg"></pic>
</book>
<book>
<name>励志中国</name>
<price value = "68"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic3.jpg"></pic>
</book>
<book>
<name>培根随笔</name>
<price value = "50"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic4.jpg"></pic>
</book>
<book>
<name>海底两万里</name>
<price value = "48"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic5.jpg"></pic>
</book>
<book>
<name>百年孤独</name>
<price value = "63"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic6.jpg"></pic>
</book>
<book>
<name>童年.在人间.我的大学</name>
<price value = "48"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic7.jpg"></pic>
</book>
<book>
<name>青鸟</name>
<price value = "24"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic8.jpg"></pic>
</book>
<book>
<name>茶花女</name>
<price value = "38"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic9.jpg"></pic>
</book>
<book>
<name>哲理文学名著</name>
<price value = "96"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic10.jpg"></pic>
</book>
<book>
<name>老人与海</name>
<price value = "69"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic11.jpg"></pic>
</book>
<book>
<name>文学名著赏析</name>
<price value = "78"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic12.jpg"></pic>
</book>
<book>
<name>三国演义</name>
<price value = "69"></price>
<pic url="http://192.168.8.14:8080/MyOrders/image/pic13.jpg"></pic>
</book>
</books>

 

代码如下： 

  1 package com.test.vbo;
  2 
  3 import android.net.Uri;
  4 import android.util.Log;
  5 import android.util.Xml;
  6 
  7 import org.w3c.dom.Document;
  8 import org.w3c.dom.Element;
  9 import org.w3c.dom.Node;
 10 import org.w3c.dom.NodeList;
 11 import org.xml.sax.Attributes;
 12 import org.xml.sax.SAXException;
 13 import org.xml.sax.helpers.DefaultHandler;
 14 import org.xmlpull.v1.XmlPullParser;
 15 import org.xmlpull.v1.XmlPullParserException;
 16 
 17 import java.io.IOException;
 18 import java.io.InputStream;
 19 import java.util.ArrayList;
 20 import java.util.List;
 21 
 22 import javax.xml.parsers.DocumentBuilder;
 23 import javax.xml.parsers.DocumentBuilderFactory;
 24 import javax.xml.parsers.ParserConfigurationException;
 25 import javax.xml.parsers.SAXParser;
 26 import javax.xml.parsers.SAXParserFactory;
 27 
 28 public class BookParser {
 29 
 30     public static final int MODE_SAX  = 0;
 31     public static final int MODE_DOM  = 1;
 32     public static final int MODE_PULL = 2;
 33     private static final String TAG = "BookParser";
 34 
 35     public List<Book> parse(InputStream input, int mode) {
 36         switch (mode) {
 37             case MODE_SAX:
 38                 return parseBySax(input);
 39             case MODE_DOM:
 40                 return parseByDom(input);
 41             case MODE_PULL:
 42                 return parseByPull(input);
 43             default :
 44             throw new IllegalArgumentException("Unsupported mode " + mode);
 45         }
 46     }
 47 
 48     //1. SAX解析XML文件
 49     /*SAX是一个解析速度快并且占用内存少的xml解析器，非常适合用于Android等移动设备。 
 50      * SAX解析XML文件采用的是事件驱动，也就是说，它并不需要解析完整个文档，
 51      * 在按内容顺序解析文档的过程中，SAX会判断当前读到的字符是否合法XML语法中的某部分，
 52      * 如果符合就会触发事件。所谓事件，其实就是一些回调（callback）方法，
 53      * 这些方法(事件)定义在ContentHandler接口。
 54      */
 55     private List<Book> parseBySax(InputStream input) {
 56         List<Book> result = null;
 57         try {
 58             //创建解析器
 59             SAXParserFactory spf = SAXParserFactory.newInstance();
 60             SAXParser saxParser = spf.newSAXParser();
 61  
 62             //设置解析器的相关特性，true表示开启命名空间特性
 63             //saxParser.setProperty("http://xml.org/sax/features/namespaces",true);
 64             XMLContentHandler handler = new XMLContentHandler();
 65             saxParser.parse(input, handler);
 66             result = handler.getBooks();
 67         } catch (Exception e) {
 68             Log.w(TAG, "during parse by sax", e); 
 69         }
 70         return result;
 71     }
 72 
 73     //SAX类：DefaultHandler，它实现了ContentHandler接口。在实现的时候，只需要继承该类，重载相应的方法即可。
 74     private class XMLContentHandler extends DefaultHandler {
 75 
 76         private List<Book> mBooks = null;
 77         private Book mCurrentBook;
 78         private String mTagName = null;// 当前解析的元素标签
 79 
 80         public List<Book> getBooks() {
 81             return mBooks;
 82         }
 83      
 84         // 接收文档开始的通知。当遇到文档的开头的时候，调用这个方法，可以在其中做一些预处理的工作。
 85         @Override
 86         public void startDocument() throws SAXException {
 87             //mBooks = new ArrayList<Book>();
 88         }
 89 
 90         // 接收元素开始的通知。当读到一个开始标签的时候，会触发这个方法。其中namespaceURI表示元素的命名空间；
 91         // localName表示元素的本地名称（不带前缀）；qName表示元素的限定名（带前缀）；atts 表示元素的属性集合
 92         @Override
 93         public void startElement(String namespaceURI, String localName, String qName,
 94                 Attributes atts) throws SAXException {
 95 
 96             if ("books".equals(localName)) {
 97                 mBooks = new ArrayList<Book>();
 98             } else if ("book".equals(localName)) {
 99                 mCurrentBook = new Book();
100             } else if ("price".equals(localName)) {
101                 mCurrentBook.setPrice(Float.parseFloat(atts.getValue("value")));
102             } else if ("pic".equals(localName)) {
103                 mCurrentBook.setPic(Uri.parse(atts.getValue("url")));
104             }
105 
106             mTagName = localName;
107         }
108      
109         // 接收字符数据的通知。该方法用来处理在XML文件中读到的内容，第一个参数用于存放文件的内容，
110         // 后面两个参数是读到的字符串在这个数组中的起始位置和长度，使用new String(ch,start,length)就可以获取内容。
111         @Override
112         public void characters(char[] ch, int start, int length) throws SAXException {
113 
114             if (mTagName != null) {
115                 String data = new String(ch, start, length);
116                 if (mTagName.equals("name")) {
117                     mCurrentBook.setName(data);
118                 }
119             }
120         }
121 
122         // 接收文档的结尾的通知。在遇到结束标签的时候，调用这个方法。其中，uri表示元素的命名空间；
123         // localName表示元素的本地名称（不带前缀）；name表示元素的限定名（带前缀）
124         @Override
125         public void endElement(String uri, String localName, String name) throws SAXException {
126 
127             if (localName.equals("book")) {
128                 mBooks.add(mCurrentBook);
129                 mCurrentBook = null;
130             }
131             mTagName = null;
132         }
133     }
134 
135     //2. DOM解析XML文件
136     /*
137      * DOM解析XML文件时，会将XML文件的所有内容读取到内存中，
138      * 然后允许您使用DOM API遍历XML树、检索所需的数据。
139      * 使用DOM操作XML的代码看起来比较直观，并且，在某些方面比基于SAX的实现更加简单。
140      * 但是，因为DOM需要将XML文件的所有内容读取到内存中，所以内存的消耗比较大，
141      * 特别对于运行Android的移动设备来说，因为设备的资源比较宝贵，
142      * 所以建议还是采用SAX来解析XML文件，当然，如果XML文件的内容比较小采用DOM是可行的。
143      */
144     private List<Book> parseByDom(InputStream input) {
145         List<Book> books = new ArrayList<Book>();
146         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
147         try {
148             DocumentBuilder builder = factory.newDocumentBuilder();
149             Document dom = builder.parse(input);
150             Element root = dom.getDocumentElement();
151             NodeList items = root.getElementsByTagName("book");// 查找所有book节点
152 
153             for (int i = 0; i < items.getLength(); i++) {
154                 Book book = new Book();
155 
156                 // 得到第i个book节点
157                 Element bookNode = (Element) items.item(i);
158 
159                 // 获取book节点下的所有子节点
160                 NodeList childsNodes = bookNode.getChildNodes();
161 
162                 for (int j = 0; j < childsNodes.getLength(); j++) {
163                     Node node = childsNodes.item(j);
164                     String nodeName = node.getNodeName();
165                     if ("name".equals(nodeName)) {
166                         book.setName(node.getFirstChild().getNodeValue());
167                     } else if ("price".equals(nodeName)){
168                         Element priceNode = ((Element) node); 
169                         book.setPrice(Float.parseFloat(priceNode.getAttribute("value")));
170                     } else if ("pic".equals(nodeName)) {
171                         Element picNode = ((Element) node); 
172                         book.setPic(Uri.parse(picNode.getAttribute("url")));
173                     }
174                 }
175                 books.add(book);
176             }
177         } catch (ParserConfigurationException e) {
178             Log.w(TAG, "during  parse by dom newDocumentBuilder ", e);
179         } catch (SAXException e) {
180             Log.w(TAG, "during  parse by dom parse", e);
181             e.printStackTrace();
182         } catch (IOException e) {
183             Log.w(TAG, "during  parse by dom parse", e);
184             e.printStackTrace();
185         }
186         return books;
187     }
188 
189     //3.Pull解析器解析XML文件
190     /*
191      * Pull解析器的运行方式与 SAX 解析器相似。
192      * 它提供了类似的事件，如：开始元素和结束元素事件，使用parser.next()可以进入下一个元素并触发相应事件。
193      * 事件将作为数值代码被发送，因此可以使用一个switch对感兴趣的事件进行处理。
194      * 当元素开始解析时，调用parser.nextText()方法可以获取下一个Text类型元素的值。
195      */
196     private List<Book> parseByPull(InputStream input) {
197         XmlPullParser parser = Xml.newPullParser();
198         Book currentBook = null;
199         List<Book> books = null;
200         try {
201             parser.setInput(input, "UTF-8");
202             int eventType = parser.getEventType();
203             
204             while (XmlPullParser.END_DOCUMENT != eventType) {
205                 switch (eventType) {
206                     case XmlPullParser.START_DOCUMENT:
207                         break;
208                     case XmlPullParser.START_TAG:
209                         String tagName = parser.getName();
210                         if ("books".equals(tagName)) {
211                             books = new ArrayList<Book>();
212                         } else if ("book".equals(tagName)){
213                             currentBook = new Book();
214                         } else if (currentBook != null) {
215                             if ("name".equals(tagName)) {
216                                 currentBook.setName(parser.nextText());
217                             } else if ("price".equals(tagName)){
218                                 currentBook.setPrice(Float.parseFloat(parser.getAttributeValue(null, "value")));
219                             } else if ("pic".equals(tagName)) {
220                                 currentBook.setPic(Uri.parse(parser.getAttributeValue(null, "url")));
221                             }
222                         } 
223                         break;
224                     case XmlPullParser.END_TAG:
225                         if (currentBook != null && "book".equals(parser.getName())) {
226                             books.add(currentBook);
227                             currentBook = null;
228                         }
229                         break;
230                 }
231                 eventType = parser.next();
232             }
233         } catch (XmlPullParserException e) {
234             Log.w(TAG, "during parse by pull set input", e);
235         } catch (IOException e) {
236             Log.w(TAG, "during parse by pull next", e);
237         }
238         return books;
239     }
240 }

 

转载于:https://www.cnblogs.com/0x00000000/archive/2012/06/27/xml_parser.html