轩辕李的博客
轩辕李
2023-06-11
目录

Java XML处理

# 简介

在当今的软件开发领域中，XML（可扩展标记语言）被广泛应用于数据交换和存储。

Java作为一种强大的编程语言，提供了丰富的API和工具，用于处理和操作XML数据。

# 1. XML简介

XML是一种用于描述、存储和交换数据的标记语言。它使用自定义的标签来定义数据的结构和内容。

XML具有良好的可读性和可扩展性，这使得它成为在不同系统和平台之间传输和共享数据的理想选择。

XML文档由标签和文本内容组成。标签用于标识数据的不同部分，而文本内容则包含实际的数据。XML还支持属性的使用，属性提供了有关数据的额外信息。通过合理地定义标签和属性，可以创建具有层次结构的数据模型，适应各种复杂的数据需求。

# 2. Java处理XML的重要性

Java作为一种跨平台的编程语言，被广泛应用于企业级应用和大型系统的开发。在这些应用中，数据的处理和交换是至关重要的。XML作为一种通用的数据格式，能够满足不同系统之间的数据交换需求。

Java提供了许多API和工具，使得处理XML变得简单和高效。使用Java的XML处理功能，开发人员可以轻松地解析和生成XML文档，读取和修改XML数据，以及在Java对象和XML之间进行转换。这些功能为开发人员提供了灵活性和控制力，使他们能够有效地处理各种XML数据操作。

# 3. Java XML处理的应用场景

Java XML处理在各种应用场景中扮演着重要的角色。以下是一些常见的应用场景：

  1. 数据交换：XML作为一种通用的数据格式，被广泛用于不同系统之间的数据交换。Java XML处理提供了解析和生成XML数据的功能，使得数据的转换和交互变得简单高效。

  2. 配置文件：XML被广泛用于存储应用程序的配置信息。Java XML处理使得读取和解析XML配置文件变得容易，开发人员可以通过Java API轻松地读取和修改配置信息。

  3. Web服务：在Web服务中，XML常用于表示和传输数据。Java XML处理使得在Web服务中处理和操作XML数据变得简单和高效。开发人员可以使用Java提供的XML处理功能来解析和生成XML数据，以便与其他系统进行数据交互。

  4. 数据存储：XML被广泛用于数据存储的需求。Java XML处理提供了将Java对象转换为XML格式的功能，使得将数据存储到XML文档中变得简单和方便。开发人员可以使用Java提供的XML处理API，将Java对象的属性和值映射到XML标签和属性上，并将对象的状态保存到XML文档中。这种机制对于需要将数据持久化到XML文件或数据库中的应用程序非常有用。

# Java XML处理的基本概念

Java提供了多种方式来处理和操作XML数据，下面介绍几种常用的方法。

假设我们已经有"data.xml"文件：

<?xml version="1.0" encoding="UTF-8"?>
<bookstore xmlns="http://www.example.com/bookstore"
        xmlns:author="http://www.example.com/author"
        xmlns:publisher="http://www.example.com/publisher">
    <book category="fiction">
        <title>Harry Potter and the Philosopher's Stone</title>
        <author:author>
            <author:name>J.K. Rowling</author:name>
            <author:birthplace>England</author:birthplace>
        </author:author>
        <publisher:publisher>
            <publisher:name>Bloomsbury</publisher:name>
            <publisher:location>London</publisher:location>
        </publisher:publisher>
        <price currency="USD">15.99</price>
    </book>
    <book category="non-fiction">
        <title>The Lean Startup</title>
        <author:author>
            <author:name>Eric Ries</author:name>
            <author:birthplace>United States</author:birthplace>
        </author:author>
        <publisher:publisher>
            <publisher:name>Random House</publisher:name>
            <publisher:location>New York</publisher:location>
        </publisher:publisher>
        <price currency="USD">19.99</price>
    </book>
</bookstore>

# 1. DOM（Document Object Model）解析

