XML文件剖析汇总SAX/DOM/PULL的细致引见【XML教程】,PULL，DOM，SAX

阅读时若有疑问和毛病迎接批评提出或许加我企鹅1262135886 ,感谢支撑SAX 、DOM4J 、PULL剖析的区分

Sax特性（ SAX是Simple API for XML的简称）

1. 剖析效率高，占用内存少

2.可以随时住手剖析

3.不能载入悉数文档到内存

4.不能写入xml

5.SAX剖析xml文件采纳的是事宜驱动

pull与sax的不同之处

1.pull读取xml文件后触发相应的事宜挪用要领返回的是数字。

2.pull可以在递次中掌握，想剖析到哪里就可以住手到哪里

3.Android中更引荐运用pull剖析

DOM的特性

长处

1.悉数文档树在内存中，便于操纵；支撑删除、修正、从新排列等多种功用

2.经由过程树形组织存取xml文档

3.可以在树的某个节点上向前或向后挪动

瑕玷

1.将悉数文档调入内存（包含无用的节点），浪费时间和空间

实用场所

一旦剖析了文档还需屡次接见这些数据；硬件资本足够（内存，cpu）

起首定义我定义了一个Student.xml文件

**示例**

[code]<?xml version="1.0" encoding="utf-8"?>
<students>

    <student id="1" >

        <name>
小红
        </name>

        <age>
21
        </age>

        <sex>
女
        </sex>

        <adress>
上海
        </adress>
    </student>

    <student id="2" >

        <name>
小黑
        </name>

        <age>
22
        </age>

        <sex>
男
        </sex>

        <adress>
天津
        </adress>
    </student>

    <student id="3" >

        <name>
小网
        </name>

        <age>
23
        </age>

        <sex>
男
        </sex>

        <adress>
北京
        </adress>
    </student>

</students>

**1.sax剖析**

[code]package com.example.sax_xml;

import java.io.IOException;
import java.io.InputStream;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;

