Android xml檔案解析 SAX，DOM，PULL

XML在各種開發中都廣泛應用，Android也不例外。作為承載資料的一個重要角色，如何讀寫XML成為Android開發中一項重要的技能。今天就由我向大家介紹一下在Android平台下幾種常見的XML解析和建立的方法。

在Android中，常見的XML解析器分别為SAX解析器、DOM解析器和PULL解析器，下面，我将一一向大家詳細介紹。

SAX解析器：

SAX(Simple API for XML)解析器是一種基于事件的解析器，它的核心是事件處理模式，主要是圍繞着事件源以及事件處理器來工作的。當事件源産生事件後，調用事件處理器相應的處理方法，一個事件就可以得到處理。在事件源調用事件處理器中特定方法的時候，還要傳遞給事件處理器相應事件的狀态資訊，這樣事件處理器才能夠根據提供的事件資訊來決定自己的行為。

SAX解析器的優點是解析速度快，占用記憶體少。非常适合在Android移動裝置中使用。

DOM解析器：

DOM是基于樹形結構的的節點或資訊片段的集合，允許開發人員使用DOM API周遊XML樹、檢索所需資料。分析該結構通常需要加載整個文檔和構造樹形結構，然後才可以檢索和更新節點資訊。

由于DOM在記憶體中以樹形結構存放，是以檢索和更新效率會更高。但是對于特别大的文檔，解析和加載整個文檔将會很耗資源。

PULL解析器：

PULL解析器的運作方式和SAX類似，都是基于事件的模式。不同的是，在PULL解析過程中，我們需要自己擷取産生的事件然後做相應的操作，而不像SAX那樣由處理器觸發一種事件的方法，執行我們的代碼。PULL解析器小巧輕便，解析速度快，簡單易用，非常适合在Android移動裝置中使用，Android系統内部在解析各種XML時也是用PULL解析器。

以上三種解析器，都是非常實用的解析器，我将會一一介紹。我們将會使用這三種解析技術完成一項共同的任務。

我們建立一個項目，項目結構如下：

我會在項目的assets目錄中放置一個XML文檔books.xml，内容如下：

[xhtml]  view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <books>  
3.     <book>  
4.         <id>1001</id>  
5.         <name>Thinking In Java</name>  
6.         <price>80.00</price>  
7.     </book>  
8.     <book>  
9.         <id>1002</id>  
10.         <name>Core Java</name>  
11.         <price>90.00</price>  
12.     </book>  
13.     <book>  
14.         <id>1003</id>  
15.         <name>Hello, Andriod</name>  
16.         <price>100.00</price>  
17.     </book>  
18. </books>  

然後我們分别使用以上三種解析技術解析文檔，得到一個List<Book>的對象，先來看一下Book.java的代碼：

[java]  view plain copy

1. package com.scott.xml.model;  
2. public class Book {  
3.     private int id;  
4.     private String name;  
5.     private float price;  
6.     public int getId() {  
7.         return id;  
8.     }  
9.     public void setId(int id) {  
10.         this.id = id;  
11.     }  
12.     public String getName() {  
13.         return name;  
14.     }  
15.     public void setName(String name) {  
16.         this.name = name;  
17.     }  
18.     public float getPrice() {  
19.         return price;  
20.     }  
21.     public void setPrice(float price) {  
22.         this.price = price;  
23.     }  
24.     @Override  
25.     public String toString() {  
26.         return "id:" + id + ", name:" + name + ", price:" + price;  
27.     }  
28. }  

最後，我們還要把這個集合對象中的資料生成一個新的XML文檔，如圖：

生成的XML結構跟原始文檔略有不同，是下面這種格式：

[xhtml]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <books>  
3.   <book id="1001">  
4.     <name>Thinking In Java</name>  
5.     <price>80.0</price>  
6.   </book>  
7.   <book id="1002">  
8.     <name>Core Java</name>  
9.     <price>90.0</price>  
10.   </book>  
11.   <book id="1003">  
12.     <name>Hello, Andriod</name>  
13.     <price>100.0</price>  
14.   </book>  
15. </books>  

接下來，就該介紹操作過程了，我們先為解析器定義一個BookParser接口，每種類型的解析器需要實作此接口。BookParser.java代碼如下：

[java]  view plain copy

1. package com.scott.xml.parser;  
2. import java.io.InputStream;  
3. import java.util.List;  
4. import com.scott.xml.model.Book;  
5. public interface BookParser {  
6.     public List<Book> parse(InputStream is) throws Exception;  
7.     public String serialize(List<Book> books) throws Exception;  
8. }  

