在编写与 XML 数据交互的现代软件应用时,有效地读取和解析 XML 文件是至关重要的。XML(可扩展标记语言)因其灵活性和自我描述性,已成为数据存储和传输的一种普遍格式。对于 Java 开发者来说,Java 提供了多种工具和库来处理 XML 文件,每种工具都有其独特的特点和最适用的场景。
本文旨在探讨 Java 中处理 XML 文件的五种主要方法:DOM、SAX、StAX、JAXB 和 JDOM。这些技术各有优势和局限,选择合适的方法可以大大提高开发效率和程序性能。我们将详细介绍每种方法的工作原理、典型用途以及如何在 Java 程序中实现它们。
文章目录
-
-
- [1、Java 读取 xml 文件的五种方式](#1、Java 读取 xml 文件的五种方式)
- 2、DOM(文档对象模型)解析
- [3、SAX(简单 API for XML)解析](#3、SAX(简单 API for XML)解析)
- [4、StAX(流 API for XML)解析](#4、StAX(流 API for XML)解析)
- [5、JAXB(Java Architecture for XML Binding)](#5、JAXB(Java Architecture for XML Binding))
- [6、JDOM(Java Document Object Model)](#6、JDOM(Java Document Object Model))
-
1、Java 读取 xml 文件的五种方式
在 Java 中读取 XML 文件有多种方法,这里列出五种常见的方式:
- DOM 解析器(Document Object Model):DOM 是处理 XML 文件的一种标准方法,它将整个 XML 文件加载到内存中,然后构造成一个树状结构以便程序可以操作。这种方法适合于需要对文档进行频繁读写操作的情况;
- SAX 解析器(Simple API for XML):SAX 是一种基于事件的解析方式,它不会将整个 XML 文档加载到内存中。这种方法适用于只需要读取 XML 文档的情况,特别是处理非常大的文件时;
- StAX 解析器(Streaming API for XML):StAX 是一种拉式解析(Pull Parsing)技术,允许程序员按需读取 XML 数据。这种方式适合于需要对 XML 文档进行增量处理的情况;
- JAXB(Java Architecture for XML Binding):JAXB 允许 Java 开发者通过注解将 Java 对象映射到 XML 文件,反之亦然。这适用于需要将 XML 数据直接转换为 Java 对象的场合;
- JDOM(Java Document Object Model):JDOM 提供了一种简洁而易用的 API,用于解析、创建和操作 XML 文档。它基于树形结构,类似于 DOM,但提供了更简单的 API,适用于中小型 XML 文件的处理。
首先是 XML 示例:
xml
xml
复制代码
<?xml version="1.0" encoding="UTF-8"?>
<library>
<book>
<title>Java Programming</title>
<author>John Smith</author>
<year>2022</year>
</book>
<book>
<title>Python Basics</title>
<author>Jane Doe</author>
<year>2021</year>
</book>
</library>
接下来,我们将使用不同的方式读取并打印这个 XML 示例。
2、DOM(文档对象模型)解析
DOM 将整个 XML 文档加载到内存中,以树形结构表示。这种方式易于遍历和操作,适合对整个文档进行多次读写操作,但可能消耗大量内存,不适合处理大型 XML 文件。
DOM 是 Java 标准库的一部分,无需额外引入依赖。
代码实现:
java
package com.lizhengi;
import org.w3c.dom.*;
import javax.xml.parsers.*;
/**
* DOM 方式读取 XML文件
* @author lizhengi
*/
public class DomReadExample {
public static void main(String[] args) throws Exception {
// 创建一个 DocumentBuilderFactory 实例,用于创建 DocumentBuilder
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
// 使用工厂创建一个 DocumentBuilder 实例,用于解析 XML 文档
DocumentBuilder builder = factory.newDocumentBuilder();
// 使用 ClassLoader 获取资源文件的输入流,并解析成 Document 对象
Document document = builder.parse(DomReadExample.class.getClassLoader().getResourceAsStream("example.xml"));
// 获取 XML 文档中所有名为 "book" 的元素节点
NodeList bookNodes = document.getElementsByTagName("book");
// 遍历每个 "book" 元素节点,并输出其子元素的内容
for (int i = 0; i < bookNodes.getLength(); i++) {
Node bookNode = bookNodes.item(i);
Element bookElement = (Element) bookNode;
// 获取 "title"、"author" 和 "year" 子元素的内容
String title = bookElement.getElementsByTagName("title").item(0).getTextContent();
String author = bookElement.getElementsByTagName("author").item(0).getTextContent();
String year = bookElement.getElementsByTagName("year").item(0).getTextContent();
// 打印输出图书的信息
System.out.println("Title: " + title + ", Author: " + author + ", Year: " + year);
}
}
}
3、SAX(简单 API for XML)解析
SAX 以事件驱动的方式逐行解析 XML 文档,并在解析过程中触发事件。它不需要将整个文档加载到内存中,因此适用于处理大型 XML 文件,但相对于 DOM,它的操作稍显复杂。
SAX 是 Java 标准库的一部分,无需额外引入依赖。
代码实现:
java
package com.lizhengi;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
/**
* SAX 解析 XML 示例
* 该类继承了 DefaultHandler 类,用于处理 SAX 事件
*
* @author liziheng
*/
public class SaxReadExample extends DefaultHandler {
// 表示是否在书籍元素内部
private boolean inBookElement = false;
// 用于存储当前正在处理的元素的名称
private String currentElement;
// 当前书籍的标题
private String currentTitle;
// 当前书籍的作者
private String currentAuthor;
// 当前书籍的年份
private String currentYear;
/**
* 开始解析元素时调用
*
* @param uri 元素的命名空间 URI
* @param localName 元素的本地名称
* @param qName 元素的限定名称
* @param attributes 元素的属性
*/
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) {
if ("book".equals(qName)) {
// 进入书籍元素内部
inBookElement = true;
}
// 存储当前元素的名称
currentElement = qName;
}
/**
* 处理元素字符数据时调用
*
* @param ch 字符数组
* @param start 字符数据的起始索引
* @param length 字符数据的长度
*/
@Override
public void characters(char[] ch, int start, int length) {
if (inBookElement) {
String content = new String(ch, start, length).trim();
if (!content.isEmpty()) {
if ("title".equals(currentElement)) {
// 设置当前书籍的标题
currentTitle = content;
} else if ("author".equals(currentElement)) {
// 设置当前书籍的作者
currentAuthor = content;
} else if ("year".equals(currentElement)) {
// 设置当前书籍的年份
currentYear = content;
}
}
}
}
/**
* 结束解析元素时调用
*
* @param uri 元素的命名空间 URI
* @param localName 元素的本地名称
* @param qName 元素的限定名称
*/
@Override
public void endElement(String uri, String localName, String qName) {
if ("book".equals(qName)) {
// 打印当前书籍的信息
System.out.println("Title: " + currentTitle + ", Author: " + currentAuthor + ", Year: " + currentYear);
// 重置当前书籍的信息
currentTitle = null;
currentAuthor = null;
currentYear = null;
// 退出书籍元素内部
inBookElement = false;
}
}
/**
* 主方法,程序入口
*
* @param args 命令行参数
* @throws Exception 抛出异常
*/
public static void main(String[] args) throws Exception {
// 创建 XML 解析器
XMLReader reader = XMLReaderFactory.createXMLReader();
// 设置内容处理器为当前类的实例
reader.setContentHandler(new SaxReadExample());
// 解析 XML 文件并触发 SAX 事件
reader.parse(new InputSource(SaxReadExample.class.getClassLoader().getResourceAsStream("example.xml")));
}
}
4、StAX(流 API for XML)解析
StAX 提供了类似于 SAX 的事件驱动的解析方式,但与 SAX 不同,它提供了更简洁的 API,并允许开发者在解析过程中灵活地控制流。这使得 StAX 更容易使用和理解。
引入依赖:
java
<dependency>
<groupId>javax.xml.stream</groupId>
<artifactId>stax-api</artifactId>
<version>1.0-2</version>
</dependency>
代码实现:
java
package com.lizhengi;
import javax.xml.stream.*;
/**
* 使用 StAX(Streaming API for XML)方式读取 XML 文件示例
* 该类实现了对 XML 文件的解析,并打印每本书的信息
*
* @author lizhengi
*/
public class StaxReadExample {
public static void main(String[] args) throws Exception {
// 创建 XMLInputFactory 实例,用于创建 XMLStreamReader
XMLInputFactory factory = XMLInputFactory.newInstance();
// 创建 XMLStreamReader 实例,用于逐行读取 XML 文件内容
XMLStreamReader reader = factory.createXMLStreamReader(StaxReadExample.class.getClassLoader().getResourceAsStream("example.xml"));
// 用于存储当前正在处理的元素的名称和内容
String currentElement = null;
String currentTitle = null;
String currentAuthor = null;
String currentYear = null;
// 循环读取 XML 文件中的内容
while (reader.hasNext()) {
int event = reader.next();
switch (event) {
case XMLStreamConstants.START_ELEMENT:
// 开始处理元素时,记录当前元素的名称
currentElement = reader.getLocalName();
break;
case XMLStreamConstants.CHARACTERS:
// 处理元素的字符数据时,获取字符数据的内容
String content = reader.getText().trim();
if (!content.isEmpty()) {
// 根据当前元素的名称,存储相应的内容
if ("title".equals(currentElement)) {
currentTitle = content;
} else if ("author".equals(currentElement)) {
currentAuthor = content;
} else if ("year".equals(currentElement)) {
currentYear = content;
}
}
break;
case XMLStreamConstants.END_ELEMENT:
// 结束处理元素时,检查是否为书籍元素的结束标签
if ("book".equals(reader.getLocalName())) {
// 打印当前书籍的信息
System.out.println("Title: " + currentTitle + ", Author: " + currentAuthor + ", Year: " + currentYear);
// 重置当前书籍的信息,准备处理下一本书
currentTitle = null;
currentAuthor = null;
currentYear = null;
}
break;
}
}
}
}
5、JAXB(Java Architecture for XML Binding)
JAXB 允许将 XML 数据绑定到 Java 对象,从而简化了 XML 数据与 Java 对象之间的转换过程。它通常用于处理 XML 数据的映射和序列化,而不是直接解析整个 XML 文档。
JAXB 也是 Java 标准库的一部分,无需额外引入依赖。
代码实现:
java
package com.lizhengi;
import javax.xml.bind.*;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.ArrayList;
import java.util.List;
/**
* XML 文件对应的 Java 类,根元素为 "library"
*/
@XmlRootElement(name = "library")
class Library {
// 用于存储书籍信息的列表,每个元素对应一个书籍
@XmlElement(name = "book")
public List<Book> books = new ArrayList<Book>();
}
/**
* 书籍信息的 Java 类
*/
class Book {
// 书籍标题
@XmlElement
public String title;
// 书籍作者
@XmlElement
public String author;
// 出版年份
@XmlElement
public int year;
}
/**
* 使用 JAXB 方式读取 XML 文件
* @author lizhengi
*/
public class JaxbReadExample {
public static void main(String[] args) throws Exception {
// 创建 JAXBContext 实例,用于创建 Unmarshaller
JAXBContext context = JAXBContext.newInstance(Library.class);
// 创建 Unmarshaller 实例,用于将 XML 数据转换为 Java 对象
Unmarshaller unmarshaller = context.createUnmarshaller();
// 使用 Unmarshaller 解析 XML 文件,并将其转换为 Library 对象
Library library = (Library) unmarshaller.unmarshal(JaxbReadExample.class.getClassLoader().getResourceAsStream("example.xml"));
// 遍历 Library 中的每本书,并打印其信息
for (Book book : library.books) {
System.out.println("Title: " + book.title + ", Author: " + book.author + ", Year: " + book.year);
}
}
}
6、JDOM(Java Document Object Model)
JDOM 提供了一种简洁而易用的 API,用于解析、创建和操作 XML 文档。它基于树形结构,类似于 DOM,但提供了更简单的 API,适用于中小型 XML 文件的处理。
引入依赖:
java
<dependency>
<groupId>org.jdom</groupId>
<artifactId>jdom2</artifactId>
<version>2.0.6.1</version>
</dependency>
代码实现:
java
package com.lizhengi;
import org.jdom2.*;
import org.jdom2.input.*;
/**
* 使用 JDOM 方式读取 XML 文件
* 该程序从 XML 文件中读取图书信息,并打印每本书的标题、作者和年份
* XML 文件的根元素为 "library",每个 "book" 元素表示一本书
* @author lizhengi
*/
public class JdomReadExample {
public static void main(String[] args) throws Exception {
// 使用 SAXBuilder 创建解析器
SAXBuilder builder = new SAXBuilder();
// 使用解析器构建 XML 文档对象
Document document = builder.build(JdomReadExample.class.getClassLoader().getResourceAsStream("example.xml"));
// 获取 XML 文档的根元素
Element root = document.getRootElement();
// 遍历根元素下的所有 "book" 元素,并输出每本书的信息
for (Element book : root.getChildren("book")) {
// 获取书籍的标题、作者和年份
String title = book.getChildText("title");
String author = book.getChildText("author");
String year = book.getChildText("year");
// 打印输出书籍信息
System.out.println("Title: " + title + ", Author: " + author + ", Year: " + year);
}
}
}