XML 可扩展标记语言

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

<!-- 普通元素：开始标签 + 内容 + 结束标签 -->
<hello>大家好</hello>

<!-- 嵌套元素 -->
<user>
    <name>张三</name>
    <age>25</age>
</user>

<!-- 空元素：自闭合形式 -->
<br/>
<close/>

<?xml version="1.0" encoding="UTF-8"?>
<users>
    <user id="001">
        <name>张百万</name>
        <age>25</age>
    </user>
    <user id="002">
        <name>小斌</name>
        <age>18</age>
        <hobby>
            <sport>乒乓球</sport>
        </hobby>
    </user>
    <empty/>
</users>

<bean id="userService" class="com.example.UserService">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!-- 使用属性 -->
<person name="张三" age="25"/>

<!-- 使用子元素 -->
<person>
    <name>张三</name>
    <age>25</age>
</person>

<!-- 这是单行注释 -->

<!--
  这是多行注释
  可以跨越多行
-->

<script>
    <![CDATA[
        if (a < b && b > c) {
            console.log("条件成立");
        }
    ]]>
</script>

<?xml version="1.0" encoding="UTF-8"?>
<employees>
    <employee eid="1">
        <ename>韩梅梅</ename>
        <age>20</age>
        <sex>女</sex>
        <salary>5000</salary>
        <hiredate>2019-03-14</hiredate>
    </employee>
    <employee eid="2">
        <ename>光明顶</ename>
        <age>40</age>
        <sex>男</sex>
        <salary>15000</salary>
        <hiredate>2010-01-01</hiredate>
    </employee>
</employees>