好了，我們就該一個一個的實作該接口，完成我們的解析過程。

使用SAX解析器：

SaxBookParser.java代碼如下：

[c-sharp]  view plain copy

1. package com.scott.xml.parser;  
2. import java.io.InputStream;  
3. import java.io.StringWriter;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6. import javax.xml.parsers.SAXParser;  
7. import javax.xml.parsers.SAXParserFactory;  
8. import javax.xml.transform.OutputKeys;  
9. import javax.xml.transform.Result;  
10. import javax.xml.transform.Transformer;  
11. import javax.xml.transform.TransformerFactory;  
12. import javax.xml.transform.sax.SAXTransformerFactory;  
13. import javax.xml.transform.sax.TransformerHandler;  
14. import javax.xml.transform.stream.StreamResult;  
15. import org.xml.sax.Attributes;  
16. import org.xml.sax.SAXException;  
17. import org.xml.sax.helpers.AttributesImpl;  
18. import org.xml.sax.helpers.DefaultHandler;  
19. import com.scott.xml.model.Book;  
20. public class SaxBookParser implements BookParser {  
21.     @Override  
22.     public List<Book> parse(InputStream is) throws Exception {  
23.         SAXParserFactory factory = SAXParserFactory.newInstance();  //取得SAXParserFactory執行個體  
24.         SAXParser parser = factory.newSAXParser();                  //從factory擷取SAXParser執行個體  
25.         MyHandler handler = new MyHandler();                        //執行個體化自定義Handler  
26.         parser.parse(is, handler);                                  //根據自定義Handler規則解析輸入流  
27.         return handler.getBooks();  
28.     }  
29.     @Override  
30.     public String serialize(List<Book> books) throws Exception {  
31.         SAXTransformerFactory factory = (SAXTransformerFactory) TransformerFactory.newInstance();//取得SAXTransformerFactory執行個體  
32.         TransformerHandler handler = factory.newTransformerHandler();           //從factory擷取TransformerHandler執行個體  
33.         Transformer transformer = handler.getTransformer();                     //從handler擷取Transformer執行個體  
34.         transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");            // 設定輸出采用的編碼方式  
35.         transformer.setOutputProperty(OutputKeys.INDENT, "yes");                // 是否自動添加額外的空白  
36.         transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");   // 是否忽略XML聲明  
37.         StringWriter writer = new StringWriter();  
38.         Result result = new StreamResult(writer);  
39.         handler.setResult(result);  
40.         String uri = "";    //代表命名空間的URI 當URI無值時 須置為空字元串  
41.         String localName = "";  //命名空間的本地名稱(不包含字首) 當沒有進行命名空間處理時 須置為空字元串  
42.         handler.startDocument();  
43.         handler.startElement(uri, localName, "books", null);  
44.         AttributesImpl attrs = new AttributesImpl();    //負責存放元素的屬性資訊  
45.         char[] ch = null;  
46.         for (Book book : books) {  
47.             attrs.clear();  //清空屬性清單  
48.             attrs.addAttribute(uri, localName, "id", "string", String.valueOf(book.getId()));//添加一個名為id的屬性(type影響不大,這裡設為string)  
49.             handler.startElement(uri, localName, "book", attrs);    //開始一個book元素 關聯上面設定的id屬性  
50.             handler.startElement(uri, localName, "name", null); //開始一個name元素 沒有屬性  
51.             ch = String.valueOf(book.getName()).toCharArray();  
52.             handler.characters(ch, 0, ch.length);   //設定name元素的文本節點  
53.             handler.endElement(uri, localName, "name");  
54.             handler.startElement(uri, localName, "price", null);//開始一個price元素 沒有屬性  
55.             ch = String.valueOf(book.getPrice()).toCharArray();  
56.             handler.characters(ch, 0, ch.length);   //設定price元素的文本節點  
57.             handler.endElement(uri, localName, "price");  
58.             handler.endElement(uri, localName, "book");  
59.         }  
60.         handler.endElement(uri, localName, "books");  
61.         handler.endDocument();  
62.         return writer.toString();  
63.     }  
64.     //需要重寫DefaultHandler的方法  
65.     private class MyHandler extends DefaultHandler {  
66.         private List<Book> books;  
67.         private Book book;  
68.         private StringBuilder builder;  
69.         //傳回解析後得到的Book對象集合  
70.         public List<Book> getBooks() {  
71.             return books;  
72.         }  
73.         @Override  
74.         public void startDocument() throws SAXException {  
75.             super.startDocument();  
76.             books = new ArrayList<Book>();  
77.             builder = new StringBuilder();  
78.         }  
79.         @Override  
80.         public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
81.             super.startElement(uri, localName, qName, attributes);  
82.             if (localName.equals("book")) {  
83.                 book = new Book();  
84.             }  
85.             builder.setLength(0);   //将字元長度設定為0 以便重新開始讀取元素内的字元節點  
86.         }  
87.         @Override  
88.         public void characters(char[] ch, int start, int length) throws SAXException {  
89.             super.characters(ch, start, length);  
90.             builder.append(ch, start, length);  //将讀取的字元數組追加到builder中  
91.         }  
92.         @Override  
93.         public void endElement(String uri, String localName, String qName) throws SAXException {  
94.             super.endElement(uri, localName, qName);  
95.             if (localName.equals("id")) {  
96.                 book.setId(Integer.parseInt(builder.toString()));  
97.             } else if (localName.equals("name")) {  
98.                 book.setName(builder.toString());  
99.             } else if (localName.equals("price")) {  
100.                 book.setPrice(Float.parseFloat(builder.toString()));  
101.             } else if (localName.equals("book")) {  
102.                 books.add(book);  
103.             }  
104.         }  
105.     }  
106. }  

