Android 之xml解析

HTTP网络传输中的数据组织方式有三种方式：1、HTML方式2、XML方式 3、JSON方式

XML称为可扩展标记语言，它与HTML一样，都是SGML(标准通用标记语言)

XML是Internet环境中跨平台的，依赖于内容技术，是当前处理结构化文档信息的有力工具，可扩展标记语言XML是一种简单的数据存储语言，使用一系列简单的标记描述数据。

xml文件的节点的种类，一种是ElementNode，一种是TextNode。像<persons>、<person>这种节点就属于ElementNode,而name、age这种就属于TextNode。

XML结构示意图：

<?xml version="1.0" encoding="UTF-8"?>
<persons>
    <person id="23">
      <name>jack</name>
      <age>30</age>
   </person>
    <person id="20">
      <name>rose</name>
      <age>25</age>
    </person>
</persons>

XML的结构解析如下：1、节点   2、元素    3 、属性和属性值

由于XML的扩展性强，致使它需要有稳定的基础规则来支持扩展，该语法规则是：1、开始和结束标签匹配;2、嵌套标签不能互相嵌套;3、区分大小写

Android中，常见的XML解析器分别为:

SAX解析器:SAX(org.xml.sax)Simple API for XML，以事件的形式通知程序，对Xml进行解析。

DOM解析器:DOM(org.w3c.dom)“文档对象模型”方式，解析完的Xml将生成一个树状结构的对象。（不推荐）

PULL解析器:XMLPULL(org.xmlpull.v1)类似于SAX方式，程序以“拉取”的方式对Xml进行解析。

---------------------

SAX解析器:是一种以事件驱动的XML api，由它定义的事件流可以指定从解析器传到专门的处理程序的代码的XML结构，

简单的讲，它解析速度快，占用内存少的解析器。这种解析器比较适合android 等移动设备。

使用SAX的优点是：因为SAX的优势是流的方式处理，当遇到一个标签的时候，并不会记录下当前所碰到的标签。也就是说，

startElement方法中，你所知道的信息，仅仅是当前的签名的名字和属性，至于标签的嵌套结构，上层标签的名字，是否有子元素与其他结构相关的信息，都是不知道的。

xml文件被Sax解析器载入，由于Sax解析是按照xml文件的顺序来解析，当读入<?xml.....>时，会调用startDocument()方法;

当读入<books>的时候，由于它是个ElementNode，所以会调用startElement(String uri, String localName, String qName, Attributes attributes) 方法，其中第二个参数就是节点的名称，注意：由于有些环境不一样，有时候第二个参数有可能为空，所以可以使用第三个参数，因此在解析前，先调用一下看哪个参数能用，第4个参数是这个节点的属性;

这里我们不需要这个节点，所以从<book>这个节点开始，也就是图中1的位置，当读入时，调用startElement(....)方法，由于只有一个属性id，可以通过attributes.getValue(0)来得到;

然后在图中标明2的地方会调用characters(char[] ch, int start, int length)方法，不要以为那里是空白，Sax解析器可不那么认为，Sax解析器会把它认为是一个TextNode。

但是这个空白不是我们想要的数据，我们是想要<name>节点下的文本信息。这就要定义一个TAG，在characters(.....)方法中，判断当前节点是不是name，是再取值，才能取到thinking in java。

 

示例：将以上xml文件内容的id name age解析到hashmap中

第一步 定义handler类继承DefaultHandler并重写以下四个方法：

(org.xml.sax.helpers.DefaultHandler;)事件处理默认基类，需要用到的主要方法有:startDocument,接收到文档开始的通知;startElement,接收到元素开始的通知;characters,接收到元素中字符数据的通知;endElement，接收到结束解析的通知

 

1 定义变量：存储单个解析的完整对象HashMap<String, String> map

存储所有的解析对象 List<HashMap<String,String>> list
正在解析的元素的标签 String currentTag=null;
解析当前元素的值 String currentVal=null;
解析当前节点名称String nodeName=null;