DOM解析是一种基于文档对象模型的XML解析方法。它将整个XML文档加载到内存中，并构建一个树状结构表示文档的层次关系。开发人员可以通过遍历这个树状结构来访问和操作XML的元素和属性。下面是一个使用DOM解析器解析XML文档的示例：

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse("data.xml");

NodeList nodeList = document.getElementsByTagName("book");
for (int i = 0; i < nodeList.getLength(); i++) {
    Node bookNode = nodeList.item(i);
    NodeList childNodes = bookNode.getChildNodes();
    for (int j = 0; j < childNodes.getLength(); j++) {
        Node childNode = childNodes.item(j);
        if (childNode.getNodeType() == Node.ELEMENT_NODE) {
            System.out.println(childNode.getNodeName() + ": " + childNode.getTextContent());
        }
    }
    System.out.println("--------------------");
}

# 2. SAX（Simple API for XML）解析

SAX解析是一种基于事件驱动的XML解析方法。它逐行读取XML文档，并在读取过程中触发相应的事件，开发人员可以实现特定的处理程序来响应这些事件。相对于DOM解析，SAX解析器对内存的消耗较小，适用于处理大型XML文档。下面是一个使用SAX解析器解析XML文档的示例：

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;

SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();

DefaultHandler handler = new DefaultHandler() {
    boolean isElement = false;

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) {
        isElement = true;
    }

    @Override
    public void characters(char[] ch, int start, int length) {
        if (isElement) {
            System.out.println(new String(ch, start, length).trim());
            isElement = false;
        }
    }
};

parser.parse("data.xml", handler);

# 3. StAX（Streaming API for XML）解析

StAX解析是一种基于流的XML解析方法。它提供了一种迭代方式来读取XML文档，开发人员可以逐个处理XML事件。相对于DOM解析和SAX解析，StAX解析器在处理速度和内存消耗方面提供了更好的平衡。下面是一个使用StAX解析器解析XML文档的示例：

import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamReader;
import java.io.FileInputStream;

XMLInputFactory factory = XMLInputFactory.newInstance();
XMLStreamReader reader = factory.createXMLStreamReader(new FileInputStream("data.xml"));

while (reader.hasNext()) {
    int event = reader.next();
    switch (event) {
        case XMLStreamConstants.CHARACTERS:
            String text = reader.getText().trim();
            if (!text.isEmpty()) {
                System.out.println("Text: " + text);
            }
            break;
    }
}

reader.close();

# 4. XPath

XPath是一种用于在XML文档中定位和选择节点的语言。Java提供了XPath API，可以使用XPath表达式来查询和操作XML文档。下面是一个使用XPath查询XML文档的示例：

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathFactory;
import javax.xml.xpath.XPathConstants;
import org.w3c.dom.Node;

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse("data.xml");

XPathFactory xPathFactory = XPathFactory.newInstance();
XPath xpath = xPathFactory.newXPath();
String expression = "/bookstore/book/title";
NodeList nodeList = (NodeList) xpath.evaluate(expression, document, XPathConstants.NODESET);

for (int i = 0; i < nodeList.getLength(); i++) {
    Node node = nodeList.item(i);
    System.out.println(node.getTextContent());
}

# 5. XSLT（Extensible Stylesheet Language Transformations）

XSLT是一种用于将XML文档转换为其他格式的语言。Java提供了XSLT处理功能，可以使用XSLT样式表来定义XML到其他格式（如HTML、XML或文本）的转换规则。下面是一个使用XSLT将XML文档转换为HTML的示例：

import java.io.File;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

File xmlFile = new File("data.xml");
File xsltFile = new File("transform.xsl");
File outFile = new File("output.html");

StreamSource xmlSource = new StreamSource(xmlFile);
StreamSource xsltSource = new StreamSource(xsltFile);
StreamResult outputResult = new StreamResult(outFile);

TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(xsltSource);

transformer.transform(xmlSource, outputResult);

System.out.println("Transformation completed.");