代碼中，我們定義了自己的事件處理邏輯，重寫了DefaultHandler的幾個重要的事件方法。下面我為大家着重介紹一下DefaultHandler的相關知識。DefaultHandler是一個事件處理器，可以接收解析器報告的所有事件，處理所發現的資料。它實作了EntityResolver接口、DTDHandler接口、ErrorHandler接口和ContentHandler接口。這幾個接口代表不同類型的事件處理器。我們着重介紹一下ContentHandler接口。結構如圖：

這幾個比較重要的方法已被我用紅線标注，DefaultHandler實作了這些方法，但在方法體内沒有做任何事情，是以我們在使用時必須覆寫相關的方法。最重要的是startElement方法、characters方法和endElement方法。當執行文檔時遇到起始節點，startElement方法将會被調用，我們可以擷取起始節點相關資訊；然後characters方法被調用，我們可以擷取節點内的文本資訊；最後endElement方法被調用，我們可以做收尾的相關操作。

最後，我們需要調用SAX解析程式，這個步驟在MainActivity中完成：

[java]  view plain copy

1. package com.scott.xml;  
2. import java.io.FileOutputStream;  
3. import java.io.InputStream;  
4. import java.util.List;  
5. import android.app.Activity;  
6. import android.content.Context;  
7. import android.os.Bundle;  
8. import android.util.Log;  
9. import android.view.View;  
10. import android.widget.Button;  
11. import com.scott.xml.model.Book;  
12. import com.scott.xml.parser.BookParser;  
13. import com.scott.xml.parser.SaxBookParser;  
14. public class MainActivity extends Activity {  
15.     private static final String TAG = "XML";  
16.     private BookParser parser;  
17.     private List<Book> books;  
18.     @Override  
19.     public void onCreate(Bundle savedInstanceState) {  
20.         super.onCreate(savedInstanceState);  
21.         setContentView(R.layout.main);  
22.         Button readBtn = (Button) findViewById(R.id.readBtn);  
23.         Button writeBtn = (Button) findViewById(R.id.writeBtn);  
24.         readBtn.setOnClickListener(new View.OnClickListener() {  
25.             @Override  
26.             public void onClick(View v) {  
27.                 try {  
28.                     InputStream is = getAssets().open("books.xml");  
29.                     parser = new SaxBookParser();  //建立SaxBookParser執行個體  
30.                     books = parser.parse(is);  //解析輸入流  
31.                     for (Book book : books) {  
32.                         Log.i(TAG, book.toString());  
33.                     }  
34.                 } catch (Exception e) {  
35.                     Log.e(TAG, e.getMessage());  
36.                 }  
37.             }  
38.         });  
39.         writeBtn.setOnClickListener(new View.OnClickListener() {  
40.             @Override  
41.             public void onClick(View v) {  
42.                 try {  
43.                     String xml = parser.serialize(books);  //序列化  
44.                     FileOutputStream fos = openFileOutput("books.xml", Context.MODE_PRIVATE);  
45.                     fos.write(xml.getBytes("UTF-8"));  
46.                 } catch (Exception e) {  
47.                     Log.e(TAG, e.getMessage());  
48.                 }  
49.             }  
50.         });  
51.     }  
52. }  

界面就兩個按鈕，順便給大家貼上：

點選“readXML”按鈕，将會調用SAX解析器解析文檔，并在日志台列印相關資訊：

