1、Java 读取 xml 文件的五种方式

在 Java 中读取 XML 文件有多种方法，这里列出五种常见的方式：

1. DOM 解析器（Document Object Model）：DOM 是处理 XML 文件的一种标准方法，它将整个 XML 文件加载到内存中，然后构造成一个树状结构以便程序可以操作。这种方法适合于需要对文档进行频繁读写操作的情况；
2. SAX 解析器（Simple API for XML）：SAX 是一种基于事件的解析方式，它不会将整个 XML 文档加载到内存中。这种方法适用于只需要读取 XML 文档的情况，特别是处理非常大的文件时；
3. StAX 解析器（Streaming API for XML）：StAX 是一种拉式解析（Pull Parsing）技术，允许程序员按需读取 XML 数据。这种方式适合于需要对 XML 文档进行增量处理的情况；
4. JAXB（Java Architecture for XML Binding）：JAXB 允许 Java 开发者通过注解将 Java 对象映射到 XML 文件，反之亦然。这适用于需要将 XML 数据直接转换为 Java 对象的场合；
5. JDOM（Java Document Object Model）：JDOM 提供了一种简洁而易用的 API，用于解析、创建和操作 XML 文档。它基于树形结构，类似于 DOM，但提供了更简单的 API，适用于中小型 XML 文件的处理。

首先是 XML 示例：

<?xml version="1.0" encoding="UTF-8"?>
<library>
    <book>
        <title>三国演义</title>
        <author>罗贯中</author>
        <year>1330</year>
    </book>
    <book>
        <title>西游记</title>
        <author>吴承恩</author>
        <year>1500</year>
    </book>
</library>

接下来，我们将使用不同的方式读取并打印这个 XML 示例。

2、DOM（文档对象模型）解析

DOM 将整个 XML 文档加载到内存中，以树形结构表示。这种方式易于遍历和操作，适合对整个文档进行多次读写操作，但可能消耗大量内存，不适合处理大型 XML 文件。

DOM 是 Java 标准库的一部分，无需额外引入依赖。

代码实现：

package com.bianchengxiaobai;

import org.w3c.dom.*;
import javax.xml.parsers.*;

/**
 * DOM 方式读取 XML文件
 * @author bianchengxiaobai
 */
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.bianchengxiaobai;

import org.xml.sax.*;
import org.xml.sax.helpers.*;

/**
 * SAX 解析 XML 示例
 * 该类继承了 DefaultHandler 类，用于处理 SAX 事件
 *
 * @author bianchengxiaobai
 */
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.bianchengxiaobai;

import javax.xml.stream.*;

/**
 * 使用 StAX（Streaming API for XML）方式读取 XML 文件示例
 * 该类实现了对 XML 文件的解析，并打印每本书的信息
 *
 * @author bianchengxiaobai
 */
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.bianchengxiaobai;

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 bianchengxiaobai
 */
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 ObjectModel）

JDOM 提供了一种简洁而易用的 API，用于解析、创建和操作 XML 文档。它基于树形结构，类似于 DOM，但提供了更简单的 API，适用于中小型 XML 文件的处理。

引入依赖：

        <dependency>
            <groupId>org.jdom</groupId>
            <artifactId>jdom2</artifactId>
            <version>2.0.6.1</version>
        </dependency>

代码实现：

package com.bianchengxiaobai;

import org.jdom2.*;
import org.jdom2.input.*;

/**
 * 使用 JDOM 方式读取 XML 文件
 * 该程序从 XML 文件中读取图书信息，并打印每本书的标题、作者和年份
 * XML 文件的根元素为 "library"，每个 "book" 元素表示一本书
 * @author bianchengxiaobai
 */
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);
        }
    }
}