并为list对象生成get方法和在构造方法中传递正在解析的节点名称

       2.完成方法：

       3.定义service 创建SAXParserFactory对象 SAXParser对象来解析xml,通过定义的list的get方法返回

        4.定义http工具类 返回xml从服务器返回的输入流

        5.建立测试类 指定网络路径

myHandler.java

package com.sax.handler;

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

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

 

public class myHandler extends DefaultHandler{

    private HashMap<String, String> map=null;//存储单个解析的完整对象
    private List<HashMap<String,String>> list=null;//存储所有的解析对象
    private String currentTag=null;//正在解析的元素的标签
    private String currentVal=null;//解析当前元素的值
    private String nodeName=null;//解析当前节点名称
    
    public List<HashMap<String, String>> getList() {
        return list;
    }

    public myHandler(String nodeName) {
        // TODO Auto-generated constructor stub
        this.nodeName=nodeName;
    }
    
    //解析到开始文档
    //当读到第一个开始标签的时候会触发这个方法
    @Override
    public void startDocument() throws SAXException {
        // TODO Auto-generated method stub
         System.out.println("--startDocument()--");
        list=new ArrayList<HashMap<String,String>>();
    }

    //开始元素
    //当遇到文档开头的时候会调用这个方法
    @Override
    public void startElement(String uri, String localName, String qname,Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
         //判断正在解析的元素是不是开始解析的元素
        System.out.println("--startElement()--"+qname);
        if(qname.equals(nodeName)){
            map=new HashMap<String, String>();
        }
        if(attributes!=null&&map!=null){
            for (int i = 0; i < attributes.getLength(); i++) {
                map.put(attributes.getQName(i), attributes.getValue(i));
            }
        }
        System.out.println(qname+":"+map);
        currentTag=qname;
    }
    
    //元素内容
    //用来处理xml文件所读取到的内容
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        // TODO Auto-generated method stub
        if(currentTag!=null&&map!=null){
            currentVal=new String(ch,start,length);
            if(currentVal!=null&&!currentVal.trim().equals("")&&!currentVal.trim().equals("
")){
                map.put(currentTag, currentVal);
            }
        }
         System.out.println("--characters()--"+currentTag+" "+currentVal);
        currentTag=null;//把当前节点对应标签和值设空
        currentVal=null;
    }

    
    //结束解析
    //遇到结束标记的时候会调用这个方法
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        // TODO Auto-generated method stub
         System.out.println("--endElement()--"+qName);
        if(qName.equals(nodeName)){
            list.add(map);
            map=null;
        }
    }
    
     //结束解析文档

    //结束解析文档，即解析根元素结束标签时调用该方法
         @Override
        public void endDocument() throws SAXException {
            // TODO Auto-generated method stub
             System.out.println("--endDocument()--");
            super.endDocument();
         }
}

httpUtils.java

package com.sax.http;

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class httpUtils {
    public  httpUtils (){
        
    }
    public static InputStream getXml(String path){
        InputStream inputStream=null;
        try {
            URL url=new URL(path);
            if(url!=null){
                HttpURLConnection connection=(HttpURLConnection)url.openConnection();
                connection.setConnectTimeout(3000);
                connection.setDoInput(true);
                connection.setRequestMethod("GET");
                int code=connection.getResponseCode();
                if(code==200){
                    inputStream=connection.getInputStream();
                }
                
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return inputStream;
    }
}

saxService.java

package com.sax.service;

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

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import com.sax.handler.myHandler;

public class saxService {

    public saxService() {
        // TODO Auto-generated constructor stub
    }
 public static List<HashMap<String,String>> readXml(InputStream inputStream,String nodeName){
     try {
        SAXParserFactory spf=SAXParserFactory.newInstance();//创建解析工厂对象
        SAXParser parser=spf.newSAXParser();//用来解析xml
        myHandler handler=new myHandler(nodeName);
        parser.parse(inputStream,handler);
        inputStream.close();
         return handler.getList();
    } catch (Exception e) {
        // TODO: handle exception
    }
     return null;
 }

}

test.java

package com.sax.test;

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

import com.sax.http.httpUtils;
import com.sax.service.saxService;

public class test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
  String path="http://122.206.79.193:8080/myhttp/person.xml";
  InputStream inputStream=httpUtils.getXml(path);
  try {
    List<HashMap<String,String>> list=saxService.readXml(inputStream, "person");
    for(HashMap<String,String> map:list){
        System.out.println(map.toString());
    }
} catch (Exception e) {
    // TODO: handle exception
}
    }

}

 ---------------------------------

 XmlPull:

和Sax类似，是基于流（stream）操作文件，然后根据节点事件回调开发者编写的处理程序。

因为是基于流的处理，因此Xmlpull和 Sax都比较节约内存资源，不会象Dom那样要把所有节点以对橡树的形式展现在内存中。 但Xmlpull比Sax更简明，而且不需要扫描完整个流。

如开始元素和结束元素，使用parser.next()可以进行下一个元素并且触发相应的事件，事件将作为代码被发送，

因此可以使用一个switch来对事件进行选择，然后进行相应的处理。当开始解析元素时候，调用parser.nextText()方法可以获得下一个Text类型的元素。

ØPULL特点：

简单的结构：一个接口，一个例外，一个工厂组成的PULL解析器

Ø简单易用：PULL解析器只有一个重要的方法next方法，他被用来检索下一个事件，

而它只有5个常用的属性：START DOCUMENT;START_TAG;TEXT;END_TAG;END_DOCUMENT

优点：比sax简单

缺点:swtich时需要知道节点名称

务必记住需要导入kxml2-2.2.2.jar

示例：同上

person

package com.xml.domain;

public class person {

    private int id;
    private String name;
    private int age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return "person [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
    public person(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public person() {
        // TODO Auto-generated constructor stub
    }

}

httpUtils

package com.xml.http;

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class httpUtils {
    public  httpUtils (){
        
    }
    public static InputStream getXml(String path){
        InputStream inputStream=null;
        try {
            URL url=new URL(path);
            if(url!=null){
                HttpURLConnection connection=(HttpURLConnection)url.openConnection();
                connection.setConnectTimeout(3000);
                connection.setDoInput(true);
                connection.setRequestMethod("GET");
                int code=connection.getResponseCode();
                if(code==200){
                    inputStream=connection.getInputStream();
                }
                
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return inputStream;
    }
}

pullXmlTools

package com.xml.pull;

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 com.xml.domain.person;

/**
 * 记得导入包
 * @author Administrator
 * 优点：比sax简单
 * 缺点:swtich时需要知道节点名称
 *
 */
public class pullXmlTools {

    public pullXmlTools() {
        // TODO Auto-generated constructor stub
    }
    //inputStream：从服务器获取xml，以流的形式返回
  public static List<person> parseXml(InputStream  inputStream,String encode) throws Exception{
      List<person> list=null;
      person person=null;//装载解析的每个节点的内容
      //创建xml工厂
      XmlPullParserFactory factory=XmlPullParserFactory.newInstance();
      //获得解析类
      XmlPullParser parser= factory.newPullParser();
      parser.setInput(inputStream, encode);
      //获得事件的类型
      int eventType=parser.getEventType();
      while(eventType!=XmlPullParser.END_DOCUMENT){
          switch (eventType) {
        case XmlPullParser.START_DOCUMENT:
            list=new ArrayList<person>();
            break;
        case XmlPullParser.START_TAG:
            if("person".equals(parser.getName())){
                person=new person();
                int id=Integer.parseInt(parser.getAttributeValue(0));
                person.setId(id);
            }
            else if("name".equals(parser.getName())){
                String name=parser.nextText();//获取该节点的内容
                person.setName(name);
            }
            else if("age".equals(parser.getName())){
                int age=Integer.parseInt(parser.nextText());
                person.setAge(age);
            }
            list=new ArrayList<person>();
            break;
        case XmlPullParser.END_TAG:
            if("person".equals(parser.getName())){
                list.add(person);
                person=null;
            }
            break;
        }
          eventType=parser.next();//循环
      }
      return list;
      
  }
}

test

package com.xml.test;

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

import com.xml.domain.person;
import com.xml.http.httpUtils;
import com.xml.pull.pullXmlTools;



public class Test {

    public Test() {
        // TODO Auto-generated constructor stub
    }

    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        String path="http://122.206.79.193:8080/myhttp/person.xml";
          InputStream inputStream=httpUtils.getXml(path);
          List<person> list=pullXmlTools.parseXml(inputStream, "UTF-8");
          for (person person : list) {
            System.out.println(person.toString());
        }
    }

}

-------------------------------

DOM(不推荐)

DOM是一种用于XML文档对象模型，DOM模式解析XML，是把整个XML文档当成一个对象来处理，会先把整个文档读入到内存里。

是基于树的结构，通常需要加载整文档和构造DOM树，然后才能开始工作。

可用于直接访问XML文档的各个部位，在DOM中文档被模拟为树状，其中XML语法的每一个组成部分都表示一个节点，DOM允许用户遍历文档树，从父节点移动到子节点和兄弟节点。并利用某节点类型特有的属性(元素具有属性，文本节点具有文本数据)

优点：a、由于整棵树在内存中，因此可以对xml文档随机访问

b、可以对xml文档进行修改操作

c、较sax，dom使用也更简单。

缺点：a、整个文档必须一次性解析完

b、由于整个文档都需要载入内存，对于大文档成本高

Ø节点(XML文档中的每一个成分都是一个节点)

DOM是这样规定的：整个文档是一个节点文档;每一个XML标签是一个元素节点;包含在XML元素中的文本是文本节点;每一个XML属性是一个属性节点

在这里当我们得到节点book时，也就是图中1所画的地方，如果我们调用它的getChildNodes()方法，它的子节点(不包括它的孙子节点，thinking in java这种的除外，因为它是孙子节点。)有5个，

分别是图中2、3、4、5、6所示的那样。所以在解析时，一定要小心，不要忽略空白的地方。

Ø从内存占用率来说： SAX和PULL比DOM占用的更少的内存解析方式，更加适合Android 手机开发。

person

package com.xml.dom.domain;

public class person {

    private int id;
    private String name;
    private int age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return "person [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
    public person(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public person() {
        // TODO Auto-generated constructor stub
    }

}

http

package com.xml.dom.http;

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class httpUtils {
    public  httpUtils (){
        
    }
    public static InputStream getXml(String path){
        InputStream inputStream=null;
        try {
            URL url=new URL(path);
            if(url!=null){
                HttpURLConnection connection=(HttpURLConnection)url.openConnection();
                connection.setConnectTimeout(3000);
                connection.setDoInput(true);
                connection.setRequestMethod("GET");
                int code=connection.getResponseCode();
                if(code==200){
                    inputStream=connection.getInputStream();
                }
                
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return inputStream;
    }
}

dom

package com.xml.dom.service;

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 com.xml.dom.domain.person;

public class DomService {

    public DomService() {
        // TODO Auto-generated constructor stub
    }

    public List<person> getPersons(InputStream  inputStream) throws Exception{
         List<person> list=new ArrayList<person>();
         DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();//创建dom解析工厂
         DocumentBuilder builder=factory.newDocumentBuilder();//
         Document dom=builder.parse(inputStream);//得到文档对象
         Element element=dom.getDocumentElement();//获得稳定的元素节点
         NodeList personNodes=element.getElementsByTagName("person");//从person节点开始遍历
         for (int i = 0; i < personNodes.getLength(); i++) {
             Element personElement=(Element)personNodes.item(i);
             person person=new person();
             person.setId(Integer.parseInt(personElement.getAttribute("id")));
             NodeList childNodes=personElement.getChildNodes();//该节点的所有属性
             for (int j = 0; j < childNodes.getLength(); j++) {
                if(childNodes.item(j).getNodeType()==Node.ELEMENT_NODE){
                    if("name".equals(childNodes.item(j).getNodeName())){
                        person.setName(childNodes.item(j).getFirstChild().getNodeValue());
                    }
                    else if("age".equals(childNodes.item(j).getNodeName())){
                        person.setAge(Integer.parseInt(childNodes.item(j).getFirstChild().getNodeValue()));
                    }
                }
            }
             list.add(person);
        }
         return list;
    }


}

test

package com.xml.dom.test;

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

import com.xml.dom.domain.person;
import com.xml.dom.http.httpUtils;
import com.xml.dom.service.DomService;



public class test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
  String path="http://122.206.79.193:8080/myhttp/person.xml";
  InputStream inputStream=httpUtils.getXml(path);
  try {
    DomService domService=new DomService();
   List<person>list= domService.getPersons(inputStream);
    for(person person:list){
        System.out.println(person.toString());
    }
} catch (Exception e) {
    // TODO: handle exception
}
    }

}

 三种方式的对比：

方式	是否提供服务器端jsonString的生成方法	优缺点
SAX	首先创建自己的事件处理器类myHandler：myHandler extends DefaultHandler 其次，建立httpUtils，从服务器读取xml文件并返回读入流 第三，实例化工厂、解析对象和事件处理对象，通过使用解析器的解析方法对输入流进行解析，并通过时间处理器的get方法返回最终的结果 SAXParserFactory spf=SAXParserFactory.newInstance();//创建解析工厂对象 SAXParser parser=spf.newSAXParser();//解析器用来解析xml myHandler handler=new myHandler(nodeName); parser.parse(inputStream,handler); inputStream.close(); return handler.getList();	完美
PULL	需要导入第三方的kxml2-2.2.2.jar  首先需要建立一个解析xml的方法，该方法有两个传入参数，InputStream  inputStream,String encode 其次，建立httpUtils，从服务器读取xml文件并返回读入流 第三，完善第一步的方法：实例化工厂、解析对象，将输入流和编码方式设置给解析对象并通过解析器parser.getEventType()方法获得标签类型， while+switch方式遍历整个文档标签，获取相应的参数、对象并累加返回list person person=null;//装载解析的每个节点的内容//创建xml工厂 XmlPullParserFactory factory=XmlPullParserFactory.newInstance();//获得解析类 XmlPullParser parser= factory.newPullParser(); parser.setInput(inputStream, encode);//获得事件的类型 int eventType=parser.getEventType(); while(eventType!=XmlPullParser.END_DOCUMENT){ switch (eventType) { case XmlPullParser.START_DOCUMENT:...}	优点：简单 缺点：需要提前知道各个节点的名字
DOM	首先需要建立一个解析xml的方法，该方法有两个传入参数，InputStream  inputStream 其次，建立httpUtils，从服务器读取xml文件并返回读入流 第三，完善第一步的方法：实例化工厂、解析对象，将输入流设置给解析对象builder.parse(inputStream)获取文档对象， 然后通过文档对象的getDocumentElement方法获取稳定节点，然后遍历 DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();//创建dom解析工厂 DocumentBuilder builder=factory.newDocumentBuilder();// Document dom=builder.parse(inputStream);//得到文档对象 Element element=dom.getDocumentElement();//获得稳定的元素节点 NodeList personNodes=element.getElementsByTagName("person");//从person节点开始遍历 for (int i = 0; i < personNodes.getLength(); i++) {...	缺点：有撑破内存的可能，极不推荐

 ---------------------------------

xml序列化：

 public void xml(View view){
         //初始化序列化器
         XmlSerializer serializer= Xml.newSerializer();
         File file=new File(Environment.getExternalStorageDirectory(),"xml.xml");
         FileOutputStream os=new FileOutputStream(file);
         serializer.setOutput(os, "utf-8");
         
         serializer.startDocument("utf-8", true);//开头
         serializer.startTag(null, "persons");
         for(Person ps:PersonList){
             serializer.startTag(null, "person");
             serializer.attribute(null, "id", ps.getId());
             
             serializer.startTag(null, "age");
             serializer.text( ps.getname());
             serializer.endTag(null, "age");
             
             serializer.endTag(null, "person");
         }
         serializer.endTag(null, "persons");
         serializer.endDocument();//结尾
     }