transform.xsl文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
        xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
        xmlns:bookstore="http://www.example.com/bookstore"
        xmlns:author="http://www.example.com/author"
        xmlns:publisher="http://www.example.com/publisher"
        exclude-result-prefixes="bookstore author publisher">

    <xsl:output method="html"/>

    <xsl:template match="/">
        <html>
            <body>
                <h2>Books</h2>
                <table border="1">
                    <tr bgcolor="#9acd32">
                        <th>Title</th>
                        <th>Author</th>
                        <th>Price</th>
                    </tr>
                    <xsl:apply-templates select="//bookstore:book"/>
                </table>
            </body>
        </html>
    </xsl:template>

    <xsl:template match="bookstore:book">
        <tr>
            <td><xsl:value-of select="bookstore:title"/></td>
            <td><xsl:value-of select="author:author/author:name"/></td>
            <td><xsl:value-of select="bookstore:price"/></td>
        </tr>
    </xsl:template>
</xsl:stylesheet>

输出的output.html文件内容如下：

<html>
    <body>
        <h2>Books</h2>
        <table border="1">
            <tr bgcolor="#9acd32">
                <th>Title</th><th>Author</th><th>Price</th>
            </tr>
            <tr>
                <td>Harry Potter and the Philosopher's Stone</td><td>J.K. Rowling</td><td>15.99</td>
            </tr>
            <tr>
                <td>The Lean Startup</td><td>Eric Ries</td><td>19.99</td>
            </tr>
        </table>
    </body>
</html>

# Java XML处理的基本操作

# 1. 创建XML文档

import org.junit.jupiter.api.Test;
import org.w3c.dom.Document;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.StringWriter;

