xml数据解析

 

什么是 XML?

XML 指可扩展标记语言（EXtensible Markup Language）
XML 是一种标记语言，很类似 HTML
XML 的设计宗旨是传输数据，而非显示数据
XML 标签没有被预定义。您需要自行定义标签。
XML 被设计为具有自我描述性。

 


XML 语法规则

所有 XML 元素都须有关闭标签
XML 标签对大小写敏感
XML 必须正确地嵌套
　　在 HTML 中，常会看到没有正确嵌套的元素：
　　　　<b><i>This text is bold and italic</b></i>
　　在 XML 中，所有元素都必须彼此正确地嵌套：
　　　　<b><i>This text is bold and italic</i></b>
　　在上例中，正确嵌套的意思是：由于 <i> 元素是在 <b> 元素内打开的，那么它必须在 <b> 元素内关闭。
XML 文档必须有根元素
XML 的属性值须加引号 <note date="08/08/2008">
　　属性值必须被引号包围，不过单引号和双引号均可使用
　　如果属性值本身包含双引号，那么有必要使用单引号包围它，或者可以使用实体引用
实体引用
　　在 XML 中，一些字符拥有特殊的意义。
　　如果你把字符 "<" 放在 XML 元素中，会发生错误，这是因为解析器会把它当作新元素的开始。
　　在 XML 中，有 5 个预定义的实体引用：
　　　　&lt; < 小于
　　　　&gt; > 大于
　　　　&amp; & 和号
　　　　&apos; ' 单引号
　　　　&quot; " 引号
　　在 XML 中，只有字符 "<" 和 "&" 确实是非法的。大于号是合法的，但是用实体引用来代替它是一个好习惯。
XML 中的注释
　　<!-- This is a comment -->
XML 中，空格会被保留
XML 以 LF 存储换行
应该尽量避免使用属性，而使用子元素代替
　　<person sex="female">
　　<firstname>Anna</firstname>
　　<lastname>Smith</lastname>
　　</person>
　　最好写为:
　　<person>
　　<sex>female</sex>
　　<firstname>Anna</firstname>
　　<lastname>Smith</lastname>
　　</person> 

XML 命名规则

XML 元素必须遵循以下命名规则：
名称可以含字母、数字以及其他的字符
名称不能以数字或者标点符号开始
名称不能以字符 “xml”（或者 XML、Xml）开始
名称不能包含空格
可使用任何名称，没有保留的字词。

　　最佳命名习惯

使名称具有描述性。使用下划线的名称也很不错。
名称应当比较简短，比如：<book_title>，而不是：<the_title_of_the_book>。
避免 "-" 字符。如果您按照这样的方式进行命名："first-name"，一些软件会认为你需要提取第一个单词。
避免 "." 字符。如果您按照这样的方式进行命名："first.name"，一些软件会认为 "name" 是对象 "first" 的属性。
避免 ":" 字符。冒号会被转换为命名空间来使用（稍后介绍）。
XML 文档经常有一个对应的数据库，其中的字段会对应 XML 文档中的元素。有一个实用的经验，即使用数据库的名称规则来命名 XML 文档中的元素。
非英语的字母比如 éòá 也是合法的 XML 元素名，不过需要留意当软件开发商不支持这些字符时可能出现的问题。


形式良好的 XML 文档


“形式良好”或“结构良好”的 XML 文档拥有正确的语法。
“形式良好”（Well Formed）的 XML 文档会遵守 XML 语法规则：
XML 文档必须有根元素
XML 文档必须有关闭标签
XML 标签对大小写敏感
XML 元素必须被正确的嵌套
XML 属性必须加引号
　　<?xml version="1.0" encoding="ISO-8859-1"?>
　　<note>
　　<to>George</to>
　　<from>John</from>
　　<heading>Reminder</heading>
　　<body>Don't forget the meeting!</body>
　　</note>

 

xml解析方法，对以下的xml文件

<?xml version="1.0" encoding="UTF-8"?>
<Persons>
    <Person id="1">
        <name>张三</name>
        <age>29</age>
    </Person>
    <Person id="2">
        <name>李小姐</name>
        <age>39</age>
        <male>false</male>
    </Person>
    <Person id="3">
        <name>赵五</name>
        <age>21</age>
        <country>中国</country>
    </Person>
