Android学习之XML数据的三种解析方式以及生成XML文件

首先，我得声明，本博客的思想主要参考了此博客：http://blog.csdn.net/liuhe688/article/details/6415593

不过代码我自己一句句敲的

好了，首先讲一下解析XML的三种方式：（恕我粘贴一下哈）

SAX解析器：

SAX(Simple API for XML)解析器是一种基于事件的解析器，它的核心是事件处理模式，主要是围绕着事件源以及事件处理器来工作的。当事件源产生事件后，调用事件处理器相应的处理方法，一个事件就可以得到处理。在事件源调用事件处理器中特定方法的时候，还要传递给事件处理器相应事件的状态信息，这样事件处理器才能够根据提供的事件信息来决定自己的行为。

SAX解析器的优点是解析速度快，占用内存少。非常适合在Android移动设备中使用。

DOM解析器：

DOM是基于树形结构的的节点或信息片段的集合，允许开发人员使用DOM API遍历XML树、检索所需数据。分析该结构通常需要加载整个文档和构造树形结构，然后才可以检索和更新节点信息。

由于DOM在内存中以树形结构存放，因此检索和更新效率会更高。但是对于特别大的文档，解析和加载整个文档将会很耗资源。

PULL解析器：

PULL解析器的运行方式和SAX类似，都是基于事件的模式。不同的是，在PULL解析过程中，我们需要自己获取产生的事件然后做相应的操作，而不像SAX那样由处理器触发一种事件的方法，执行我们的代码。PULL解析器小巧轻便，解析速度快，简单易用，非常适合在Android移动设备中使用，Android系统内部在解析各种XML时也是用PULL解析器。

好了，介绍完三种解析方式，现在开始进行xml文件的解析与生成了。

首先需要在项目的assets目录里面放置一个xml文件来给我们此次做xml源文件，当然，实际应用当中，可以通过httpClient 或者URLConnection的方式进行获取服务器的xml文件来与服务器进行交互，这里我就直接放到项目里面了，方便操作一些，以下是我的xml文件，比较简单，实践的时候，可以自己随意想一种格式的xml文件：

<?xml version="1.0" encoding="utf-8"?>
<addresses>  
    <address>  
        <id>01</id>  
        <name>北京</name>  
        <money>10000</money>  
    </address>  
    <address>  
        <id>02</id>  
        <name>上海</name>  
        <money>8999</money>  
    </address>  
    <address>  
        <id>03</id>  
        <name>广州</name>  
        <money>7500</money>  
    </address>
    <address>  
        <id>04</id>  
        <name>深圳</name>  
        <money>8500</money>  
    </address>  
</addresses> 

首先，针对我这个xml文件新建一个Address类，用来封装数据:

package com.oysd.ouyangxml.model;

public class Address {
    
    private int id;
    private String name;
    private float money;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getMoney() {
        return money;
    }
    public void setMoney(float money) {
        this.money = money;
    }
    
    @Override
    public String toString() {
        
        return "id: " + id + "
" + 
               "name: " + name + "
" + 
               "money:" + money;
    }

}

然后就是新建一个接口类，为什么要新建一个接口类呢？因为我们这次需要使用三种方式来进行解析xml文件，
而且，每一次解析的时候，都需要调用这一种方式的解析方法，每一次生成xml文件的，也需要调用这种方式的生成方法，

那么，我们直接定义这个接口类，然后，在这个接口类里面声明两个方法，一个是解析xml的方法，另一个是生成xml文件的方法，

然后，让这三种方式都implements这个接口，然后都需要实现这个接口的两个方法，以下是AddressParser接口类：

package com.oysd.ouyangxml.parser;

import java.io.InputStream;
import java.util.List;

import com.oysd.ouyangxml.model.Address;

public interface AddressParser {
    
    /**
     * 解析xml的文件的输入流，返回Address对象集合
     * @param is
     * @return
     * @throws Exception
     */
    public List<Address> parser(InputStream is) throws Exception;
    
