详解Java中的XML解析

详解Java中的XML解析

前言

XML,全称Extensibible Markup Language, 主要用于数据的保存或者文件传输，其主要特性如下所示：

- 以标签为主的标记语言

- 支持自定义标签，支持自我解释

- 与具体技术无关

- 支持验证

- 方便人类的读写

XML示例

为了更好的了解XML，下面我们提供一个简单的XML文件，内容如下所示：

<?xml version="1.0" encoding="UTF-8" ?>

<!--
根元素为students
注意XML文件中有且仅有一个根元素
-->
<students>
<!--
子元素student
id属性同样可以作为student的子元素
为了演示方便，这里将其作为属性
-->
<student id="123">
<!--
student有三个子元素
name、age、gender
-->
<name>xuhuanfeng</name>
<age>22</age>
<gender>male</gender>
</student>
<!--同上-->
<student id="456">
<name>Tom</name>
<age>23</age>
<gender>femal</gender>
</student>
<!--同上-->
<student id="789">
<name>Lily</name>
<age>24</age>
<gender>femal</gender>
</student>
</students>

在XML中每个元素都可以有子元素/值，元素可以有属性，具体关于XML的内容还请查看官方的文档，接下来的内容主要为Java对XML文件的解析。

XML解析

XML解析主要有两种方式，一种称为DOM解析，另外一种称之为SAX解析。

- DOM解析：Document Object Model，简单的来讲，DOM解析就是读取XML文件，然后在文件文档描述的内容在内存中生成整个文档树。

- SAX解析：Simple API for XML，简单的来讲，SAX是基于事件驱动的流式解析模式，一边去读文件，一边解析文件，在解析的过程并不保存具体的文件内容。

两种解析方式各有千秋，也都有各自的有点和缺点，这里简单罗列如下：

- DOM解析:

- 优点：在内存中形成了整个文档树，有了文档树，就可以随便对文档中任意的节点进行操作(增加节点、删除节点、修改节点信息等)，而且由于已经有了整个的文档树，可以实现对任意节点的随机访问。

- 缺点：由于需要在内存中形成文档树，需要消耗的内存比较大，尤其是当文件比较大的时候，消耗的代价还是不容小视的。

- SAX解析：

- 优点：SAX解析由于是一边读取文档一边解析的，所以所占用的内存相对来说比较小。

- 缺点：无法保存文档的信息，无法实现随机访问节点，当文档需要编辑的时候，使用SAX解析就比较麻烦了。

对XML的两种不同解析机制有一定的了解之后，接下来我们就来具体的看下，在Java中是如何解析的。

### DOM解析

关于DOM的解析，这里就不再做过多的解释了，直接通过代码来查看具体的操作过程

解析文档

“`Java

public void parse() {

// students的内容为上面所示XML代码内容

File file = new File(“D:/students.xml”);

try {
// 创建文档解析的对象
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

// 解析文档，形成文档树，也就是生成Document对象
Document document = builder.parse(file);

// 获得根节点
Element rootElement = document.getDocumentElement();
System.out.printf("Root Element: %s\n", rootElement.getNodeName());

// 获得根节点下的所有子节点
NodeList students = rootElement.getChildNodes();
for (int i = 0; i < students.getLength(); i++){
// 获得第i个子节点
Node childNode = students.item(i);
// 由于节点多种类型，而一般我们需要处理的是元素节点
// 元素节点就是非空的子节点，也就是还有孩子的子节点
if (childNode.getNodeType() == Node.ELEMENT_NODE){
Element childElement = (Element)childNode;
System.out.printf(" Element: %s\n", childElement.getNodeName());
System.out.printf("  Attribute: id = %s\n", childElement.getAttribute("id"));
// 获得第二级子元素
NodeList childNodes = childElement.getChildNodes();
for (int j = 0; j < childNodes.getLength(); j++){
Node child = childNodes.item(j);
if (child.getNodeType() == Node.ELEMENT_NODE){
Element eChild = (Element) child;
System.out.printf("  sub Element: %s value= %s\n", eChild.getNodeName(), eChild.getTextContent());
}
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

“`

解析的结果如下所示:

shell

Root Element: students

Element: student

Attribute: id = 123

sub Element: name value= xuhuanfeng

sub Element: age value= 22

sub Element: gender value= male

# 其余两个student节点由于篇幅原因这里省略...

当我们需要特定的节点的数据的时候，可以根据具体的数据从上面的解析过程中进行数据的筛选即可，所以这里不演示如果进行数据的选取了(毕竟整个文档的内容都读取出来了:))

编辑文档

由于DOM解析是直接在内存中生成对应的文档树，所以我们可以很方便地对其进行编辑，这里演示修改id = 123的子元素name的值为Huanfeng.Xu，具体代码如下所示：

