android解析XML的三种方式（DOM，SAX，PULL）

本文的内容基本上是来自于另一篇文章，详细的请参考:
http://www.cnblogs.com/zhangdongzi/archive/2011/04/14/2016434.html
然后自己简单的总结了一下，手动写了个demo来练手，把三种方式都写在一个类里面

1. DOM

DOM方式解析xml是先把xml文档都读到内存中，然后再用DOM API来访问树形结构，并获取数据的，但是这样一来，如果xml文件很大呢？手机CPU处理能力当然不能与PC机器比，因此在处理效率方面就相对差了，当然这是对于其他方式处理xml文档而言。

2. SAX

SAX是基于事件驱动的。当然android的事件机制是基于回调函数的，在用SAX解析xml文档时候，在读取到文档开始和结束标签时候就会回调一个事件，在读取到其他节点与内容时候也会回调一个事件。

既然涉及到事件，就有事件源，事件处理器。在SAX接口中，事件源是org.xml.sax包中的XMLReader，它通过parser()方法 来解析XML文档，并产生事件。事件处理器是org.xml.sax包中ContentHander、DTDHander、ErrorHandler，以 及EntityResolver这4个接口

需要XmlReader 以及DefaultHandler来配合解析xml。

3.PULL

PULL方式也是基于事件驱动的，读取xml回调方法返回的是数字。

读取到xml的声明返回      START_DOCUMENT
读取到xml的结束返回       END_DOCUMENT 
读取到xml的开始标签返回 START_TAG 
读取到xml的结束标签返回 END_TAG 
读取到xml的文本返回       TEXT

package per.lx.xml_parser;  

import java.io.IOException;  
import java.io.InputStream;  
import java.io.Serializable;  
import java.util.ArrayList;  
import java.util.List; 

import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import javax.xml.parsers.ParserConfigurationException;  
import javax.xml.parsers.SAXParser;  
import javax.xml.parsers.SAXParserFactory;  
  
import org.w3c.dom.Element;  
import org.w3c.dom.NodeList;  
import org.xml.sax.Attributes;  
import org.xml.sax.InputSource;  
import org.xml.sax.SAXException;  
import org.xml.sax.XMLReader;  
import org.xml.sax.helpers.DefaultHandler;  
import org.xmlpull.v1.XmlPullParser;  
import org.xmlpull.v1.XmlPullParserException;  
  
import android.app.Activity;  
import android.os.Bundle;  
import android.util.Xml;  
import android.widget.TextView;  
  
public class XMLParserTestActivity extends Activity {  
  
    private static final String DOM = "DOM parser";  
    private static final String SAX = "SAX parser";  
    private static final String PULL = "PULL parser";  
  
    private String parserType = DOM;  
  
    /** Called when the activity is first created. */  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
  
        List<SearchInfo> infos = null;  
        if (DOM.equals(parserType)) {  
            infos = parserByDOM("search.xml");  
        } else if (SAX.equals(parserType)) {  
            infos = parserBySAX("search.xml");  
        } else if (PULL.equals(parserType)) {  
            infos = parserByPULL("search.xml");  
        }  
  