    /**
     * 序列化Address集合对象，形成xml形式的字符串
     * @param addresses
     * @return
     * @throws Exception
     */
    public String outPutXml(List<Address> addresses) throws Exception;

}

接口类做好之后，我们就可以按三种方式一一进行解析与生成了
第一：SAX解析与生成XML文件

以下代码是我的SaxAddressParser.java的代码：

package com.oysd.ouyangxml.parser;

import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.DefaultHandler;

import android.database.CursorJoiner.Result;

import com.oysd.ouyangxml.model.Address;


public class SaxAddressParser implements AddressParser{

    /**
     * 解析xml文件
     */
    @Override
    public List<Address> parser(InputStream is) throws Exception {
        //取得SAXParserFactory实例
        SAXParserFactory factory = SAXParserFactory.newInstance();
        //通过factory实例获取SAXParser实例
        SAXParser parser = factory.newSAXParser();
        //实例化自定义的Handler
        OuYangHandler oyHandler = new OuYangHandler();
        //根据自定义的Handler规则解析输入流
        parser.parse(is, oyHandler);
        return oyHandler.getAddresses();
    }

    /**
     * 将xml文件输出到文件
     */
    @Override
    public String outPutXml(List<Address> addresses) throws Exception {
        //取得SAXTransformerFactory实例 
        SAXTransformerFactory factory = (SAXTransformerFactory) TransformerFactory.newInstance();
        //从factory获取TransformerHandler实例
        TransformerHandler handler = factory.newTransformerHandler();
        //从handler获取Transformer实例 
        Transformer transformer = handler.getTransformer();
        
        // 设置输出采用的编码方式 
        transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
        // 是否自动添加额外的空白
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        // 是否忽略XML声明  
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
        
        StringWriter writer = new StringWriter();
        StreamResult result = new StreamResult(writer);
        handler.setResult(result);
        
        String uri = "";  //代表命名空间的URI 当URI无值时 须置为空字符串 
        String localName = "";  //命名空间的本地名称(不包含前缀) 当没有进行命名空间处理时 须置为空字符串 
        
        handler.startDocument();
        handler.startElement(uri, localName, "addresses", null);
        AttributesImpl attrs = new AttributesImpl(); //负责存放元素的属性信息  
        
        char ch [] = null;
        for(Address address:addresses){
            attrs.clear();
            //添加一个名为id的属性(type影响不大,这里设为string) 
            attrs.addAttribute(uri, localName, "id", "string", String.valueOf(address.getId()));
            //开始一个address元素 关联上面设定的id属性  
            handler.startElement(uri, localName, "address", attrs);
            //开始一个name元素 没有属性  
            handler.startElement(uri, localName, "name", null); 
            
            ch = String.valueOf(address.getName()).toCharArray();
            handler.characters(ch, 0, ch.length);//设置name元素的文本节点
            handler.endElement(uri, localName, "name");
            //开始一个money元素 没有属性
            handler.startElement(uri, localName, "money", null);
            ch = String.valueOf(address.getMoney()).toCharArray();
            handler.characters(ch, 0, ch.length);//设置money元素的文本节点
            handler.endElement(uri, localName, "money");
            handler.endElement(uri, localName, "address");
            
            
        }  
        handler.endElement(uri, localName, "addresses");
        handler.endDocument();
        return writer.toString();
    }
    
    
    public class OuYangHandler extends DefaultHandler{
        
        private List<Address> addresses;
        private Address address;
        private StringBuilder builder;
        
        
        /**
         * 返回解析后的Address对象集合
         * @return
         */
        public List<Address> getAddresses(){
            return addresses;
        }

        /**
         * characters方法被调用，我们可以获取节点内的文本信息
         */
        @Override
        public void characters(char[] ch, int start, int length)
                throws SAXException {
            super.characters(ch, start, length);
            //将读取的字符数组追加到builder中 
            builder.append(ch, start, length);
        }

        @Override
        public void endDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.endDocument();
        }

