Android中使用SAX解析XML

HTTP网络传输中的数据组织方式有三种方式：HTML方式、XML方式、JSON方式，下面来讲解析XML的方法。关于XML是什么，可以点这里查看。 xml的结构解析为：

1.节点 

2.元素

3.属性和属性值

     由于XML的扩展性强，致使它需要有稳定的基础规则来支持扩展，该语法规则是：

1.开始和结束标签匹配

2.标签不能互相嵌套

3.区分大小写

     在Android中，解析XML数据有三种方式：

        1.DOM（文档对象模型）：解析完的XML将生成一个树状结构的对象

        2.SAX（Simple API for XML）：以事件的形式通知程序，对XML进行解析

        3.PULL：类似于SAX方式，程序以“拉取”的方式对XML进行解析

     SAX是一种以事件驱动的XML API，由它定义的事件流可以指定从解析器传到专门的处理程序的代码的XML结构，简单的说，它解析速度快，占用内存少。这种解析器比较适合android等移动设备。

     使用SAX的优点是：因为SAX的优势是使用流的方式处理，当遇到一个标签的时候，并不会记录当前所碰到的标签。也就是说，startElement方法中，你所知道的信息，仅仅是当前标签的名字和属性，至于标签的嵌套结构，上层标签的名字，是否有子元素与其他结构相关的信息，都是未知的。

下面介绍的实例中，为了体现现实开发中的常用情况，将persons.xml文件放置在服务器端，最终实现读取xml文件并显示出来：

     要解析的XML文件persons.xml：

<?xml version="1.0" encoding="UTF-8"?>
<persons>
     <person id="1">
          <name>lin</name>
          <age>23</age>
     </person>
     <person id="2">
          <name>ying</name>
          <age>22</age>
     </person>
</persons>

用SAX解析XML的类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 currentValue = null;
     // 解析当前的节点名称
     private String nodeName = null;

     public MyHandler(String nodeName) {
          this.nodeName = nodeName;
     }

     public List<HashMap<String, String>> getList() {
          return list;
     }

     @Override
     public void startDocument() throws SAXException {
          // 当读取到第一个开始标签时，会触发这个方法
          list = new ArrayList<HashMap<String, String>>();
     }

     @Override
     public void startElement(String uri, String localName, String qName,
               Attributes attributes) throws SAXException {
          // 当遇到文档的开头的时候，调用这个方法
          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));
               }
          }
          currentTag = qName;
     }

     @Override
     public void characters(char[] ch, int start, int length)
               throws SAXException {
          // 这个方法是用来处理xml文件所读取到的内容
          if (currentTag != null && map != null) {
               currentValue = new String(ch, start, length);
               if (currentValue != null && !currentValue.trim().equals("")
                         && !currentValue.trim().equals("\n")) {
                    map.put(currentTag, currentValue);
               }
          }
          currentTag = null;// 把当前节点对应的值和标签设置为空
          currentValue = null;
     }

     @Override
     public void endElement(String uri, String localName, String qName)
               throws SAXException {
          // 当遇到结束标记的时候会调用这个方法
          if (qName.equals(nodeName)) {
               list.add(map);
               map = null;
          }
          super.endElement(uri, localName, qName);
     }
}

用于解析xml的业务类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 {
               //创建一个解析XML的工厂对象
               SAXParserFactory spf = SAXParserFactory.newInstance();
               //用来解析XML
               SAXParser parser = spf.newSAXParser();
               MyHandler handler = new MyHandler(nodeName);
               parser.parse(inputStream, handler);
               inputStream.close();
               return handler.getList();
          } catch (Exception e) {
               e.printStackTrace();
          }
          return null;
     }
}

网络访问并获取XML文件的类HttpUtils：

package com.sax.http;

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

public class HttpUtils {

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

     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) {
               e.printStackTrace();
          }
          return inputStream;
     }
}

主程序类Test.java：

package com.sax.test;

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

import com.sax.http.HttpUtils;
import com.sax.service.SaxService;

public class Test {

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

     /**
     * @param args
     */
     public static void main(String[] args) {

          String path = "http://127.0.0.1:8088/Test1/persons.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) {
               e.printStackTrace();
          }
     }

}

执行结果为：

{id=1, age=23, name=lin}

{id=2, age=22, name=ying}