</Persons>

DOM解析

DOM是基于树形结构的的节点或信息片段的集合，允许开发人员使用DOM API遍历XML树、检索所需数据。分析该结构通常需要加载整个文档和构造树形结构，然后才可以检索和更新节点信息。
利用DOM中的对象，可以对XML文档进行读取、搜索、修改、添加和删除等操作。
DOM的工作原理：使用DOM对XML文件进行操作时，首先要解析文件，将文件分为独立的元素、属性和注释等，然后以节点树的形式在内存中对XML文件进行表示，就可以通过节点树访问文档的内容，并根据需要修改文档。
DOM实现时首先为XML文档的解析定义一组接口，解析器读入整个文档，然后构造一个驻留内存的树结构，这样代码就可以使用DOM接口来操作整个树结构。
优缺点：由于DOM在内存中以树形结构存放，因此检索和更新效率会更高。但是对于特别大的文档，解析和加载整个文档将会很耗资源。 当然，如果XML文件的内容比较小，采用DOM是可行的。

常用的DoM接口和类：

Document：该接口定义分析并创建DOM文档的一系列方法，它是文档树的根，是操作DOM的基础。
Element：该接口继承Node接口，提供了获取、修改XML元素名字和属性的方法。
Node：该接口提供处理并获取节点和子节点值的方法。
NodeList：提供获得节点个数和当前节点的方法。这样就可以迭代地访问各个节点。
DOMParser：该类是Apache的Xerces中的DOM解析器类，可直接解析XML文件。


采用DOM解析时具体处理步骤是：

1 首先利用DocumentBuilderFactory创建一个DocumentBuilderFactory实例
2 然后利用DocumentBuilderFactory创建DocumentBuilder
3 然后加载XML文档（Document）
4 然后获取文档的根结点(Element)
5 然后获取根结点中所有子节点的列表（NodeList）
6 然后使用再获取子节点列表中的需要读取的结点

package com.disyoul.dom;

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

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

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import android.util.Log;

import com.diysoul.pull.Person;

public class PersonXmlDom {

    private static final String TAG = "dom";

    private static final String TAG_PERSON = "Person";
    private static final String TAG_ID = "id";
    private static final String TAG_NAME = "name";
    private static final String TAG_AGE = "age";
    private static final String TAG_MALE = "male";
    private static final String TAG_COUNTRY = "country";

    public PersonXmlDom() {
    }

    public List<Person> parseXml(InputStream inputStream) {
        List<Person> list = new ArrayList<Person>();
        try {
            DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
            Document document = builder.parse(inputStream);

            NodeList personNodes = document.getElementsByTagName(TAG_PERSON);
            Element element;
            String tempString;
            String nodeName;
            Node node;
            Person person;
            for (int i = 0; i < personNodes.getLength(); i++) {
                person = new Person();
                element = (Element) personNodes.item(i);
                tempString = element.getAttribute(TAG_ID);
                setAttribute(person, TAG_ID, tempString);
                NodeList attrNodes = element.getChildNodes();
                for (int j = 0; j < attrNodes.getLength(); j++) {
                    node = attrNodes.item(j);

                    if (node.getNodeType() == Node.ELEMENT_NODE) {
                        nodeName = node.getNodeName();
                        tempString = node.getFirstChild().getNodeValue();
                        setAttribute(person, nodeName, tempString);
                    }
                }
                list.add(person);
            }
        } catch (ParserConfigurationException e) {
            Log.e(TAG, "", e);
        } catch (SAXException e) {
            Log.e(TAG, "", e);
        } catch (IOException e) {
            Log.e(TAG, "", e);
        }
        return list;
    }

    /**
     * 设置Person的属性值
     * 
     * @param person
     * @param tag
     * @param value
     * @return
     */
    private boolean setAttribute(Person person, String tag, String value) {
        print("setAttribute--> tag=" + tag + ", value:" + value);
        if (person == null)
            return false;

        if (TAG_ID.equals(tag)) {
            if (value != null)
                person.setId(Integer.parseInt(value));
            return true;
        }
        if (TAG_NAME.equals(tag)) {
            person.setName(value);
            return true;
        }
        if (TAG_AGE.equals(tag)) {
            if (value != null)
                person.setAge(Integer.parseInt(value));
            return true;
        }
        if (TAG_MALE.equals(tag)) {
            if (value != null)
                person.setMale(Boolean.parseBoolean(value));
            return true;
        }
        if (TAG_COUNTRY.equals(tag)) {
            person.setCountry(value);
            return true;
        }

        return false;
    }