public void modify(){
try {
// 生成文档树的过程同前面所示，这里不进行过多的解释
File file = new File("d:/students.xml");
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

Document document = builder.parse(file);

Element rootElement = document.getDocumentElement();
NodeList students = rootElement.getChildNodes();
for (int i = 0; i < students.getLength(); i++){
Node tmp = students.item(i);
if (tmp.getNodeType() == Node.ELEMENT_NODE){
Element element = (Element)tmp;
// 获得id为123的student节点
String attr = element.getAttribute("id");
if ("123".equalsIgnoreCase(attr)){
NodeList childNodes = element.getChildNodes();
for (int j = 0; j < childNodes.getLength(); j++){
Node childNode = childNodes.item(j);
if (childNode.getNodeType() == Node.ELEMENT_NODE) {
Element childElement = (Element) childNode;
// 修改子节点name的值
if (childElement.getNodeName().equalsIgnoreCase("name")) {
childElement.setTextContent("Huanfeng.Xu");
break;
}
}
}
}
}
}

// 获得Transformer对象，用于输出文档
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
// 封装成DOMResource对象
DOMSource domSource = new DOMSource(document);
Result result = new StreamResult("d:/newStudents.xml");
// 输出结果
transformer.transform(domSource, result);

} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (TransformerConfigurationException e) {
e.printStackTrace();
} catch (TransformerException e) {
e.printStackTrace();
}
}

可以看到，基本的操作跟解析文档是一致的，这也非常好理解，修改嘛，肯定先要解析文档然后获得需要修改的节点信息，这里同样可以对节点进行删除、增加操作，原理同上，这里就不进行演示。

SAX解析

关于SAX解析的原理，这里就不再做过多的解释，同上面DOM的解析一样，这里我们直接通过代码来查看具体的操作过程

解析文档

/**
*  由于SAX解析是基于事件机制的，也就是当遇到指定元素的时候，解析器就会自动调用
*  回调函数，所以使用SAX解析的时候，需要创建自定义的Handler并且继承自DefaultHandler
*  并且将其传给解析器，用于指定需要进行回调的内容
*/
class SAXHandler extends DefaultHandler{

/**
* 用于标志是否已经读取到指定的元素
*/
private boolean isName;
private boolean isAge;
private boolean isGender;

@Override
public void startDocument() throws SAXException {
System.out.println("Starting parse the document");
}

@Override
public void endDocument() throws SAXException {
System.out.println("Ending parse the document");
}

@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if ("student".equalsIgnoreCase(qName)){
System.out.println("student");
}else if ("name".equalsIgnoreCase(qName)){
isName = true;
}else if ("age".equalsIgnoreCase(qName)){
isAge = true;
}else if ("gender".equalsIgnoreCase(qName)){
isGender = true;
}
}

@Override
public void characters(char[] ch, int start, int length) throws SAXException {
String content = new String(ch, start, length);
if (isName){
System.out.printf("  Name: %s\n", content);
isName = false; // 这里需要额外注意，当读取到一个节点之后，需要
// 把该节点的标志去除，不然下一次读取会出现问题
}else if (isAge){
System.out.printf("  Age: %s\n", content);
isAge = false;
}else if (isGender){
System.out.printf("  Gender: %s\n", content);
isGender = false;
}
}
}