然後再點選“writeXML”按鈕，将會在該應用包下的files目錄生成一個books.xml檔案：

使用DOM解析器：

DomBookParser.java代碼如下：

[java]  view plain copy

1. package com.scott.xml.parser;  
2. import java.io.InputStream;  
3. import java.io.StringWriter;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6. import javax.xml.parsers.DocumentBuilder;  
7. import javax.xml.parsers.DocumentBuilderFactory;  
8. import javax.xml.transform.OutputKeys;  
9. import javax.xml.transform.Result;  
10. import javax.xml.transform.Source;  
11. import javax.xml.transform.Transformer;  
12. import javax.xml.transform.TransformerFactory;  
13. import javax.xml.transform.dom.DOMSource;  
14. import javax.xml.transform.stream.StreamResult;  
15. import org.w3c.dom.Document;  
16. import org.w3c.dom.Element;  
17. import org.w3c.dom.Node;  
18. import org.w3c.dom.NodeList;  
19. import com.scott.xml.model.Book;  
20. public class DomBookParser implements BookParser {  
21.     @Override  
22.     public List<Book> parse(InputStream is) throws Exception {  
23.         List<Book> books = new ArrayList<Book>();  
24.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  //取得DocumentBuilderFactory執行個體  
25.         DocumentBuilder builder = factory.newDocumentBuilder(); //從factory擷取DocumentBuilder執行個體  
26.         Document doc = builder.parse(is);   //解析輸入流 得到Document執行個體  
27.         Element rootElement = doc.getDocumentElement();  
28.         NodeList items = rootElement.getElementsByTagName("book");  
29.         for (int i = 0; i < items.getLength(); i++) {  
30.             Book book = new Book();  
31.             Node item = items.item(i);  
32.             NodeList properties = item.getChildNodes();  
33.             for (int j = 0; j < properties.getLength(); j++) {  
34.                 Node property = properties.item(j);  
35.                 String nodeName = property.getNodeName();  
36.                 if (nodeName.equals("id")) {  
37.                     book.setId(Integer.parseInt(property.getFirstChild().getNodeValue()));  
38.                 } else if (nodeName.equals("name")) {  
39.                     book.setName(property.getFirstChild().getNodeValue());  
40.                 } else if (nodeName.equals("price")) {  
41.                     book.setPrice(Float.parseFloat(property.getFirstChild().getNodeValue()));  
42.                 }  
43.             }  
44.             books.add(book);  
45.         }  
46.         return books;  
47.     }  
48.     @Override  
49.     public String serialize(List<Book> books) throws Exception {  
50.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
51.         DocumentBuilder builder = factory.newDocumentBuilder();  
52.         Document doc = builder.newDocument();   //由builder建立新文檔  
53.         Element rootElement = doc.createElement("books");  
54.         for (Book book : books) {  
55.             Element bookElement = doc.createElement("book");  
56.             bookElement.setAttribute("id", book.getId() + "");  
57.             Element nameElement = doc.createElement("name");  
58.             nameElement.setTextContent(book.getName());  
59.             bookElement.appendChild(nameElement);  
60.             Element priceElement = doc.createElement("price");  
61.             priceElement.setTextContent(book.getPrice() + "");  
62.             bookElement.appendChild(priceElement);  
63.             rootElement.appendChild(bookElement);  
64.         }  
65.         doc.appendChild(rootElement);  
66.         TransformerFactory transFactory = TransformerFactory.newInstance();//取得TransformerFactory執行個體  
67.         Transformer transformer = transFactory.newTransformer();    //從transFactory擷取Transformer執行個體  
68.         transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");            // 設定輸出采用的編碼方式  
69.         transformer.setOutputProperty(OutputKeys.INDENT, "yes");                // 是否自動添加額外的空白  
70.         transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");   // 是否忽略XML聲明  
71.         StringWriter writer = new StringWriter();  
72.         Source source = new DOMSource(doc); //表明文檔來源是doc  
73.         Result result = new StreamResult(writer);//表明目标結果為writer  
74.         transformer.transform(source, result);  //開始轉換  
75.         return writer.toString();  
76.     }  
77. }  

然後再MainActivity中隻需改一個地方：

[java]  view plain copy