    public void print(String s) {
        // Log.d(TAG, "" + s);
    }
}

SAX解析

SAX(Simple API for XML)解析器是一种基于事件的解析器，事件驱动的流式解析方式是，从文件的开始顺序解析到文档的结束，不可暂停或倒退。它的核心是事件处理模式，
主要是围绕着事件源以及事件处理器来工作的。当事件源产生事件后，调用事件处理器相应的处理方法，一个事件就可以得到处理。在事件源调用事件处理器中特定方法的时候，
还要传递给事件处理器相应事件的状态信息，这样事件处理器才能够根据提供的事件信息来决定自己的行为。
SAX解析器的优点是解析速度快，占用内存少。非常适合在Android移动设备中使用。
SAX的工作原理：SAX的工作原理简单地说就是对文档进行顺序扫描，当扫描到文档(document)开始与结束、元素(element)开始与结束、文档(document)结束等地方时通知事件处理函数，由事件处理函数做相应动作，然后继续同样的扫描，直至文档结束。
在SAX接口中，事件源是org.xml.sax包中的XMLReader，它通过parser()方法来解析XML文档，并产生事件。
事件处理器是org.xml.sax包中ContentHander、DTDHander、ErrorHandler，以及EntityResolver这4个接口。XMLReader通过相应事件处理器注册方法setXXXX()来完成的与ContentHander、DTDHander、ErrorHandler，以及EntityResolver这4个接口的连接。

常用的SAX接口和类：

Attrbutes：用于得到属性的个数、名字和值。
ContentHandler：定义与文档本身关联的事件(例如，开始和结束标记)。大多数应用程序都注册这些事件。
DTDHandler：定义与DTD关联的事件。它没有定义足够的事件来完整地报告DTD。如果需要对DTD进行语法分析，请使用可选的DeclHandler。
DeclHandler是SAX的扩展。不是所有的语法分析器都支持它。
EntityResolver：定义与装入实体关联的事件。只有少数几个应用程序注册这些事件。
ErrorHandler：定义错误事件。许多应用程序注册这些事件以便用它们自己的方式报错。
DefaultHandler：它提供了这些接LI的缺省实现。在大多数情况下，为应用程序扩展DefaultHandler并覆盖相关的方法要比直接实现一个接口更容易。

采用SAX解析时具体处理步骤是：

1 创建SAXParserFactory对象
2 根据SAXParserFactory.newSAXParser()方法返回一个SAXParser解析器
3 根据SAXParser解析器获取事件源对象XMLReader
4 实例化一个DefaultHandler对象
5 连接事件源对象XMLReader到事件处理类DefaultHandler中
6 调用XMLReader的parse方法从输入源中获取到的xml数据
7 通过DefaultHandler返回我们需要的数据集合。

    public List<Map<String, String>> getList(InputStream is) {
        try {
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser saxParser = factory.newSAXParser();
            PersonSaxHandler handler = new PersonSaxHandler("Person");
            saxParser.parse(is, handler);
            return handler.getList();
        } catch (Exception e) {
        }
        
        return null;
    }

  

package com.diysoul.sax;

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

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

//<?xml version="1.0" encoding="UTF-8"?>
//<Persons>
//    <Person id="1">
//        <name>张三</name>
//        <age>29</age>
//    </Person>
//    <Person id="2">
//        <name>李小姐</name>
//        <age>39</age>
//        <male>false</male>
//    </Person>
//    <Person id="3">
//        <name>赵五</name>
//        <age>21</age>
//    </Person>
//</Persons>
// Sax解析原理:
//    对一个格式良好的xml文件，如上面的信息:
//    读取到<?xml version="1.0" encoding="UTF-8"?>时调用startDocument，如果含有值，将携带在Attributes中。
//    遇到文档开始标签的时侯即读取到<时调用startElement，然后调用characters。
//    遇到文档结束标签的时侯即读取到</时调用endElement，然后调用characters，此时传入的值为空。
//    文档结束时调用endDocument。
public class PersonSaxHandler extends DefaultHandler {