import android.app.Activity;
import android.content.res.AssetManager;
import android.os.Bundle;
import android.view.View;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void sax_xml(View v) {
        // 取得装备管理者对象
        AssetManager manager = this.getAssets();
        try {
            // 猎取到assets目录下的Student.xml文件输入流
            InputStream is = manager.open("Student.xml");
            /**
             * SAXParserFactory 定义了一个API工场，使得运用递次可以设置和取得一个基于SAX（Simple API for
             * XML
             * 
             * ）的剖析器，从而可以剖析XML文档( 原文： Defines a factory API that enables
             * applications to configure and obtain a SAX based parser to parse
             * XML documents. )
             * 
             * 它的组织器是受庇护的，因此只能用newInstance（）要领取得实例（ Protected constructor to
             * force use of newInstance(). ）
             */
            SAXParserFactory factory = SAXParserFactory.newInstance();

            /**
             * XmlReader 类是一个供应对 XML 数据的非缓存、只进只读接见的笼统基类。 该类相符 W3C 可扩大标记言语 (XML)
             * 1.0 和 XML 中的定名空间的发起。 XmlReader 类支撑从流或文件读取 XML 数据。
             * 该类定义的要领和属性使您可以阅读数据并读取节点的内容。 当前节点指读取器所处的节点。
             * 运用任何返回当前节点值的读取要领和属性推动读取器。 XmlReader 类使您可以： 1. 搜检字符是不是是正当的
             * XML字符，元素和属性的称号是不是是有用的 XML 称号。 2. 搜检 XML 文档的花样是不是准确。 3. 依据 DTD
             * 或架构考证数据。 4.从 XML流检索数据或运用提取模子跳过不须要的纪录。
             */
            XMLReader xmlReader = factory.newSAXParser().getXMLReader();
            /**
             * ContentHandler是Java类包中一个迥殊的SAX接口，位于org.xml.sax包中。该接口封装了一些对事宜处置惩罚的要领
             * ，当XML剖析器最先剖析XML输入文档时，它会碰到某些迥殊的事宜，比方文档的开首和完毕、元素开首和完毕、以及元素中的字符数据等事宜
             * 。当碰到这些事宜时，XML剖析器会挪用ContentHandler接口中相应的要领来相应该事宜。
             */
            //由于它是一个接口所以我直接编写一个类继续它的子类DefaultHandler，从新其要领
            ContentHandler handler = new ContentHandler();
            // 将ContentHandler的实例设置到XMLReader中
            // setContentHandler此要领设置 XML 读取器的内容处置惩罚递次
            xmlReader.setContentHandler(handler);
            // 最先实行剖析
            //InputSource：XML 实体的单一输入源。
            xmlReader.parse(new InputSource(is));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

**本身定义的ContentHandler类**

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

import android.util.Log;

public class ContentHandler extends DefaultHandler {

    private StringBuilder id;
    private StringBuilder name;
    private StringBuilder sex;
    private StringBuilder age;
    private StringBuilder adress;
    private String nodeName;// 纪录当前节点的名字

    // 最先xml剖析的时刻挪用
    @Override
    public void startDocument() throws SAXException {
        id = new StringBuilder();
        name = new StringBuilder();
        sex = new StringBuilder();
        age = new StringBuilder();
        adress = new StringBuilder();
    }

    // 最先剖析某个节点的时刻挪用
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        nodeName = localName;
    }

    // 猎取某个节点中的内容时挪用
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        if ("id".equals(nodeName)) {
            id.append(ch, start, length);
        } else if ("name".equals(nodeName)) {
            name.append(ch, start, length);
        } else if ("age".equals(nodeName)) {
            age.append(ch, start, length);
        } else if ("sex".equals(nodeName)) {
            sex.append(ch, start, length);
        } else if ("adress".equals(nodeName)) {
            adress.append(ch, start, length);
        }
    }

    //完成某个节点的剖析的时刻挪用
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        if ("student".equals(localName)) {
            Log.d("ContentHandler", "id is" + id.toString().trim());
            Log.d("ContentHandler", "name is" + name.toString().trim());
            Log.d("ContentHandler", "age is" + age.toString().trim());
            Log.d("ContentHandler", "sex is" + sex.toString().trim());
            Log.d("ContentHandler", "adress is" + adress.toString().trim());
            // 末了要将StringBuilder清空掉
            id.setLength(0);
            name.setLength(0);
            age.setLength(0);
            sex.setLength(0);
            adress.setLength(0);
        }
    }

    //完成悉数XML剖析的时刻挪用
    @Override
    public void endDocument() throws SAXException {
        // TODO Auto-generated method stub
        super.endDocument();
    }
}

**2.pull剖析**

[code]package com.example.xmlpull;

import android.app.Activity;
import android.content.res.AssetManager;
import android.os.Bundle;
import android.util.Log;
import android.util.Xml;
import android.view.View;
import android.widget.Toast;

import org.xmlpull.v1.XmlPullParser;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 
 *         读取到xml的声明返回数字0 START_DOCUMENT; 
 *         读取到xml的完毕返回数字1 END_DOCUMENT ;
 *         读取到xml的最先标签返回数字2 START_TAG 
 *         读取到xml的完毕标签返回数字3 END_TAG 
 *         读取到xml的文本返回数字4  TEXT
 * 
 */
