Android解析XML三种方式

三种方式分别为SAX、PULL和DOM

先准备封装数据的类与http工具类

package com.lee.testxml1116.bean;

/**
* 存储person数据的bean类
* @author Lee
*
*/
public class Person {

private int id;
private int age;
private String name;

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

public Person(int id, int age, String name) {
super();
this.id = id;
this.age = age;
this.name = name;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return "Person [id=" + id + ", age=" + age + ", name=" + name + "]";
}

}

package com.lee.testxml1116.utils;

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

public class HttpUtil {

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

/**
* 获取http输入字节流，通过流获取服务器端返回的数据
* @param path
* @return
*/
public static InputStream getXML(String path){
InputStream is = null;
try {
URL url = new URL(path);
if(null != url){
// 创建http连接
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
// 设置连接超时时间为3秒
connection.setConnectTimeout(3000);
connection.setDoInput(true);
// 设置请求方式为get
connection.setRequestMethod("GET");
// 获取服务器响应状态码
int code = connection.getResponseCode();
// 若状态码为200(即正常)，获取输入流
if(200 == code)
is = connection.getInputStream();
}
} catch (Exception e) {
// TODO: handle exception
}
return is;
}
}

一、SAX方式
用到org.xml.sax.helpers.DefaultHandler，所以要定义自己的handler类，重写读取xml文件的相关方法

package com.lee.testxml1116.utils;

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 MySaxHandler 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 MySaxHandler(String nodeName) {
super();
// TODO Auto-generated constructor stub
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 {
// 判断当前元素(节点)是否为要解析的根元素(节点),如果是，则创建存储解析对象信息的map
System.out.println(qName);
if(nodeName.equals(qName)){
map = new HashMap<String, String>();
}
System.out.println(map);
// 判断该元素是否有标签内属性，有则存入map
if(!(null == attributes || null == map)){
for(int i = 0;i < attributes.getLength();i++){
System.out.println(attributes.getQName(i));
map.put(attributes.getQName(i), attributes.getValue(i));
}
}
currentTag = qName;
}

/**
* 读到元素(节点)中字符类型数据时调用的方法
*/
@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
// 判断当前元素(节点)名称是否为空，不为空，则取值
if(!(null == map || null == currentTag)){
currentValue = new String(ch, start, length);
// 判断当前值是否为空、是否等于换行符，两者均否，则存入map
if(!(null == currentValue || "".equals(currentValue.trim()) || "\n".equals(currentValue.trim()))){
map.put(currentTag, currentValue);
}
}
// 存储数据结束后，将currentTag与currentValue初始化
currentTag = null;
currentValue = null;

}

/**
* 读到元素(节点)结束标记时调用的方法
*/
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
// 判断当前结束标记是否为目标根节点，若是，则将map存入list中
if(qName.equals(nodeName)){
list.add(map);
// 将map初始化
map = null;
}
}

/**
* 读到文档结束时调用的方法
*/
@Override
public void endDocument() throws SAXException {
//
}
}

定义完handler之后，创建一个service类，来封装从xml中获取数据的方法

package com.lee.testxml1116.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.lee.testxml1116.utils.MySaxHandler;
/**
* 以SAX方式解析xml并返回数据的服务类
* @author Lee
*
*/
public class SaxService {

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

public static List<HashMap<String,String>> readXML(InputStream is, String nodeName){
try {
// 创建SAX解析工厂，获取一个解析对象
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser parser = spf.newSAXParser();
// 创建一个自定义DefaultHandler对象
MySaxHandler handler = new MySaxHandler(nodeName);
// 解析xml
parser.parse(is, handler);
// 关闭InputStream
if(null != is)
is.close();
// 返回存储数据的list集合
return handler.getList();
} catch (Exception e) {
// TODO: handle exception
}
return null;
}

}

二、Pull方式
当使用pull方式解析xml时，需要用到第三方包kxml，这里使用的是kxml2-2.2.2.jar

主要用到的类就是org.xmlpull.v1.XmlPullParser

package com.lee.testxml1116.utils;

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 com.lee.testxml1116.bean.Person;