    /** 要解析的开始节点 */
    private String mNode;
    /** 正在解析的节点 */
    private String mCurrentTag;
    /** 保存返回的结果 */
    private List<Map<String, String>> mListResult;
    /** 保存每一个Person信息 */
    private Map<String, String> mPersonMap;

    public PersonSaxHandler(String nodeName) {
        mNode = nodeName;
    }

    @Override
    public void startDocument() throws SAXException {
        mListResult = new ArrayList<Map<String, String>>();
    }

    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        print("[startElement]localName=" + localName + " , qName=" + qName);
        if (qName.equals(mNode)) {
            mPersonMap = new HashMap<String, String>();
        } else {
            mCurrentTag = qName;
        }
        if (attributes != null && mPersonMap != null) {
            for (int i = 0; i < attributes.getLength(); i++) {
                mPersonMap.put(attributes.getQName(i), attributes.getValue(i));
                print(attributes.getQName(i) + " : " + attributes.getValue(i));
            }
        }
    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        if (mCurrentTag != null && mPersonMap != null) {
            String value = new String(ch, start, length);
            print("[characters]value=" + value);
            if (value != null) {
                value = value.trim();
                if (!value.equals("") && !value.equals("
"))
                    mPersonMap.put(mCurrentTag, value);
            }
        }
        mCurrentTag = null;
    }

    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        print("[endElement]localName=" + localName + " , qName=" + qName);
        if (qName.equals(mNode)) {
            if (mPersonMap != null) {
                mListResult.add(mPersonMap);
                mPersonMap = null;
            }
        }
    }

    @Override
    public void endDocument() throws SAXException {
        print("[endDocument]");
    }

    public List<Map<String, String>> getList() {
        return mListResult;
    }

    private void print(String s) {
        // System.out.println(s);
    }
}

　　

pull解析

pull解析器允许从解析器中获取事件，这与SAX解析器自动将事件推入处理程序相反。PULL解析器的运行方式和SAX类似，都是基于事件的模式。不同的是，在PULL解析过程中返回的是数字，且我们需要自己获取产生的事件然后做相应的操作，而不像SAX那样由处理器触发一种事件的方法，执行我们的代码。

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


常用的XML pull的接口和类：

XmlPullParser：XML pull解析器是一个在XMLPULL VlAP1中提供了定义解析功能的接口。
XmlSerializer：它是一个接口，定义了XML信息集的序列。
XmlPullParserFactory：这个类用于在XMPULL V1 API中创建XML Pull解析器。
XmlPullParserException：抛出单一的XML pull解析器相关的错误。

package com.diysoul.pull;

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

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;

import android.content.Context;
import android.content.res.XmlResourceParser;
import android.util.Log;

// Pull解析器的运行方式与 SAX，但它需要调用next方法进下一步解析，并返回相应的event类型，并不提供回调。
// 当元素开始解析时，调用parser.nextText()方法可以获取Text类型节点的值。
public class PersonXmlPullTools {

    private static final String TAG = "System.out";

    private static final String TAG_PERSON = "Person";
    private static final String TAG_ID = "id";
    private static final String TAG_NAME = "name";
    private static final String TAG_AGE = "age";
    private static final String TAG_MALE = "male";
    private static final String TAG_COUNTRY = "country";

    public PersonXmlPullTools() {
    }

    /**
     * 使用 android 封装的类型进行解析，id指向的资源定义在res/xml中
     * 
     * @param context
     * @param id
     * @return
     */
    public List<Person> parseXml(Context context, int id) {

        XmlResourceParser parser = context.getResources().getXml(id);
        List<Person> list = parse(parser);
        return list;
    }

    /**
     * 使用与pull库解析，android系统已包含了相应的库，java中需要自行下载并导入xmlpull_xxx.jar
     * 解析原生的xml文件，android系统中xml文件放置到assets中
     * 
     * @param is
     *            输入流
     * @param encode
     *            编码格式，必须和is流中的对象编码一致
     * @return
     */
    public List<Person> parseXml(InputStream is, String encode) {
        List<Person> list = null;
        XmlPullParser parser = null;
        try {
            parser = XmlPullParserFactory.newInstance().newPullParser();
            parser.setInput(is, encode);
            list = parse(parser);
        } catch (XmlPullParserException e) {
            Log.e(TAG, "", e);
        }
        return list;
    }