public class MainActivity extends Activity {
    /**
     * 用于装载剖析出来的数据
     */
    private List<Map<String, Object>> oList;
    private Map<String, Object> oMap;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

    }

    public void btn_pull(View v) {
        // 猎取装备管理器对象
        AssetManager manager = this.getAssets();
        try {
            // 取得assets文件下的Student.xml文件输入流
            InputStream is = manager.open("Student.xml");
            // 取得pull剖析对象,它的组织器是受庇护的，因此只能用newInstance（）要领取得实例
            XmlPullParser parser = Xml.newPullParser();
            // 将xml文件输入流传给pull剖析对象
            parser.setInput(is, "UTF-8");
            // 猎取剖析时的事宜范例,
            int type = parser.getEventType();
            // 运用while轮回，假如剖析的事宜范例不等于全文档末了节点范例，一向剖析
            while (type != XmlPullParser.END_DOCUMENT) {
                // 取得当前的节点名字
                String nodeName = parser.getName();
                switch (type) {
                // 假如是全文档的最先节点范例
                case XmlPullParser.START_DOCUMENT:
                    // 初始化装载数据的鸠合
                    oList = new ArrayList<Map<String, Object>>();
                    break;

                // 假如是group最先节点范例
                case XmlPullParser.START_TAG:
                    // 依据剖析的节点名字举行推断
                    if ("students".equals(nodeName)) {

                    } else if ("student".equals(nodeName)) {
                        oMap = new HashMap<String, Object>();
                        // 取得group开首的student节点
                        String id = parser.getAttributeValue(0);
                        oMap.put("id", id);
                    } else if ("name".equals(nodeName)) {
                        // 节点对应的文本
                        String name = parser.nextText();
                        oMap.put("name", name);
                    } else if ("sex".equals(nodeName)) {
                        String sex = parser.nextText();
                        oMap.put("sex", sex);
                    } else if ("age".equals(nodeName)) {
                        String age = parser.nextText();
                        oMap.put("age", age);
                    } else if ("adress".equals(nodeName)) {
                        String adress = parser.nextText();
                        oMap.put("adress", adress);
                    }
                    break;

                // 到了group末了的节点
                case XmlPullParser.END_TAG:
                    if ("name".equals(nodeName)) {
                        Toast.makeText(this, "姓名剖析完成", Toast.LENGTH_LONG)
                                .show();
                    }
                    if ("student".equals(nodeName)) {
                        oList.add(oMap);
                    }
                    break;
                }

                //切换到下一个group
                type = parser.next();

            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        //末了遍历鸠合Log
        for (int i = 0; i < oList.size(); i++) {

            Log.e("error",
                    "name:" + oList.get(i).get("name") + "----sex:"
                            + oList.get(i).get("sex") + "----age:"
                            + oList.get(i).get("age") + "----address:"
                            + oList.get(i).get("adress"));
        }

    }

}

起首说一下DOM剖析须要注重的处所，由于讲这个的时刻我们先生就犯了这个毛病,这里迥殊指出一下

在这里当我们取得节点student时，也就是图中箭头所画的处所，假如我们挪用它的getChildNodes()要领，人人猜猜它的子节点有几个？不包含它的孙子节点，小红这类的除外，由于它是孙子节点。它总共有5个子节点，分别是图中黑色横线标记的那样。所以在剖析时，一定要警惕，不要疏忽空缺的处所。

下面附上细致剖析代码

这里我是把dom剖析的部份拆分成了一个东西类

[code]package com.example.domxml;

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

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

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

/**
 *Dom剖析是将xml文件悉数载入，组装成一颗dom树，
 *然后经由过程节点以及节点之间的关联来剖析xml文件,一层一层扒开
 */
public class Dom_xml_Util {
    private List<Student> list = new ArrayList<Student>();  
    public List<Student> getStudents(InputStream in) throws Exception{
        //猎取dom剖析工场，它的组织器是受庇护的，因此只能用newInstance（）要领取得实例
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        //运用当前设置的参数建立一个新的 DocumentBuilder 实例
        //DocumentBuilder使其从 XML 文档猎取 DOM 文档实例。
        //运用此类，运用递次员可以从 XML 猎取一个 Document
        DocumentBuilder builder = factory.newDocumentBuilder();  
        //猎取Document
        Document document = builder.parse(in); 
        //getDocumentElement()这是一种便利属性，该属性许可直接接见文档的文档元素的子节点
        //Element 接口示意 HTML 或 XML 文档中的一个元素
        Element element = document.getDocumentElement();  
        //以文档递次返回具有给定标记称号的一切子女 Elements 的 NodeList
        NodeList bookNodes = element.getElementsByTagName("student"); 
        //遍历NodeList
        //getLength()列表中的节点数
        for(int i=0;i<bookNodes.getLength();i++){  
            //返回鸠合中的第 i个项
            Element bookElement = (Element) bookNodes.item(i);  
            Student student = new Student();  
            //取得item大节点中的属性值。
            student.setId(Integer.parseInt(bookElement.getAttribute("id"))); 
            //取得大节点中的小节点的Nodelist
            NodeList childNodes = bookElement.getChildNodes();  
//          System.out.println("*****"+childNodes.getLength());  
            //遍历小节点
            for(int j=0;j<childNodes.getLength();j++){  
                /**
                 * getNodeType()示意基本对象的范例的节点
                 * Node.ELEMENT_NODE  该节点为 Element
                 * getNodeName()此节点的称号，取决于其范例
                 * getFirstChild() 此节点的第一个子节点
                 * getNodeValue()此节点的值，取决于其范例
                 */
                if(childNodes.item(j).getNodeType()==Node.ELEMENT_NODE){  
                    if("name".equals(childNodes.item(j).getNodeName())){  
                        student.setName(childNodes.item(j).getFirstChild().getNodeValue());  
                    }else if("age".equals(childNodes.item(j).getNodeName())){  
                        student.setAge(Integer.parseInt(childNodes.item(j).getFirstChild().getNodeValue()));  
                    }else if("sex".equals(childNodes.item(j).getNodeName())){  
                        student.setSex(childNodes.item(j).getFirstChild().getNodeValue());  
                    }else if("address".equals(childNodes.item(j).getNodeName())){  
                        student.setAddress(childNodes.item(j).getFirstChild().getNodeValue());  
                    }  
                }  
            }//end for j  
            list.add(student);  
        }//end for i  
        return list;
    }
}

Student.class

[code]package com.example.domxml;

public class Student {

    private int id;
    private String name;
    private int age;
    private String sex;
    private String address;
    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 int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }

}

