Dom、Sax、JDOM和Dom4j四种方式解析XML文件小Demo和四种方式的大概比较

我们都知道，解析XML文件的方式不外乎如下四种：

Dom、Sax、JDOM和Dom4j

在此简单的比较一下四种解析XML的特点：

Dom：通常需要加载整个文档，消耗资源大，因此适用于比较小的XML文档。

Sax：Sax是基于事件驱动的解析方式，不需要加载整个文档就开始解析，效率和性能较高，可以用于解析比系统内存大的文档。

JDOM：使用具体类而不是接口，简化了Dom的API，但是性能和Dom解析差不多。

Dom4j：在四种解析方式中，Dom4j的性能是最高的，而且使用的是接口，支持xpath。

使用建议：假如XML文档大而且要求性能和效率高，而且不考虑移植性的问题，就采用Dom4j解析方式。假如XML文档小就采用Dom和JDOM方式。

假如需要及时处理而且不需要保存数据则采用SAX解析。

JDOM的架包：jdom-2.0.6.jar

Dom4j的架包：dom4j-1.6.1.jar

请自行到网上下载

XML模版：

<?xml version="1.0" encoding="UTF-8"?>
<users>
<user id="0">
<name>胡吉安</name>
<age>27</age>
<sex>男</sex>
</user>
<user id="1">
<name>罗鹏</name>
<age>27</age>
<sex>男</sex>
</user>
<user id="2">
<name>黄艳梅</name>
<age>27</age>
<sex>女</sex>
</user>
<user id="3">
<name>欧丹</name>
<age>26</age>
<sex>女</sex>
</user>
</users>

xml模版路径常量：

package com.zy.xml.common;
public class Constant {
public static final String FILE_NAME="F:\\workspace\\web\\XMLParser\\src\\xml\\user.xml";
}

XML解析的接口：

package com.zy.xml.common;
/**
 * 定义XML文档解析的接口
 * 
 * @author Administrator
 * 
 */

public interface XMLDocument {
/**
* 解析XML的方法
* 
* @param fileName
*            :文件全路径的名称
*/
public void parseXML(String fileName);
}

Dom方式：

package com.zy.xml.dom;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import com.zy.xml.common.Constant;
import com.zy.xml.common.XMLDocument;
/**
 * DOM方式来解析XML
 * 
 * @author Luopeng
 * 
 */