    private List<Person> parse(XmlPullParser parser) {
        List<Person> list = null;
        Person person = null;
        String tag;
        try {
            int eventType = parser.getEventType();
            while (eventType != XmlPullParser.END_DOCUMENT) {
                switch (eventType) {
                case XmlPullParser.START_DOCUMENT:
                    list = new ArrayList<Person>();
                    break;

                case XmlPullParser.START_TAG:
                    print("[START_TAG]");
                    tag = parser.getName();
                    print(tag);
                    if (checkTag(TAG_PERSON, tag)) {
                        person = new Person();
                        int cnt = parser.getAttributeCount();
                        for (int i = 0; i < cnt; i++) {
                            tag = parser.getAttributeName(i);
                            print("attr:" + tag);
                            setAttribute(person, tag, parser.getAttributeValue(i));
                        }
                    } else {
                        if (isDefinedTag(tag)) {
                            String value = parser.nextText(); // 取得该节点的内容
                            setAttribute(person, tag, value);
                        }
                    }
                    break;

                case XmlPullParser.END_TAG:
                    print("[END_TAG]");
                    tag = parser.getName();
                    print("attr:" + tag);
                    if (checkTag(TAG_PERSON, tag)) {
                        list.add(person);
                        person = null;
                    }
                    break;
                }
                eventType = parser.next();
            }

        } catch (XmlPullParserException e) {
            Log.e(TAG, "", e);
            return null;
        } catch (IOException e) {
            Log.e(TAG, "", e);
            return null;
        }

        return list;
    }

    /**
     * 判断两个tag的值是否相等
     * 
     * @param destTag
     * @param tag
     * @return
     */
    private boolean checkTag(String destTag, String tag) {
        print("checktag: " + destTag + "," + tag);
        if (destTag.equals(tag)) {
            return true;
        }
        return false;
    }

    private boolean isDefinedTag(String tag) {
        if (checkTag(TAG_ID, tag))
            return true;
        if (checkTag(TAG_NAME, tag))
            return true;
        if (checkTag(TAG_AGE, tag))
            return true;
        if (checkTag(TAG_MALE, tag))
            return true;
        if (checkTag(TAG_COUNTRY, tag))
            return true;
        return false;
    }

    /**
     * 设置Person的属性值
     * 
     * @param person
     * @param tag
     * @param value
     * @return
     */
    private boolean setAttribute(Person person, String tag, String value) {
        print("setAttribute--> tag=" + tag + ", value:" + value);
        if (person == null)
            return false;

        if (TAG_ID.equals(tag)) {
            if (value != null)
                person.setId(Integer.parseInt(value));
            return true;
        }
        if (TAG_NAME.equals(tag)) {
            person.setName(value);
            return true;
        }
        if (TAG_AGE.equals(tag)) {
            if (value != null)
                person.setAge(Integer.parseInt(value));
            return true;
        }
        if (TAG_MALE.equals(tag)) {
            if (value != null)
                person.setMale(Boolean.parseBoolean(value));
            return true;
        }
        if (TAG_COUNTRY.equals(tag)) {
            person.setCountry(value);
            return true;
        }

        return false;
    }

    private void print(String s) {
        // Log.d(TAG, "" + s);
    }
}
package com.diysoul.pull;

public class Person {

    int mId;
    String mName;
    int mAge;
    boolean mMale = true;
    String mCountry;

    public Person() {

    }

    public int getId() {
        return mId;
    }

    public Person setId(int id) {
        mId = id;
        return this;
    }

    public String getName() {
        return mName;
    }

    public Person setName(String name) {
        mName = name;
        return this;
    }

    public int getAge() {
        return mAge;
    }

    public Person setAge(int age) {
        mAge = age;
        return this;
    }

    public boolean isMale() {
        return mMale;
    }

    public Person setMale(boolean male) {
        mMale = male;
        return this;
    }

    public String getCountry() {
        return mCountry;
    }

    public Person setCountry(String country) {
        mCountry = country;
        return this;
    }

    @Override
    public String toString() {
        return "Person [mId=" + mId + ", mName=" + mName + ", mAge=" + mAge + ", mMale=" + mMale
                + ", mCountry=" + mCountry + "]";
    }
}
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/diysoul/p/5516426.html