        /**
         * 执行到最后一个节点，endElement方法被调用，我们可以做收尾的相关操作
         */
        @Override
        public void endElement(String uri, String localName, String qName)
                throws SAXException {
            super.endElement(uri, localName, qName);
            
            if(localName.equals("id")){
                address.setId(Integer.parseInt(builder.toString()));
            }else if(localName.equals("name")){
                address.setName(builder.toString());
                
            }else if(localName.equals("money")){
                address.setMoney(Float.parseFloat(builder.toString()));
            }else if(localName.equals("address")){
                addresses.add(address);
            }
        }

        /**
         * 文档准备好之后，开始解析文档
         */
        @Override
        public void startDocument() throws SAXException {
            super.startDocument();
            //初始一下
            addresses = new ArrayList<Address>();
            builder = new StringBuilder();
        }

        /**
         * 当执行文档时遇到起始节点，startElement方法将会被调用
         */
        @Override
        public void startElement(String uri, String localName, String qName,
                Attributes attributes) throws SAXException {
            super.startElement(uri, localName, qName, attributes);
            if(localName.equals("address")){
                address = new Address();
            }
            builder.setLength(0);//将字符长度设置为0 以便重新开始读取元素内的字符节点 
        }
        
    }

}

稍微讲一下里面的解析xml的带代码，使用SAX解析xml，需要使用到DefaultHandler来处理解析过程中的一些事件

DefaultHandler是一个事件处理器，可以接收解析器报告的所有事件，处理所发现的数据。它实现了EntityResolver接口、DTDHandler接口、ErrorHandler接口和ContentHandler接口。这几个接口代表不同类型的事件处理器，我定义了一个OuYangHandler扩展至DefaultHandler,

最主要的是重写startElement方法、characters方法和endElement方法，

当执行文档时遇到起始节点，startElement方法将会被调用，我们可以获取起始节点相关信息；

然后characters方法被调用，我们可以获取节点内的文本信息；

最后endElement方法被调用，我们可以做收尾的相关操作。

还有就是里面的生成XML的方法，个人感觉使用SAX的这个方式来生成xml比较麻烦，不过，逻辑性也比较强，

牢记自己xml文件的格式，然后通过TransFormerHandler的实例handler来构造格式：

格式如下：

handler.startDocument();

　　handler.startElement();

　　　　handler.startElement();

　　　　handler.endElement();

      handler.endElement();

handler.endDocument();

至于中间的数据，通过handler.characters();方法进行赋值，这里需要传什么样的参数，就不仔细说了， 可以直接看源码；

解析完了xml文件返回了一个List<Address>，在MainActivity里面进行输出，布局就不贴了，超简陋，两个Button,一个TextView