/**
* 以pull方式解析xml的工具类
* @author Lee
*
*/
public class PullXMLUtil {

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

public static List<Person> parseXML(InputStream is, String encode) throws XmlPullParserException, NumberFormatException, IOException{
List<Person> persons = null;
Person person = null;
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlPullParser parser = factory.newPullParser();
parser.setInput(is, encode);
int eventType = parser.getEventType();
while(eventType != XmlPullParser.END_DOCUMENT){
switch (eventType) {
case XmlPullParser.START_DOCUMENT:
persons = 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("age".equals(parser.getName())){
int age = Integer.parseInt(parser.nextText());
person.setAge(age);
} else if("name".equals(parser.getName())){
String name = parser.nextText();
person.setName(name);
}
break;
case XmlPullParser.END_TAG:
if("person".equals(parser.getName())){
persons.add(person);
person = null;
}
break;
}
eventType = parser.next();
}
return persons;
}
}

三、DOM方式

package com.lee.testxml1116.utils;

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 javax.xml.soap.Node;

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

import com.lee.testxml1116.bean.Person;

/**
* 以DOM方式解析xml的工具类
*
* @author Lee
*
*/
public class DomXMLUtil {

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

/**
* 从在http连接中取到的流中读取xml数据
*
* @param is
* @return
* @throws ParserConfigurationException
* @throws IOException
* @throws SAXException
*/
public static List<Person> readXML(InputStream is)
throws ParserConfigurationException, SAXException, IOException {
List<Person> persons = new ArrayList<Person>();
// 创建一个文档构造器工厂，用以获取文档构造器
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
// 获取一个文档构造器的实例，用以获取文档
DocumentBuilder builder = dbf.newDocumentBuilder();
// 获取一个文档实例
Document document = builder.parse(is);
// 获取文档中的元素集合
Element element = document.getDocumentElement();
// 在元素集合中获取目标节点的集合
NodeList personNodes = element.getElementsByTagName("person");
// 遍历目标节点集合，解析xml
for (int i = 0; i < personNodes.getLength(); i++) {
// 获取当前的目标节点
Element personElement = (Element) personNodes.item(i);
Person person = new Person();
// 获取当前节点中属性的值，并给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){
String nodeName = childNodes.item(j).getNodeName();
String nodeValue = childNodes.item(j).getFirstChild().getNodeValue();
if("name".equals(nodeName)){
person.setName(nodeValue);
} else if("age".equals(nodeName)){
person.setAge(Integer.parseInt(nodeValue));
}
}
}
// 子节点集合遍历结束后，即已经完成对一个person节点的解析，因此将一个完整的person对象存入list中
persons.add(person);
}

return persons;
}
}

最后附上测试类，对这三种方式进行测试

package com.lee.testxml1116.test;

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

import javax.xml.parsers.ParserConfigurationException;

import org.xml.sax.SAXException;
import org.xmlpull.v1.XmlPullParserException;

import com.lee.testxml1116.bean.Person;
import com.lee.testxml1116.utils.DomXMLUtil;
import com.lee.testxml1116.utils.HttpUtil;
import com.lee.testxml1116.utils.PullXMLUtil;

/**
* 测试类
* @author Lee
*
*/
public class Test {

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

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String path = "目标xml文件的url地址";
InputStream is = HttpUtil.getXML(path);
/*
* 以SAX方式解析
List<HashMap<String,String>> list = SaxService.readXML(is, "person");
for(HashMap<String, String> map : list){
System.out.println(map.toString());
}
*/

List<Person> persons = null;
/*
* 以pull方式解析
try {
persons = PullXMLUtil.parseXML(is, "UTF-8");
for(Person person : persons){
System.out.println(person.toString());
}
} catch (NumberFormatException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
*/

// 以dom方式解析
try {
persons = DomXMLUtil.readXML(is);
for(Person person : persons){
System.out.println(person.toString());
}
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

三种方法相比，由于dom使用的是循环嵌套，所以当xml节点层级较多时，效率会比前两者略低。