Java读取xml文件的五种方式
作者：栗筝i
在编写与 XML 数据交互的现代软件应用时,有效地读取和解析 XML 文件是至关重要的,本文旨在探讨 Java 中处理 XML 文件的五种主要方法：DOM、SAX、StAX、JAXB 和 JDOM,我们将详细介绍每种方法的工作原理、典型用途以及如何在 Java 程序中实现它们
前言
在编写与 XML 数据交互的现代软件应用时，有效地读取和解析 XML 文件是至关重要的。XML（可扩展标记语言）因其灵活性和自我描述性，已成为数据存储和传输的一种普遍格式。对于 Java 开发者来说，Java 提供了多种工具和库来处理 XML 文件，每种工具都有其独特的特点和最适用的场景。
本文旨在探讨 Java 中处理 XML 文件的五种主要方法：DOM、SAX、StAX、JAXB 和 JDOM。这些技术各有优势和局限，选择合适的方法可以大大提高开发效率和程序性能。我们将详细介绍每种方法的工作原理、典型用途以及如何在 Java 程序中实现它们。
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 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 标准库的一部分，无需额外引入依赖。
代码实现：
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 标准库的一部分，无需额外引入依赖。
代码实现：
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 更容易使用和理解。
引入依赖：
<dependency>
<groupId>javax.xml.stream</groupId>
<artifactId>stax-api</artifactId>
<version>1.0-2</version>
</dependency>
代码实现：
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 标准库的一部分，无需额外引入依赖。
代码实现：
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 文件的处理。
引入依赖：
<dependency>
<groupId>org.jdom</groupId>
<artifactId>jdom2</artifactId>
<version>2.0.6.1</version>
</dependency>
代码实现：
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);
}
}
}
以上就是Java读取xml文件的五种方式的详细内容，更多关于Java读取xml文件的资料请关注脚本之家其它相关文章！