<!ELEMENT students (student+)>           <!-- 根元素，至少包含一个 student -->
<!ELEMENT student (name, age, sex)>     <!-- 子元素必须按顺序出现 -->
<!ELEMENT name (#PCDATA)>               <!-- 普通文本内容 -->
<!ELEMENT age (#PCDATA)>
<!ELEMENT sex (#PCDATA)>
<!ATTLIST student number ID #REQUIRED>  <!-- 定义属性：ID 类型，必须填写 -->

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE students SYSTEM "student.dtd">
<students>
    <student number="S001">
        <name>光明顶</name>
        <age>20</age>
        <sex>男</sex>
    </student>
    <student number="S002">
        <name>韩梅梅</name>
        <age>18</age>
        <sex>女</sex>
    </student>
</students>

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.example.com/xml"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.example.com/xml"
            elementFormDefault="qualified">

    <!-- 定义根元素 -->
    <xsd:element name="students" type="studentsType"/>

    <!-- 复杂类型：包含子元素 -->
    <xsd:complexType name="studentsType">
        <xsd:sequence>
            <xsd:element name="student" type="studentType"
                         minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>

    <!-- 学生类型 -->
    <xsd:complexType name="studentType">
        <xsd:sequence>
            <xsd:element name="name" type="xsd:string"/>
            <xsd:element name="age" type="ageType"/>
            <xsd:element name="sex" type="sexType"/>
        </xsd:sequence>
        <xsd:attribute name="number" type="numberType" use="required"/>
    </xsd:complexType>

    <!-- 简单类型：性别枚举 -->
    <xsd:simpleType name="sexType">
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="male"/>
            <xsd:enumeration value="female"/>
        </xsd:restriction>
    </xsd:simpleType>

    <!-- 简单类型：年龄范围 -->
    <xsd:simpleType name="ageType">
        <xsd:restriction base="xsd:integer">
            <xsd:minInclusive value="0"/>
            <xsd:maxInclusive value="150"/>
        </xsd:restriction>
    </xsd:simpleType>

    <!-- 简单类型：学号格式 -->
    <xsd:simpleType name="numberType">
        <xsd:restriction base="xsd:string">
            <xsd:pattern value="S_\d{4}"/>
        </xsd:restriction>
    </xsd:simpleType>
</xsd:schema>

<?xml version="1.0" encoding="UTF-8"?>
<students xmlns="http://www.example.com/xml"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://www.example.com/xml student.xsd">
    <student number="S_0001">
        <name>张三</name>
        <age>20</age>
        <sex>male</sex>
    </student>
    <student number="S_0002">
        <name>李四</name>
        <age>22</age>
        <sex>female</sex>
    </student>
</students>

<dependency>
    <groupId>org.dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>2.1.4</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<users>
    <user id="001">
        <name>大叶</name>
        <age>25</age>
        <hobby>编程</hobby>
    </user>
    <user id="002">
        <name>小叶</name>
        <age>18</age>
        <hobby>阅读</hobby>
    </user>
</users>

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.Test;

import java.util.List;

public class Dom4jDemo {

    @Test
    public void testParseElements() throws DocumentException {
        // 创建 SAX 读取器
        SAXReader reader = new SAXReader();
        // 读取 XML 文件并构建文档对象
        Document document = reader.read("src/main/resources/user.xml");
        // 获取根元素
        Element rootElement = document.getRootElement();

        System.out.println("根元素: " + rootElement.getName());

        // 遍历根元素下的所有子元素
        List<Element> users = rootElement.elements();
        for (Element user : users) {
            System.out.println("子元素: " + user.getName());

            // 遍历每个 user 元素下的子元素
            List<Element> children = user.elements();
            for (Element child : children) {
                System.out.println("  - " + child.getName());
            }
        }
    }

    @Test
    public void testParseData() throws DocumentException {
        SAXReader reader = new SAXReader();
        Document document = reader.read("src/main/resources/user.xml");
        Element rootElement = document.getRootElement();

        List<Element> users = rootElement.elements();

        for (Element user : users) {
            // 获取属性值
            String id = user.attributeValue("id");
            // 获取子元素文本（两种方式）
            String name = user.elementText("name");       // 方式一：直接获取文本
            String age = user.elementText("age");
            String hobby = user.element("hobby").getText(); // 方式二：先获取元素再取文本

            System.out.printf("ID: %s, 姓名: %s, 年龄: %s, 爱好: %s%n",
                              id, name, age, hobby);
        }
    }
}

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Dom4jWriteDemo {

    public static void main(String[] args) throws IOException {
        // 创建空文档
        Document document = DocumentHelper.createDocument();
        // 添加根元素
        Element root = document.addElement("users");

        // 方式一：链式调用添加元素（注意链式调用会返回最后添加的元素）
        root.addElement("user")
            .addAttribute("id", "001")
            .addElement("name").addText("张三");

        // 链式调用后需要回到 user 元素继续添加子元素
        root.element("user").addElement("age").addText("25");

        // 方式二：分步添加，更清晰可控
        Element user2 = root.addElement("user");
        user2.addAttribute("id", "002");
        user2.addElement("name").addText("李四");
        user2.addElement("age").addText("30");

        // 设置输出格式（美化缩进）
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("UTF-8");

        // 写入文件（Java 7+ 推荐使用 try-with-resources）
        try (XMLWriter writer = new XMLWriter(
                new FileOutputStream("output.xml"), format)) {
            writer.write(document);
            System.out.println("XML 文件写入成功");
        }
    }
}

<dependency>
    <groupId>jaxen</groupId>
    <artifactId>jaxen</artifactId>
    <version>1.2.0</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
    <book id="book1">
        <name>金瓶梅</name>
        <author>金圣叹</author>
        <price>99</price>
    </book>
    <book id="book2">
        <name>红楼梦</name>
        <author>曹雪芹</author>
        <price>69</price>
    </book>
    <book id="book3">
        <name>Java编程思想</name>
        <author>埃克尔</author>
        <price>59</price>
    </book>
</bookstore>

import org.dom4j.Document;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.junit.Test;

import java.util.List;

public class XPathDemo {

    @Test
    public void testSelectSingleNode() throws Exception {
        SAXReader reader = new SAXReader();
        Document document = reader.read("src/main/resources/book.xml");

        // 绝对路径：获取第一本书的书名
        Node node1 = document.selectSingleNode("/bookstore/book/name");
        System.out.println("第一本书名: " + node1.getText());

        // 索引定位：获取第二本书的书名（XPath 索引从 1 开始）
        Node node2 = document.selectSingleNode("/bookstore/book[2]/name");
        System.out.println("第二本书名: " + node2.getText());

        // last() 函数：获取最后一本书的书名
        Node node3 = document.selectSingleNode("/bookstore/book[last()]/name");
        System.out.println("最后一本书名: " + node3.getText());
    }

    @Test
    public void testSelectByAttribute() throws Exception {
        SAXReader reader = new SAXReader();
        Document document = reader.read("src/main/resources/book.xml");

        // 获取属性值
        Node attr = document.selectSingleNode("/bookstore/book/@id");
        System.out.println("第一个 book 的 id: " + attr.getText());

        // 根据属性值筛选元素
        Node book = document.selectSingleNode("/bookstore/book[@id='book2']");
        String name = book.selectSingleNode("name").getText();
        System.out.println("id=book2 的书名: " + name);
    }

    @Test
    public void testSelectNodes() throws Exception {
        SAXReader reader = new SAXReader();
        Document document = reader.read("src/main/resources/book.xml");

        // 获取所有节点
        List<Node> allNodes = document.selectNodes("//*");
        System.out.println("所有节点数量: " + allNodes.size());

        // 获取所有指定名称的节点
        List<Node> names = document.selectNodes("//name");
        System.out.println("所有书名:");
        for (Node node : names) {
            System.out.println("  - " + node.getText());
        }

        // 组合条件：获取指定属性值元素下的所有内容
        List<Node> book1Content = document.selectNodes(
            "/bookstore/book[@id='book1']//*");
        System.out.println("book1 的所有内容:");
        for (Node node : book1Content) {
            if (!node.getText().trim().isEmpty()) {
                System.out.println("  " + node.getName() + ": " + node.getText());
            }
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<jdbc>
    <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb?useSSL=false&amp;serverTimezone=UTC&amp;characterEncoding=UTF-8</property>
    <property name="user">root</property>
    <property name="password">123456</property>
    <property name="initialSize">5</property>
    <property name="maxTotal">20</property>
</jdbc>

import org.dom4j.Document;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

public class XmlJdbcUtils {

    private static final Map<String, String> CONFIG = new HashMap<>();

    // 静态初始化块：类加载时读取配置并注册驱动
    static {
        try {
            loadConfig();
            Class.forName(CONFIG.get("driverClass"));
        } catch (Exception e) {
            throw new RuntimeException("初始化 JDBC 配置失败", e);
        }
    }

    /**
     * 从 XML 配置文件中加载数据库连接参数
     * 使用 XPath 精确定位每个 property 元素
     */
    private static void loadConfig() throws Exception {
        SAXReader reader = new SAXReader();
        Document document = reader.read(
            XmlJdbcUtils.class.getResourceAsStream("/jdbc-config.xml"));

        String[] keys = {"driverClass", "jdbcUrl", "user", "password",
                         "initialSize", "maxTotal"};

        for (String key : keys) {
            // 通过 XPath 按属性名定位元素
            Node node = document.selectSingleNode(
                "/jdbc/property[@name='" + key + "']");
            if (node != null) {
                CONFIG.put(key, node.getText());
            }
        }
    }

    /**
     * 获取数据库连接
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(
            CONFIG.get("jdbcUrl"),
            CONFIG.get("user"),
            CONFIG.get("password")
        );
    }

    /**
     * 获取指定配置项的值
     */
    public static String getConfig(String key) {
        return CONFIG.get(key);
    }
}

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class XmlJdbcTest {

    public static void main(String[] args) {
        // 使用 try-with-resources 自动关闭资源
        try (Connection connection = XmlJdbcUtils.getConnection()) {
            String sql = "SELECT id, name, age FROM user LIMIT 5";

            try (PreparedStatement ps = connection.prepareStatement(sql);
                 ResultSet rs = ps.executeQuery()) {

                System.out.println("数据库连接成功，查询结果：");
                while (rs.next()) {
                    System.out.printf("ID: %d, 姓名: %s, 年龄: %d%n",
                        rs.getInt("id"),
                        rs.getString("name"),
                        rs.getInt("age"));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// SAXReader 核心方法（简化版，基于 DOM4J 2.1.4 源码）
public Document read(InputSource inputSource) throws DocumentException {
    try {
        // 1. 获取 JDK 内置的 SAXParserFactory
        SAXParserFactory factory = SAXParserFactory.newInstance();
        // 2. 配置解析器特性（命名空间、验证等）
        configureParserFactory(factory);
        // 3. 创建 SAXParser
        SAXParser parser = factory.newSAXParser();
        // 4. 创建 DOM4J 自定义的 ContentHandler
        //    SAXContentHandler 是核心：它将 SAX 事件转换为 DOM4J 的 Element 树
        SAXContentHandler contentHandler = new SAXContentHandler(
            getDocumentFactory(),  // 文档工厂，创建 Element/Attribute 对象
            getElementHandler()    // 元素处理器，可自定义扩展
        );
        // 5. 将 ContentHandler 注册到 SAXParser
        parser.getXMLReader().setContentHandler(contentHandler);
        // 6. 开始解析，SAX 事件驱动 contentHandler 构建文档树
        parser.parse(inputSource);
        // 7. 返回构建完成的 Document
        return contentHandler.getDocument();
    } catch (Exception e) {
        throw new DocumentException("解析 XML 失败", e);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 公共配置：所有环境共享 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 数据源定义由各环境配置文件覆盖 -->
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 开发环境数据源：本地 MySQL -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb_dev?useSSL=false&amp;serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="initialSize" value="5"/>
        <property name="maxActive" value="20"/>
    </bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 生产环境数据源：使用加密密码 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://prod-db-master:3306/mydb?useSSL=true&amp;serverTimezone=UTC"/>
        <property name="username" value="app_user"/>
        <!-- 使用 Druid 内置加密，密码为加密后的密文 -->
        <property name="password" value="加密后的密文"/>
        <property name="connectionProperties" value="config.decrypt=true"/>
        <property name="initialSize" value="10"/>
        <property name="maxActive" value="100"/>
        <property name="minIdle" value="10"/>
        <property name="maxWait" value="60000"/>
        <!-- 连接有效性检测 -->
        <property name="validationQuery" value="SELECT 1"/>
        <property name="testWhileIdle" value="true"/>
    </bean>
</beans>

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.io.FileInputStream;

public class XmlParserOptimization {

    // 复用 SAXReader 实例（注意：SAXReader 不是线程安全的，
    // 多线程环境下应使用 ThreadLocal 或每次创建新实例）
    private static final ThreadLocal<SAXReader> READER_POOL =
        ThreadLocal.withInitial(SAXReader::new);

    /**
     * 使用线程安全的 SAXReader 解析文档
     */
    public static Document parseDocument(String filePath) throws DocumentException {
        SAXReader reader = READER_POOL.get();
        try {
            return reader.read(filePath);
        } finally {
            READER_POOL.remove(); // 避免内存泄漏
        }
    }

    /**
     * 解析大文件：使用 InputStream 并指定编码
     * 确保流资源被正确关闭
     */
    public static void parseLargeFile(String filePath) throws Exception {
        try (InputStream is = new FileInputStream(filePath)) {
            SAXReader reader = new SAXReader();
            reader.setEncoding("UTF-8");
            Document document = reader.read(is);
            // 处理文档...
        }
    }
}

// 解决方案：确保编码一致
// 1. XML 声明指定 UTF-8
// 2. 文件保存为 UTF-8 编码
// 3. 读取时指定编码

SAXReader reader = new SAXReader();
reader.setEncoding("UTF-8");
Document document = reader.read(new InputStreamReader(
    new FileInputStream("file.xml"), StandardCharsets.UTF_8));

// 使用命名空间时，XPath 需要特殊处理
Map<String, String> namespaceMap = new HashMap<>();
namespaceMap.put("ns", "http://www.example.com/xml");

XPath xpath = document.createXPath("//ns:user");
xpath.setNamespaceURIs(namespaceMap);
List<Node> nodes = xpath.selectNodes(document);

<!-- 使用 CDATA 包含特殊字符 -->
<sql>
    <![CDATA[
        SELECT * FROM user WHERE age < 18 AND status = 'active'
    ]]>
</sql>

// Java 17+ 使用 DOM4J 可能遇到的模块访问问题
// 启动参数添加：
// --add-opens java.base/java.lang=ALL-UNNAMED
// --add-opens java.base/java.lang.reflect=ALL-UNNAMED

// 或者升级到 DOM4J 3.x（开发中），原生支持模块系统