java dom、sax解析xml

<?xml version="1.0" encoding="utf-8" ?>
<ROWDATA>
<ROW>
<T_ID>1</T_ID>
<T_KEY>binding_time</T_KEY>
<T_VALUE></T_VALUE>
<T_REMARK>保存im.cgs_bind_info的binding_time字段</T_REMARK>
</ROW>
<ROW>
<T_ID>2</T_ID>
<T_KEY>relate_time</T_KEY>
<T_VALUE>2015-06-09 23:55:26</T_VALUE>
<T_REMARK>保存im.cgs_relate_info的relate_time字段</T_REMARK>
</ROW>
<ROW>
<T_ID>3</T_ID>
<T_KEY>bind_oper_time</T_KEY>
<T_VALUE></T_VALUE>
<T_REMARK>保存im.cgs_user_bind_oper的oper_time字段</T_REMARK>
</ROW>
</ROWDATA>

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

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

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

public class SaxParser extends DefaultHandler {
private List<Map<String, Object>> list;

/**
* 解析XML文档
* @param filePath 要解析的文件路径
* @throws IOException
* @throws ParserConfigurationException
* @throws SAXException
*/
public SaxParser(String filePath) throws IOException, ParserConfigurationException, SAXException {
SAXParser parser = null;
try {
// 构建SAXParser
parser = SAXParserFactory.newInstance().newSAXParser();
File file = new File(filePath);
FileInputStream fis = new FileInputStream(file);
SaxHandler saxHandler = new SaxHandler();
// 调用parse()方法
parser.parse(fis, saxHandler);
list = saxHandler.getRowList();
fis.close();
} catch (ParserConfigurationException e) {
throw e;
} catch (SAXException e) {
throw e;
} catch (IOException e) {
throw e;
} finally {
if (parser != null)
parser.reset();
}
}
/**
* 解析XML文档
* @param is 要解析的文件输入流
* @throws IOException
* @throws ParserConfigurationException
* @throws SAXException
*/
public SaxParser(InputStream is) throws IOException, ParserConfigurationException, SAXException {
SAXParser parser = null;
try {
// 构建SAXParser
parser = SAXParserFactory.newInstance().newSAXParser();
SaxHandler saxHandler = new SaxHandler();
// 调用parse()方法
parser.parse(is, saxHandler);
list = saxHandler.getRowList();
is.close();
} catch (ParserConfigurationException e) {
throw e;
} catch (SAXException e) {
throw e;
} catch (IOException e) {
throw e;
} finally {
if (parser != null)
parser.reset();
}
}
/**
* 获取解析后得到的List
*/
public List<Map<String, Object>> getRowList() {
return list;
}
}
class SaxHandler extends DefaultHandler{
List<Map<String, Object>> list;
Map<String, Object> map;
private String qName; // 节点名称
private StringBuilder sb = new StringBuilder();// 保存节点内容

/**
* 获取解析后得到的List
*/
public List<Map<String, Object>> getRowList() {
return list;
}

@Override
public void startDocument() throws SAXException {
//		System.out.println("开始解析XML");
list = new ArrayList<Map<String,Object>>();
}

@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
//		System.out.println("读取标签：" + uri + " ---> " + localName + " ---> " + qName);
/*
* 如果使用localName的话，有些环境下永远为空，qName就不会用这种情况
*/
this.qName = qName;
if ("ROW".equals(this.qName)) {
map = new LinkedHashMap<String, Object>();
}
}

@Override
public void characters(char[] ch, int start, int length) throws SAXException {
/*
如果xml文档交长（一般4k会清理一下内存），有可能一个元素的值会被分成两次（多次）读入。
如果只用characters方法去获得元素的值，很可能得到的不完整的数据。
characters会在startElement和endElement之间调用多次，不能保证一次会返回整个文本块，所以必须等待endElement的时候才可以认为这个文本结点结束。
*/
if (this.qName != null && !"ROWDATA".equals(this.qName) && !"ROW".equals(this.qName)) {
String data = new String(ch, start, length);
sb.append(data);
}
}

@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
if (this.qName != null && !"ROWDATA".equals(this.qName) && !"ROW".equals(this.qName)) {
// 等到解析完当前qName标签，再将qName和值放到map中
map.put(this.qName, sb.toString());
sb.setLength(0);
}
if ("ROW".equals(qName)) {
list.add(map);
}
// 当前qName解析结束时置为空。
this.qName = null;
}

@Override
public void endDocument() throws SAXException {
//		System.out.println("结束解析XML");
}
}

import java.io.File;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class Dom4jParser {
private List<Map<String, Object>> list;

/**
* 解析XML文档
* @param filePath 要解析的文件路径
* @throws DocumentException
*/
public Dom4jParser(String filePath) throws DocumentException {
list = new ArrayList<Map<String,Object>>();
SAXReader reader = new SAXReader();
File file = new File(filePath);
Document document = reader.read(file);
list = parserXML(document);
}
/**
* 解析XML文档
* @param is 要解析的文件输入流
* @throws DocumentException
*/
public Dom4jParser(InputStream is) throws DocumentException {
list = new ArrayList<Map<String,Object>>();
SAXReader reader = new SAXReader();
Document document = reader.read(is);
list = parserXML(document);
}

public List<Map<String, Object>> getRowList() {
return list;
}

/**
* 解析根节点，获取得到所有ROW节点的子节点的集合
*/
private List<Map<String, Object>> parserXML(Document document) throws DocumentException {
Element rowdata = document.getRootElement(); // ROWDATA跟节点
List<Element> rows = rowdata.elements("ROW");
List<Map<String, Object>> list = parserRowElement(rows);
return list;
}
/**
* 解析ROW节点下的子节点
*/
private List<Map<String, Object>> parserRowElement(List<Element> rows) {
for (Element element : rows) {
Map<String, Object> map = new LinkedHashMap<String, Object>();
Iterator<Element> it = element.elementIterator();
while (it.hasNext()) {
Element next = it.next();
map.put(next.getName(), next.getTextTrim());
}
list.add(map);
}
return list;
}
}