        TextView search = (TextView) findViewById(R.id.search);  
        StringBuilder infoBuilder = new StringBuilder();  
        infoBuilder.append(" " + parserType + "\n\n");  
        for (int i = 0; i < infos.size(); i++) {  
            infoBuilder.append(" name : " + infos.get(i).getName() + "\n");  
            infoBuilder.append(" age : " + infos.get(i).getAge() + "\n");  
            infoBuilder.append(" introduction : " + infos.get(i).getIntroduction() + "\n");  
            infoBuilder.append(" url : " + infos.get(i).getUrl() + "\n");  
            infoBuilder.append("\n");  
        }  
        search.setText(infoBuilder.toString());  
    }  
  
    public static class SearchInfo implements Serializable {  
  
        /** 
         *  
         */  
        private static final long serialVersionUID = 1L;  
  
        private String name;  
  
        private int age;  
  
        private String introduction;  
  
        private String url;  
  
        public String getName() {  
            return name;  
        }  
  
        public void setName(String name) {  
            this.name = name;  
        }  
  
        public int getAge() {  
            return age;  
        }  
  
        public void setAge(int age) {  
            this.age = age;  
        }  
  
        public String getIntroduction() {  
            return introduction;  
        }  
  
        public void setIntroduction(String introduction) {  
            this.introduction = introduction;  
        }  
  
        public String getUrl() {  
            return url;  
        }  
  
        public void setUrl(String url) {  
            this.url = url;  
        }  
  
    }  
  
    private static final String SEARCH = "search";  
    private static final String NAME = "name";  
    private static final String AGE = "age";  
    private static final String INTRODUCTION = "introduction";  
    private static final String URL = "url";  
  
    /** 
     * DOM parse 
     *  
     * @param fileName 
     * @return 
     */  
    private List<SearchInfo> parserByDOM(String fileName) {  
        List<SearchInfo> infos = new ArrayList<SearchInfo>();  
        try {  
            // 加载xml文档  
            DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();  
            InputStream inputStream = getResources().getAssets().open(fileName);  
            // 找到根节点---searchs  
            NodeList nodes = builder.parse(inputStream).getDocumentElement().getElementsByTagName(SEARCH);  
            // 遍历根节点searchs下的所有子节点  
            for (int i = 0; i < nodes.getLength(); i++) {  
                SearchInfo info = new SearchInfo();  
                Element searchElement = (Element) nodes.item(i);  
                info.setName(searchElement.getAttribute(NAME));  
                info.setAge(Integer.parseInt(searchElement.getAttribute(AGE)));  
                Element introduction = (Element) searchElement.getElementsByTagName(INTRODUCTION).item(0);  
                info.setIntroduction(introduction.getFirstChild().getNodeValue());  
                Element url = (Element) searchElement.getElementsByTagName(URL).item(0);  
                info.setUrl(url.getFirstChild().getNodeValue());  
                infos.add(info);  
            }  
        } catch (ParserConfigurationException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (SAXException e) {  
            e.printStackTrace();  
        }  
        return infos;  
    }  
  
    /** 
     * SAX parse 
     *  
     * @param fileName 
     * @return 
     */  
    private List<SearchInfo> parserBySAX(String fileName) {  
        List<SearchInfo> infos = null;  
        try {  
            SAXParser parser = SAXParserFactory.newInstance().newSAXParser();  
            XMLReader reader = parser.getXMLReader();  
            SearchHander hander = new SearchHander();  
            reader.setContentHandler(hander);  
            reader.parse(new InputSource(getAssets().open(fileName)));  
            infos = hander.getSearchInfos();  
        } catch (ParserConfigurationException e) {  
            e.printStackTrace();  
        } catch (SAXException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return infos;  
    }  
  
    private class SearchHander extends DefaultHandler {  
  
        private SearchInfo info;  
        private List<SearchInfo> infos = new ArrayList<SearchInfo>();  
  
        private boolean isIntroduction = false;  
        private boolean isURL = false;  
  
        public List<SearchInfo> getSearchInfos() {  
            return infos;  
        }  
  
        // 开始读取标签  
        public void startElement(String uri, String localName, String qName, Attributes attributes) {  
            String tagName = localName.length() != 0 ? localName : qName;  
            tagName = tagName.toLowerCase().trim();  
            // 读取的是Search标签开始，则实例化SearchInfo  
            if (tagName.equals(SEARCH)) {  
                info = new SearchInfo();  
                info.setName(attributes.getValue(NAME));  
                info.setAge(Integer.parseInt(attributes.getValue(AGE)));  
            }  
            // 读取其他节点  
            if (tagName.equals(INTRODUCTION)) {  
                isIntroduction = true;  
            } else if (tagName.equals(URL)) {  
                isURL = true;  
            }  
        }  
  
        // 结束标签  
        public void endElement(String uri, String localName, String qName) {  
            String tagName = localName.length() != 0 ? localName : qName;  
            tagName = tagName.toLowerCase().trim();  
  
            // 读取的是Search标签结束，则把search添加进集合中  
            if (tagName.equals(SEARCH)) {  
                infos.add(info);  
            }  
            // 读取其他节点  
            if (tagName.equals(INTRODUCTION)) {  
                isIntroduction = false;  
            } else if (tagName.equals(URL)) {  
                isURL = false;  
            }  
        }  
  
        // 读取到节点内容时的回调  
        public void characters(char[] ch, int start, int length) {  
            if (isIntroduction) {  
                info.setIntroduction(new String(ch, start, length));  
            } else if (isURL) {  
                info.setUrl(new String(ch, start, length));  
            }  
        }  
  
    }  
  
    /** 
     * Pull parse 
     *  
     * @param fileName 
     * @return 
     */  
    private List<SearchInfo> parserByPULL(String fileName) {  
        List<SearchInfo> infos = new ArrayList<SearchInfo>();  
        XmlPullParser xmlParser = Xml.newPullParser();  
        InputStream inputStream = null;  
        try {  
            inputStream = getResources().getAssets().open(fileName);  
            xmlParser.setInput(inputStream, "utf-8");  
            int evtType = xmlParser.getEventType();  
            SearchInfo info = null;  
            while (evtType != XmlPullParser.END_DOCUMENT) {  
                switch (evtType) {  
                case XmlPullParser.START_TAG:  
                    String tag = xmlParser.getName();  
                    // 如果是search标签开始，则实例化对象  
                    if (tag.equalsIgnoreCase(SEARCH)) {  
                        info = new SearchInfo();  
                        // 取出search标签中的属性值  
                        info.setName(xmlParser.getAttributeValue(null, NAME));  
                        info.setAge(Integer.parseInt(xmlParser.getAttributeValue(null, AGE)));  
                    } else if (info != null) {  
                        if (tag.equalsIgnoreCase(INTRODUCTION)) {  
                            info.setIntroduction(xmlParser.nextText());  
                        } else if (tag.equalsIgnoreCase(URL)) {  
                            info.setUrl(xmlParser.nextText());  
                        }  
                    }  
                    break;  
                case XmlPullParser.END_TAG:  
                    // 如果遇到search标签结束，则把search对象添加进集合中  
                    if (xmlParser.getName().equalsIgnoreCase(SEARCH) && info != null) {  
                        infos.add(info);  
                        info = null;  
                    }  
                    break;  
                default:  
                    break;  
                }  
                // 如果xml没有结束，则导航到下一个river节点  
                evtType = xmlParser.next();  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (XmlPullParserException e) {  
            e.printStackTrace();  
        }  
        return infos;  
    }  
  
}  

search.xml

<?xml version="1.0" encoding="utf-8"?>  
<searchs>  
  
    <search  
        name="google" age="14" >  
        <introduction>Hi, This is google search!</introduction>  
        <url>http://www.google.com</url>  
    </search>  
  
    <search  
        name="baidu" age="12" >  
        <introduction>Hi, This is baidu search!</introduction>  
        <url>http://www.baidu.com</url>  
    </search>  
  
    <search  
        name="biying" age="3" >  
        <introduction>Hi, This is biying search!</introduction>  
        <url>http://www.biying.com</url>  
    </search>  
  
</searchs>