public void parser(){
try {
File file = new File("d:/students.xml");
// 创建一个SAX解析器
SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
javax.xml.parsers.SAXParser parser = saxParserFactory.newSAXParser();
// 解析对应的文件
parser.parse(file, new SAXHandler());
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

对应的输出结果如下所示：

student
Name: xuhuanfeng
Age: 22
Gender: male
# 这里由于篇幅原因，省略其他两个输出内容

由于SAX解析本身不利于节点的保存以及编辑，所以这里就不演示器编辑的过程。

第三方类库解析

上面的内容就是XML解析的最基本的操作了，不过，由于原生API操作不方便，加上效率不怎么高，所以就出现了许多的第三方的解析类库，最常使用的包括了JDOM、StAX、XPath、DOM4j等，下面我们将逐个演示其操作

JDOM解析

JDOM是我们所要接触的第一个第三方解析类库，其操作的原理是基于DOM解析操作，不过JDOM的解析效率比原生操作高，内存占用相对低，使用的时候需要导入JDOM的jar文件，下载地址

解析文档

public void parse(){
try {
File file = new File("d:/students.xml");
// 获得一个解析器
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(file);
// 获得根元素
Element rootElement = document.getRootElement();
System.out.printf("Root Element %s\n", rootElement.getName());
List<Element> elements = rootElement.getChildren();
for (Element e : elements){
System.out.printf(" %s\n", e.getName());
System.out.printf("  Name: %s\n", e.getChild("name").getTextTrim());
System.out.printf("  Age: %s\n", e.getChild("age").getTextTrim());
System.out.printf("  Gender: %s\n", e.getChild("gender").getTextTrim());
}
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

可以看到使用JDOM进行解析是比较方便的，而且由于JDOM使用了List等容器类，更加方便操作了。

StAX解析

StAx是我们要使用的第二个第三方解析类库，StAX的实现原理为SAX操作，不过StAX提供了比原生SAX解析更加方便的操作，使用时同样需要导入其jar文件，下载地址

解析文档

public void parse(){

boolean isName = false;
boolean isAge = false;
boolean isGender = false;

try {
File file = new File("d:/students.xml");
// 获得解析器
XMLInputFactory factory = XMLInputFactory.newFactory();
XMLEventReader reader = factory.createXMLEventReader(new FileReader(file));

while (reader.hasNext()){
// 获得事件
XMLEvent event = reader.nextEvent();
switch (event.getEventType()){
// 解析事件的类型
case XMLStreamConstants.START_ELEMENT:
StartElement startElement = event.asStartElement();
String qName = startElement.getName().getLocalPart();
if ("name".equalsIgnoreCase(qName)){
isName = true;
}else if ("age".equalsIgnoreCase(qName)){
isAge = true;
}else if ("gender".equalsIgnoreCase(qName)){
isGender = true;
}
break;
case XMLStreamConstants.CHARACTERS:
Characters characters = event.asCharacters();
if (isName){
System.out.printf(" Name: %s\n", characters.getData());
isName = false;
}else if (isAge){
System.out.printf(" Age: %s\n", characters.getData());
isAge = false;
}else if (isGender){
System.out.printf(" Gender: %s\n", characters.getData());
isGender = false;
}
break;
}
}
} catch (XMLStreamException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

XPath

XPath从严格意义上来讲并不是一种解析方式，不过XPath提供了一种定位节点的方式，XPath表达式，通过该表达式，我们可以定位到指定特性的一个或者一组节点

常用的XPath表达式如下所示：

/ ：从根节点开始查找

//：从当前节点开始查找

. ：选择当前节点

..：选择当前节点的父节点

@：指定元素

还有其他一些表达式，可以参考XPath表达式

解析文档

public void parse(){
try {
File file = new File("d:/students.xml");
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
// 创建xpath对象
XPath xPath = XPathFactory.newInstance().newXPath();
Document document = builder.parse(file);
// 编写xpath表达式
String expression = "/students/student";
NodeList students = (NodeList)xPath.compile(expression).evaluate(document, XPathConstants.NODESET);
for (int i = 0; i < students.getLength(); i++){
Node node = students.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE){
Element element = (Element) node;
System.out.printf(" Element: %s\n", element.getNodeName());
System.out.printf(" Name: %s\n", element.getElementsByTagName("name").item(0).getTextContent());
System.out.printf(" Age: %s\n", element.getElementsByTagName("age").item(0).getTextContent());
System.out.printf(" Gender: %s\n", element.getElementsByTagName("gender").item(0).getTextContent());
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (XPathExpressionException e) {
e.printStackTrace();
}
}

可以看到，使用XPath技术本质上还是使用DOM解析，只不过借助XPath表达式，可以很方便地定位到指定元素

DOM4J解析

DOM4J是一个比较优秀的解析类库，也是目前使用得比较多的库类，使用的时候可以配合XPath技术来辅助定位某一个节点，使用的时候需要导入对应的jar文件，下载地址，注意使用DOM4J的时候需要导入两个jar文件，DOM4J本身的jar文件以及jaxen文件

解析文档

public void parse() throws DocumentException {
File file = new File("d:/students.xml");

// 加载文档
SAXReader reader = new SAXReader();
Document document = reader.read(file);

Element rootElement = document.getRootElement();
System.out.printf("Root Element: %s\n", rootElement.getName());
// 使用XPath表达式来定位节点
List<Node> students = document.selectNodes("/students/student");
for (Node n: students){
System.out.printf("Element: %s\n", n.getName());

System.out.printf("Name: %s\n", n.selectSingleNode("name").getText());
System.out.printf("Age: %s\n", n.selectSingleNode("age").getText());
System.out.printf("Gender: %s\n", n.selectSingleNode("gender").getText());
}
}

可以看到，使用DOM4J解析文档是非常方便的，不仅如此，使用DOM4J生成文档也是非常方便的

生成文档

public void create() throws IOException {
Document document = DocumentHelper.createDocument();
Element root = document.addElement("students");

Element student = root.addElement("student");

student.addElement("name")
.addText("xuhuanfeng");

student.addElement("age")
.addText("22");

OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter(System.out);
writer.write(document);
}

总结

本节我们学习了XML解析的机制，包括了DOM解析以及SAX解析，并且通过具体实例使用不同解析技术进行解析，还了解了几个常用的XML解析类库，包括了JDOM、StAX、XPath、DOM4J等，并且通过具体操作更加具体地了解了其操作的过程。