@Test
public void createXMLDocument() {
    try {
        // 创建文档工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();

        // 创建文档对象
        Document document = builder.newDocument();

        // 创建根元素
        String rootElementName = "books";
        org.w3c.dom.Element rootElement = document.createElement(rootElementName);
        document.appendChild(rootElement);

        // 创建子元素
        String bookElementName = "book";
        org.w3c.dom.Element bookElement = document.createElement(bookElementName);
        rootElement.appendChild(bookElement);

        // 添加子元素的属性
        bookElement.setAttribute("id", "1");

        // 添加子元素的文本内容
        String title = "Java Programming";
        org.w3c.dom.Element titleElement = document.createElement("title");
        titleElement.appendChild(document.createTextNode(title));
        bookElement.appendChild(titleElement);

        // 将文档转换为字符串
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        StringWriter writer = new StringWriter();
        transformer.transform(new DOMSource(document), new StreamResult(writer));
        String xmlString = writer.toString();

        // 断言输出的XML字符串是否符合预期
        String expectedXmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books><book id=\"1\"><title>Java Programming</title></book></books>";
        Assertions.assertEquals(xmlString, expectedXmlString);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 2. 读取XML文档

import org.junit.jupiter.api.Test;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.StringReader;

@Test
public void readXMLDocument() {
    try {
        // XML文档字符串
        String xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books><book id=\"1\"><title>Java Programming</title></book></books>";

        // 创建文档工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();

        // 从XML字符串创建文档对象
        Document document = builder.parse(new InputSource(new StringReader(xmlString)));

        // 读取XML节点的值
        String title = document.getElementsByTagName("title").item(0).getTextContent();

        // 断言读取的节点值是否符合预期
        Assertions.assertEquals(title, "Java Programming");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 3. 解析XML文档

@Test
public void testSAXParsing() {
    try {
        // 创建 SAXParserFactory 对象
        SAXParserFactory factory = SAXParserFactory.newInstance();

        // 创建 SAXParser 对象
        SAXParser saxParser = factory.newSAXParser();

        // 解析 XML 文档
        String xmlString = "<root><element1>Value 1</element1><element2>Value 2</element2></root>";
        saxParser.parse(new InputSource(new StringReader(xmlString)), new DefaultHandler() {
            @Override
            public void startElement(String uri, String localName, String qName, Attributes attributes)
                    throws SAXException {
                System.out.println("Start Element :" + qName + " " + localName + " " + uri);
            }

            @Override
            public void endElement(String uri, String localName, String qName) throws SAXException {
                System.out.println("End Element :" + qName + " " + localName + " " + uri);
            }

            @Override
            public void characters(char[] ch, int start, int length) throws SAXException {
                String content = new String(ch, start, length).trim();
                if (!content.isEmpty()) {
                    System.out.println("Content :" + content);
                }
            }
        });
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 4. 修改XML文档

import org.junit.jupiter.api.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.InputSource;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.StringReader;
import java.io.StringWriter;

@Test
public void modifyXMLDocument() {
    try {
        // XML文档字符串
        String xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books><book id=\"1\"><title>Java Programming</title></book></books>";

        // 创建文档工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();

        // 从XML字符串创建文档对象
        Document document = builder.parse(new InputSource(new StringReader(xmlString)));

        // 修改节点的值
        Element titleElement = (Element) document.getElementsByTagName("title").item(0);
        titleElement.setTextContent("Java Programming 2nd Edition");

        // 将修改后的文档转换为字符串
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        StringWriter writer = new StringWriter();
        transformer.transform(new DOMSource(document), new StreamResult(writer));
        String modifiedXmlString = writer.toString();

        // 断言修改后的XML字符串是否符合预期
        String expectedModifiedXmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books><book id=\"1\"><title>Java Programming 2nd Edition</title></book></books>";
        Assertions.assertEquals(modifiedXmlString, expectedModifiedXmlString);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 5. 删除XML节点

import org.junit.jupiter.api.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;


import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.StringReader;
import java.io.StringWriter;


@Test
public void deleteXMLNode() {
    try {
        // XML文档字符串
        String xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books><book id=\"1\"><title>Java Programming</title></book></books>";

        // 创建文档工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();

        // 从XML字符串创建文档对象
        Document document = builder.parse(new InputSource(new StringReader(xmlString)));

        // 获取要删除的节点
        Element bookElement = (Element) document.getElementsByTagName("book").item(0);

        // 删除节点
        Node parentNode = bookElement.getParentNode();
        parentNode.removeChild(bookElement);

        // 将修改后的文档转换为字符串
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        StringWriter writer = new StringWriter();
        transformer.transform(new DOMSource(document), new StreamResult(writer));
        String modifiedXmlString = writer.toString();

        // 断言删除节点后的XML字符串是否符合预期
        String expectedModifiedXmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books/>";
        Assertions.assertEquals(modifiedXmlString, expectedModifiedXmlString);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 6. 合并XML文档

import org.junit.jupiter.api.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.StringReader;
import java.io.StringWriter;

@Test
public void mergeXMLDocuments() {
    try {
        // XML文档字符串1
        String xmlString1 = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books><book id=\"1\"><title>Java Programming</title></book></books>";

        // XML文档字符串2
        String xmlString2 = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books><book id=\"2\"><title>Python Programming</title></book></books>";

        // 创建文档工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();

        // 从XML字符串创建文档对象1
        Document document1 = builder.parse(new InputSource(new StringReader(xmlString1)));

        // 从XML字符串创建文档对象2
        Document document2 = builder.parse(new InputSource(new StringReader(xmlString2)));

        // 获取根节点
        Element rootElement1 = document1.getDocumentElement();
        Element rootElement2 = document2.getDocumentElement();

        // 将文档2中的所有子节点添加到文档1的根节点下
        NodeList childNodes = rootElement2.getChildNodes();
        for (int i = 0; i < childNodes.getLength(); i++) {
            Node node = childNodes.item(i);
            Node importedNode = document1.importNode(node, true);
            rootElement1.appendChild(importedNode);
        }

        // 将合并后的文档转换为字符串
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        StringWriter writer = new StringWriter();
        transformer.transform(new DOMSource(document1), new StreamResult(writer));
        String mergedXmlString = writer.toString();

        // 断言合并后的XML字符串是否符合预期
        String expectedMergedXmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books><book id=\"1\"><title>Java Programming</title></book><book id=\"2\"><title>Python Programming</title></book></books>";
        Assertions.assertEquals(mergedXmlString, expectedMergedXmlString);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 7. 查询XML数据

import org.junit.jupiter.api.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.StringReader;


@Test
public void queryXMLData() {
    try {
        // XML文档字符串
        String xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><books><book id=\"1\"><title>Java Programming</title></book><book id=\"2\"><title>Python Programming</title></book></books>";

        // 创建文档工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();

        // 从XML字符串创建文档对象
        Document document = builder.parse(new InputSource(new StringReader(xmlString)));

        // 查询XML数据
        NodeList bookList = document.getElementsByTagName("book");
        for (int i = 0; i < bookList.getLength(); i++) {
            Node bookNode = bookList.item(i);
            if (bookNode.getNodeType() == Node.ELEMENT_NODE) {
                Element bookElement = (Element) bookNode;
                String bookId = bookElement.getAttribute("id");
                String title = bookElement.getElementsByTagName("title").item(0).getTextContent();
                Assertions.assertEquals(bookId, i == 0 ? "1" : "2");
                Assertions.assertEquals(title, i == 0 ? "Java Programming" : "Python Programming");
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# Java XML处理的工具和库

# 1. JAXP (Java API for XML Processing)

JAXP (Java API for XML Processing) 是 Java 平台上用于处理 XML 的官方 API。它提供了一组标准的接口和类，用于解析、创建、转换和验证 XML 文档。JAXP 支持多种 XML 处理方式，包括 DOM、SAX 和 StAX 解析。

示例代码中使用的 DocumentBuilder、TransformerFactory 和 SAXParserFactory 类就是 JAXP 的一部分。通过使用 JAXP，开发人员可以跨不同的 XML 处理实现进行编程，而不需要依赖于特定的 XML 处理库。

# 2. JAXB (Java Architecture for XML Binding)

JAXB (Java Architecture for XML Binding) (opens new window) 是 Java 平台上用于 XML 数据绑定的技术。它允许开发人员将 XML 文档和 Java 对象之间进行映射，从而方便地在 Java 应用程序中读取、创建和操作 XML 数据。

JAXB 提供了注解和 API，用于定义 Java 类和 XML 文档之间的映射关系。通过使用 JAXB，开发人员可以轻松地将 XML 数据转换为 Java 对象，并将 Java 对象转换回 XML 数据。

# 示例

下面是一个使用 JAXB 进行 XML 到 Java 对象和 Java 对象到 XML 的示例：

首先，定义一个 Java 类 Book，用于表示图书信息：

import jakarta.xml.bind.annotation.*;

@XmlRootElement(name = "book")
@XmlAccessorType(XmlAccessType.FIELD)
public class Book {

    @XmlAttribute
    private int id;

    @XmlElement
    private String title;

    // Getter and Setter methods
    // ...
}

然后，可以使用 JAXB 将 XML 转换为 Java 对象（XML 到 Java 对象）：

import jakarta.xml.bind.*;
import java.io.File;

public class XMLToBeanExample {

    public static void main(String[] args) {
        try {
            // 创建 JAXBContext 实例
            JAXBContext context = JAXBContext.newInstance(Book.class);

            // 创建 Unmarshaller 实例
            Unmarshaller unmarshaller = context.createUnmarshaller();

            // 从 XML 文件中读取 Book 对象
            File xmlFile = new File("book.xml");
            Book book = (Book) unmarshaller.unmarshal(xmlFile);

            // 输出 Java 对象内容
            System.out.println("Book ID: " + book.getId());
            System.out.println("Title: " + book.getTitle());
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

上述代码将从名为 "book.xml" 的 XML 文件中读取 Book 对象，并打印出其中的属性值。

接下来，可以使用 JAXB 将 Java 对象转换为 XML（Java 对象到 XML）：

import jakarta.xml.bind.*;
import java.io.File;

public class BeanToXMLExample {

    public static void main(String[] args) {
        try {
            // 创建 JAXBContext 实例
            JAXBContext context = JAXBContext.newInstance(Book.class);

            // 创建 Marshaller 实例
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

            // 创建 Book 对象
            Book book = new Book();
            book.setId(1);
            book.setTitle("Java Programming");

            // 将 Book 对象转换为 XML 文件
            File xmlFile = new File("book.xml");
            marshaller.marshal(book, xmlFile);

            System.out.println("XML file created successfully.");
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

上述代码将创建一个 Book 对象，并将其转换为 XML 格式后写入名为 "book.xml" 的文件中。

这是一个简单的使用 JAXB 进行 XML 和 Java 对象之间转换的示例。通过定义适当的注解或配置文件，可以更复杂地映射 XML 结构和 Java 类的关系，以满足更具体的需求。

# 3. JDOM

JDOM (opens new window) 是一个简单、直观的 Java API，用于处理 XML 数据。它提供了一种易于使用的方式来读取、创建和操作 XML 文档。

JDOM 的设计目标是提供一个更简洁和直观的 API，以便开发人员可以更轻松地处理 XML 数据。它使用类似于操作常规对象的方法来访问和操作 XML 元素、属性和文本内容，使得代码编写和阅读更加直观和易于理解。

JDOM注重简洁性和直观性，提供了易于使用的API，类似于操作常规对象的方式来访问和操作XML数据。

参考： Getting Started (opens new window)

# 4. DOM4J

DOM4J (opens new window) 是一个功能强大的开源 Java XML API，用于处理大型 XML 文档。它是基于标准的 W3C DOM 规范的扩展，提供了更高级别和更易于使用的 API。

DOM4J 提供了一种灵活且高效的方式来读取、创建和操作 XML 文档。它支持 XPath 查询、XML 内容修改、命名空间处理等功能。DOM4J 还具有优化的内存使用和高性能的特点，适合处理复杂的 XML 数据。

参考： Quick Start (opens new window)

# 5. XStream

XStream (opens new window) 是一个简单而强大的 Java 库，用于将对象转换为 XML 格式并进行反向操作。它通过使用注解或映射来定义对象与 XML 之间的转换规则。

XStream 允许开发人员使用简洁的代码将 Java 对象转换为 XML 字符串，并将 XML 字符串反序列化为 Java 对象。它不需要特殊的配置文件或代码生成过程，使得使用 XStream 非常方便和灵活。

参考： Tutorial (opens new window)

# 6. Jackson XML

在Java JSON处理 中提到了Jackson的XML处理模块，也可以用于处理XML数据。

Jackson XML (opens new window) 是 Jackson 库的一个模块，用于在 Java 对象和 XML 之间进行序列化和反序列化操作。它提供了一种简单且灵活的方式，将 Java 对象转换为 XML 格式，并将 XML 转换回 Java 对象。

# 结论

在本文中，我们介绍了 Java XML 处理的重要性以及其在实际应用中的广泛应用场景。XML 是一种用于存储和传输数据的常用格式，因此 Java 开发人员需要掌握处理 XML 的技术和工具。

我们介绍了 Java 中处理 XML 的基本概念，包括 DOM 解析、SAX 解析、StAX 解析、XPath、XSLT 和 XQuery。每种方法都有其自己的特点和适用场景，开发人员可以根据具体需求选择合适的方法。

我们还介绍了几种常用的 Java XML 处理工具和库，包括 JAXP、JAXB、JDOM、DOM4J 和 XStream等。这些工具和库提供了不同级别的抽象和功能，可以帮助开发人员更便捷地处理 XML 数据。

最后，我们强调了结合实际需求和场景来优化 Java XML 处理效果的重要性。在处理大型 XML 文档或对性能要求较高的场景下，选择适当的方法和工具，并进行代码优化和性能调优，可以提高处理效率和响应速度。

通过掌握 Java XML 处理的知识和技能，并选择合适的方法和工具，开发人员可以更加灵活和高效地处理 XML 数据，满足各种业务需求。

祝你变得更强!

编辑 (opens new window)
#XML
上次更新: 2023/06/14
Java JSON处理
Java对象池技术

← Java对象池技术→

最近更新
01
Spring表达式语言（SpELl）
02-11
02
Spring中的验证、数据绑定和类型转换
01-30
03
Spring中的资源访问：Resource接口
01-29
更多文章>
Theme by Vdoing | Copyright © 2018-2025 京ICP备2021021832号-2 | MIT License