public class DomXMLParser implements XMLDocument {
@Override
public void parseXML(String fileName) {
try {
/**
* DocumentBuilderFactory.newInstance()的作用
* 1.在系统环境变量中(System.getProperties())中查找key=javax.xml.parsers.DocumentBuilderFactory
* 2.如果1没有找到,则找java.home\lib\jaxp.properties文件，如果文件存在, 在文件中查找key=javax.xml.parsers.DocumentBuilderFactory
* 3.如果2没有找到则在classpath中的所有的jar包中查找META-INF/services/javax.xml.parsers.DocumentBuilderFactory 文件.
* 全都没找到，则返回null
*/
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
/**
* newDocumentBuilder代表一个具体的XML解析器
*/
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.parse(fileName);
// 得到最外层的tag(users)
NodeList users = document.getChildNodes();
for (int i = 0; i < users.getLength(); i++) {
Node user = users.item(i);
// 得到中间层tag(user)
NodeList userInfo = user.getChildNodes();
for (int j = 0; j < userInfo.getLength(); j++) {
Node userNode = userInfo.item(j);
// 遍历得到中间层tag的数据
NodeList userNodeList = userNode.getChildNodes();
for (int k = 0; k < userNodeList.getLength(); k++) {
if (userNodeList.item(k).getNodeName() != "#text") {
System.out.println(userNodeList.item(k)
.getNodeName()
+ "："
+ userNodeList.item(k).getTextContent());
}
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
DomXMLParser dxp = new DomXMLParser();
dxp.parseXML(Constant.FILE_NAME);
}
}

SAX解析：

package com.zy.xml.sax;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import org.xml.sax.Attributes;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import com.zy.xml.common.Constant;
import com.zy.xml.common.XMLDocument;
/**
 * Sax方式来解析XML
 * 
 * @author Luopeng
 * 
 */
public class SaxXMLParser implements XMLDocument {
@Override
public void parseXML(String fileName) {
/**
* SAXParserFactory.newInstance()定义一个工厂，是应用程序可以配置和获得一个
* 基于SAX的解析器，从而能够解析XML文档
*/
SAXParserFactory spf = SAXParserFactory.newInstance();
InputStream is = null;
try {
SAXParser sp = spf.newSAXParser();
is = new FileInputStream(fileName);
sp.parse(is, new MySaxXMLParserHandler());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
class MySaxXMLParserHandler extends DefaultHandler {
private boolean hasAttributes = false;
private Attributes attributes = null;


public void startDocument() throws SAXException {
System.out.println("=========开始解析XML=========");
}


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


/**
* startElement方法开始解析节点
*/
public void startElement(String path, String local, String name,
Attributes attributes) throws SAXException {
if ("users".equals(name)) {
return;
}
if ("user".equals(name)) {
return;
}
if (attributes.getLength() > 0) {
this.attributes = attributes;
this.hasAttributes = true;
}
}
/**
* 然后调用characters方法保存节点的内容，
*/
public void characters(char[] ch, int start, int length)
throws SAXException {
System.out.print(new String(ch, start, length));
}
/**
* 最后调用endElement方法结束解析
*/
public void endElement(String path, String local, String name)
throws SAXException {
if (hasAttributes && attributes != null) {
for (int i = 0; i < attributes.getLength(); i++) {
System.out.println(attributes.getQName(i) + "："
+ attributes.getValue(i));
}
}
}
}

public static void main(String[] args) {
SaxXMLParser sxp = new SaxXMLParser();
sxp.parseXML(Constant.FILE_NAME);
}
}

JDOM解析：

package com.zy.xml.jdom;
import java.io.IOException;
import java.util.List;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import com.zy.xml.common.Constant;
import com.zy.xml.common.XMLDocument;
/**
 * JDOM方式来解析XML文件
 * 
 * @author Luopeng
 * 
 */
public class JDomXMLParser implements XMLDocument {
@SuppressWarnings("rawtypes")
@Override
public void parseXML(String fileName) {
SAXBuilder sb = new SAXBuilder();
try {
/**
* SAXBuilder是个JDOM解析器，它能够将路径中的XML文件解析成Document对象
*/
Document document = sb.build(fileName);
Element users = document.getRootElement();
List userList = users.getChildren("user");
if (userList != null) {
for (int i = 0; i < userList.size(); i++) {
Element ele = (Element) userList.get(i);
List userInfos = ele.getChildren();
if (userInfos != null) {
for (int j = 0; j < userInfos.size(); j++) {
System.out.println(((Element) userInfos.get(j))
.getName()
+ "："
+ ((Element) userInfos.get(j)).getValue());
}
}
}
}
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
JDomXMLParser jdxp = new JDomXMLParser();
jdxp.parseXML(Constant.FILE_NAME);
}
}

Dom4j解析：

package com.zy.xml.dom4j;
import java.io.File;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import com.zy.xml.common.Constant;
import com.zy.xml.common.XMLDocument;
/**
 * Dom4j方法来解析XML文件
 * 
 * @author Luopeng
 * 
 */
public class Dom4jXMLParser implements XMLDocument {
@SuppressWarnings("rawtypes")
@Override
public void parseXML(String fileName) {
File file = new File(fileName);
SAXReader sr = new SAXReader();
try {
Document document = sr.read(file);
Element users = document.getRootElement();
for (Iterator it = users.elementIterator(); it.hasNext();) {
Element ele = (Element) it.next();
for (Iterator ite = ele.elementIterator(); ite.hasNext();) {
Element user = (Element) ite.next();
System.out.println(user.getName() + "：" + user.getText());
}
}
} catch (DocumentException e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
Dom4jXMLParser dxp = new Dom4jXMLParser();
dxp.parseXML(Constant.FILE_NAME);
}
}