package com.oysd.ouyangxml;

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import com.oysd.ouyangxml.model.Address;
import com.oysd.ouyangxml.parser.AddressParser;
import com.oysd.ouyangxml.parser.DomAddressParser;
import com.oysd.ouyangxml.parser.PullAddressParser;
import com.oysd.ouyangxml.parser.SaxAddressParser;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity implements OnClickListener {
    
    private Button btnParser;
    private Button btnOutPut;
    private TextView tvXML;

    private static final String TAG = "XML";
    private AddressParser parser;
    private List<Address> addresses;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }
    
    private void initView(){
        btnParser = (Button) findViewById(R.id.btnParser);
        btnOutPut = (Button) findViewById(R.id.btnOutPut);
        tvXML = (TextView) findViewById(R.id.tvXml);
        
        btnParser.setOnClickListener(this);
        btnOutPut.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub
        switch(v.getId()){
        case R.id.btnParser:
            try {
                InputStream is = getAssets().open("address.xml");
                parser = new SaxAddressParser();//SAX方式解析XML文件
                //parser = new DomAddressParser();//DOM方式解析XML文件
                //parser = new PullAddressParser();//PULL方式解析XML文件
                addresses = parser.parser(is);
                for(Address address : addresses){
                    Log.d(TAG , address.toString());
                    tvXML.append(address.toString());
                    tvXML.append("
");
                }
                
            } catch (Exception e) {
                // TODO Auto-generated catch block
                //Log.d(TAG, e.toString());
                e.printStackTrace();
                
            }
            break;
        case R.id.btnOutPut:
            try {
                    Process process = null;
                    DataOutputStream os = null;
                    try {
                        process = Runtime.getRuntime().exec("su");
                        os = new DataOutputStream(process.getOutputStream());
                        //os.writeBytes(command+"
");
                        os.writeBytes("exit
");
                        os.flush();
                        process.waitFor();
                    } catch (Exception e) {
                        Log.d("*** DEBUG ***", "Unexpected error - Here is what I know: "+e.getMessage());
                    }
                    finally {
                        try {
                            if (os != null) {
                                os.close();
                            }
                            process.destroy();
                        } catch (Exception e) {
                            // nothing
                        }
                    }
                String xml = parser.outPutXml(addresses);
                FileOutputStream fos = openFileOutput("address.xml", Context.MODE_PRIVATE);
                fos.write(xml.getBytes("UTF-8"));
                
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            
        }
        
    }
    
    
}

第二种：DOM方式解析与生成XML文件
以下是我的DomAddressParser.java的代码：

package com.oysd.ouyangxml.parser;

import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.oysd.ouyangxml.model.Address;


public class DomAddressParser implements AddressParser{

    @Override
    public List<Address> parser(InputStream is) throws Exception {
        List<Address> addresses = new ArrayList<Address>();
        //获得DocumentBuilderFactory实例 
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        //通过factory获得DocumentBuilder实例
        DocumentBuilder builder = factory.newDocumentBuilder();
        //解析输入的xml文件，获取Document实例
        Document doc = builder.parse(is);
        Element rootElement = doc.getDocumentElement();//获取到根节点
        NodeList items = rootElement.getElementsByTagName("address");
        for (int i = 0; i < items.getLength(); i++) {
            Address address = new Address();
            Node item = items.item(i);
            NodeList properties = item.getChildNodes();
            for (int j = 0; j < properties.getLength(); j++) {
                Node property = properties.item(j);
                String nodeName = property.getNodeName();
                if(nodeName.equals("id")){
                    address.setId(Integer.parseInt(property.getFirstChild().getNodeValue()));
                }else if(nodeName.equals("name")){
                    address.setName(property.getFirstChild().getNodeValue());
                    
                }else if(nodeName.equals("money")){
                    address.setMoney(Float.parseFloat(property.getFirstChild().getNodeValue()));
                }
            }
            addresses.add(address);
        }
        return addresses;
    }

    @Override
    public String outPutXml(List<Address> addresses) throws Exception {
        
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.newDocument();//由builder创建新文档
        Element rootElement = doc.createElement("addresses");
        for(Address address:addresses){
            Element addressElement = doc.createElement("address");
            addressElement.setAttribute("id", address.getId() + "");
            
            Element nameElement = doc.createElement("name");
            nameElement.setTextContent(address.getName());
            addressElement.appendChild(nameElement);
            
            Element moneyElement = doc.createElement("money");
            moneyElement.setTextContent(String.valueOf(address.getMoney()));
            addressElement.appendChild(moneyElement);
            
            rootElement.appendChild(addressElement);
        }
        doc.appendChild(rootElement);
        
        TransformerFactory transFactory = TransformerFactory.newInstance();
        Transformer transformer = transFactory.newTransformer();
        transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");//设置编码
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");//自动添加额外空白处
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");//是否忽略xml声明
        
        
        StringWriter writer = new StringWriter();
        
        Source source = new DOMSource(doc);//声明文档来源是doc
        Result result = new StreamResult(writer);//表明目标结果为writer  
        transformer.transform(source, result); //开始转换
        
        return writer.toString();
    }
    

}

解析XML的文件的步骤差不多
生成XML的格式（通过Document实例对象doc来设置好格式）：

doc.createElement();

　　doc.createElement();

　　　　doc.createElement();

　　　　doc.appendChild();

　　doc.appendChild();

doc.appendChild();

其中添加具体的数据使用：Element实例对象进行setTextContent来设置值

调用这种方式，在MainActivity里面实例对象的时候，换一个类就好了

第三步：使用PULL解析与生成XML文件

以下是PullAddressParser.java的代码：

package com.oysd.ouyangxml.parser;

import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlSerializer;

import android.util.Log;
import android.util.Xml;

import com.oysd.ouyangxml.model.Address;

public class PullAddressParser implements AddressParser{

    private static final String TAG = "PullAddressParser";
    
    @Override
    public List<Address> parser(InputStream is) throws Exception {
        
        List<Address> addresses = null;
        Address address = null;
        //由android.util.Xml创建一个XmlPullParser实例  
        XmlPullParser parser = Xml.newPullParser();
        //设置输入流 并指明编码方式  
        parser.setInput(is, "utf-8");
        int eventType = parser.getEventType();
        while(eventType != XmlPullParser.END_DOCUMENT){
            String str = parser.getName();
            
            switch(eventType){
            case XmlPullParser.START_DOCUMENT:
                addresses = new ArrayList<Address>();
                break;
            case XmlPullParser.START_TAG:
                if(parser.getName().equals("address")){
                    address = new Address();
                    
                }else if(parser.getName().equals("id")){
                    //Log.d(TAG, parser.getText());
                    eventType = parser.next();
                    //Log.d(TAG, parser.getText());
                    address.setId(Integer.parseInt(parser.getText()));
                    
                }else if(parser.getName().equals("name")){
                    //Log.d(TAG, parser.getText());
                    eventType = parser.next();
                    //Log.d(TAG, parser.getText());
                    address.setName(parser.getText());
                    
                }else if(parser.getName().equals("money")){
                    //Log.d(TAG, parser.getText());
                    
                    eventType = parser.next();
                    //Log.d(TAG, parser.getText());
                    address.setMoney(Float.parseFloat(parser.getText()));
                    
                }
                break;
            case XmlPullParser.END_TAG:
                if(parser.getName().equals("address")){
                    addresses.add(address);
                    address = null;
                }
                break;
            }
            //Log.d(TAG, parser.getText());
            eventType = parser.next();
            //Log.d(TAG, parser.getText());
        }
        
        return addresses;
    }

    @Override
    public String outPutXml(List<Address> addresses) throws Exception {
        
        XmlSerializer serializer = Xml.newSerializer();//由android.util.Xml创建一个XmlSerializer实例 
        StringWriter writer = new StringWriter();
        serializer.setOutput(writer);//设置输出方向为writer
        serializer.startDocument("utf-8", true);
        serializer.startTag("", "addresses");
        for(Address address : addresses){
            serializer.startTag("", "book");  
            serializer.attribute("", "id", address.getId() + "");  
            serializer.startTag("", "name");  
            serializer.text(address.getName());  
            serializer.endTag("", "name");
            serializer.startTag("", "moeny");  
            serializer.text(address.getMoney() + "");  
            serializer.endTag("", "money"); 

            serializer.endTag("", "address");
        }
        serializer.endTag("", "addresses");  
        serializer.endDocument();  
        return writer.toString();
    }

}

生成XML文件的格式（直接通过XmlSeriaizer实例对象serializer进行生成格式）：

serializer.startDocument();

　　serializer.startTag();

　　　　serializer.startTag();

　　　　serializer.endTag();

　　serializer.endTag();

serializer.endDocument();

设置值的时候，使用：serializer.Text();

对于这三种解析器各有优点，其中PULL解析器方便快捷，因为SAX解析器操作起来太笨重，DOM不适合文档较大，内存较小的场景，唯有PULL轻巧灵活，速度快，占用内存小，使用非常顺手。各位按自己的爱好来选择吧