1.      readBtn.setOnClickListener(new View.OnClickListener() {  
2. @Override  
3. public void onClick(View v) {  
4.     try {  
5.         InputStream is = getAssets().open("books.xml");  
6.  //             parser = new SaxBookParser();  
7.         parser = new DomBookParser();  
8.         books = parser.parse(is);  
9.         for (Book book : books) {  
10.             Log.i(TAG, book.toString());  
11.         }  
12.     } catch (Exception e) {  
13.         Log.e(TAG, e.getMessage());  
14.     }  
15. }  
16. );  

執行結果是一樣的。

使用PULL解析器：

PullBookParser.java代碼如下：

[java]  view plain copy

1. package com.scott.xml.parser;  
2. import java.io.InputStream;  
3. import java.io.StringWriter;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6. import org.xmlpull.v1.XmlPullParser;  
7. import org.xmlpull.v1.XmlSerializer;  
8. import android.util.Xml;  
9. import com.scott.xml.model.Book;  
10. public class PullBookParser implements BookParser {  
11.     @Override  
12.     public List<Book> parse(InputStream is) throws Exception {  
13.         List<Book> books = null;  
14.         Book book = null;  
15. //      XmlPullParserFactory factory = XmlPullParserFactory.newInstance();  
16. //      XmlPullParser parser = factory.newPullParser();  
17.         XmlPullParser parser = Xml.newPullParser(); //由android.util.Xml建立一個XmlPullParser執行個體  
18.         parser.setInput(is, "UTF-8");               //設定輸入流 并指明編碼方式  
19.         int eventType = parser.getEventType();  
20.         while (eventType != XmlPullParser.END_DOCUMENT) {  
21.             switch (eventType) {  
22.             case XmlPullParser.START_DOCUMENT:  
23.                 books = new ArrayList<Book>();  
24.                 break;  
25.             case XmlPullParser.START_TAG:  
26.                 if (parser.getName().equals("book")) {  
27.                     book = new Book();  
28.                 } else if (parser.getName().equals("id")) {  
29.                     eventType = parser.next();  
30.                     book.setId(Integer.parseInt(parser.getText()));  
31.                 } else if (parser.getName().equals("name")) {  
32.                     eventType = parser.next();  
33.                     book.setName(parser.getText());  
34.                 } else if (parser.getName().equals("price")) {  
35.                     eventType = parser.next();  
36.                     book.setPrice(Float.parseFloat(parser.getText()));  
37.                 }  
38.                 break;  
39.             case XmlPullParser.END_TAG:  
40.                 if (parser.getName().equals("book")) {  
41.                     books.add(book);  
42.                     book = null;      
43.                 }  
44.                 break;  
45.             }  
46.             eventType = parser.next();  
47.         }  
48.         return books;  
49.     }  
50.     @Override  
51.     public String serialize(List<Book> books) throws Exception {  
52. //      XmlPullParserFactory factory = XmlPullParserFactory.newInstance();  
53. //      XmlSerializer serializer = factory.newSerializer();  
54.         XmlSerializer serializer = Xml.newSerializer(); //由android.util.Xml建立一個XmlSerializer執行個體  
55.         StringWriter writer = new StringWriter();  
56.         serializer.setOutput(writer);   //設定輸出方向為writer  
57.         serializer.startDocument("UTF-8", true);  
58.         serializer.startTag("", "books");  
59.         for (Book book : books) {  
60.             serializer.startTag("", "book");  
61.             serializer.attribute("", "id", book.getId() + "");  
62.             serializer.startTag("", "name");  
63.             serializer.text(book.getName());  
64.             serializer.endTag("", "name");  
65.             serializer.startTag("", "price");  
66.             serializer.text(book.getPrice() + "");  
67.             serializer.endTag("", "price");  
68.             serializer.endTag("", "book");  
69.         }  
70.         serializer.endTag("", "books");  
71.         serializer.endDocument();  
72.         return writer.toString();  
73.     }  
74. }  

然後再對MainActivity做以下更改：

[java]  view plain copy

1.         readBtn.setOnClickListener(new View.OnClickListener() {  
2.             @Override  
3.             public void onClick(View v) {  
4.                 try {  
5.                     InputStream is = getAssets().open("books.xml");  
6. //                  parser = new SaxBookParser();  
7. //                  parser = new DomBookParser();  
8.                     parser = new PullBookParser();  
9.                     books = parser.parse(is);  
10.                     for (Book book : books) {  
11.                         Log.i(TAG, book.toString());  
12.                     }  
13.                 } catch (Exception e) {  
14.                     Log.e(TAG, e.getMessage());  
15.                 }  
16.             }  
17.         });  

和其他兩個執行結果都一樣。

對于這三種解析器各有優點，我個人比較傾向于PULL解析器，因為SAX解析器操作起來太笨重，DOM不适合文檔較大，記憶體較小的場景，唯有PULL輕巧靈活，速度快，占用記憶體小，使用非常順手。讀者也可以根據自己的喜好選擇相應的解析技術。