在activity中挪用

activity_main

[code]<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <TextView
        android:id="@+id/tv_id"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
     <TextView
        android:id="@+id/tv_name"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
      <TextView
        android:id="@+id/tv_age"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
       <TextView
        android:id="@+id/tv_sex"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
        <TextView
        android:id="@+id/tv_adress"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</LinearLayout>

MainActivity

[code]package com.example.domxml;

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

import android.os.Bundle;
import android.app.Activity;
import android.content.res.AssetManager;
import android.view.Menu;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends Activity {

    private TextView tv_id,tv_name,tv_age,tv_sex,tv_adress;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv_id=(TextView)findViewById(R.id.tv_id);
        tv_name=(TextView)findViewById(R.id.tv_name);
        tv_age=(TextView)findViewById(R.id.tv_age);
        tv_sex=(TextView)findViewById(R.id.tv_sex);
        tv_adress=(TextView)findViewById(R.id.tv_adress);
    }
    public void bnt_parse(View v) 
    {
        AssetManager manager=getAssets();
        try {
            InputStream in=manager.open("Student.xml");
            List<Student> oList =new ArrayList<Student>();
            try {
                //返回一个泛型为Student的鸠合
                oList = new Dom_xml_Util().getStudents(in);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //遍历鸠合，取鸠合中的第一组数据
            for (int i = 0; i < oList.size(); i++) {
                tv_id.setText(oList.get(0).getId());
                tv_name.setText(oList.get(0).getName());
                tv_age.setText(oList.get(0).getAge());
                tv_sex.setText(oList.get(0).getSex());
                tv_adress.setText(oList.get(0).getAddress());
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

以上就是XML文件剖析汇总SAX/DOM/PULL的细致引见的细致内容，更多请关注ki4网别的相干文章！