【Java 进阶篇】Java XML解析：从入门到精通

不念不忘少年蓝@ 2024-02-21 12:01 13阅读 0赞

![在这里插入图片描述][ee6246a97e76456ea2a96231b3fde401.png]

XML（可扩展标记语言）是一种常用的数据格式，用于存储和交换数据。在Java中，XML解析是一项重要的任务，它允许您从XML文档中提取和操作数据。本篇博客将从基础开始，详细介绍如何在Java中解析XML文档，包括DOM解析、SAX解析和StAX解析。无论您是XML的新手还是有一些经验的开发者，都能在本文中找到有关Java XML解析的有用信息。

### 为什么需要XML解析？ ###

XML解析是将XML文档转换为应用程序可以理解和操作的数据的过程。它在许多应用程序中都具有关键作用，包括：

*  **数据交换**：XML通常用于不同系统之间的数据交换，解析XML可将接收的数据转化为应用程序可以使用的格式。
 *  **配置文件**：XML通常用于存储应用程序的配置信息，解析XML可读取配置并将其应用到应用程序中。
 *  **Web服务**：许多Web服务使用XML来传递数据，解析XML可用于访问和操作Web服务的响应数据。
 *  **日志文件**：某些应用程序将日志数据存储为XML，解析XML可用于分析和提取有关应用程序性能和行为的信息。

### XML基础 ###

在开始学习XML解析之前，让我们先了解XML的基础知识。

#### 1. XML文档结构 ####

XML文档由标签（element）、属性（attribute）、文本内容和注释组成。一个简单的XML文档包括以下部分：

*  `<person>` 是一个元素，带有一个名为 `age` 的属性和子元素 `name` 和 `address`。
 *  `<name>` 和 `<address>` 也是元素，分别包含文本内容。
 *  `age` 是 `<person>` 元素的属性。

#### 2. XML解析模型 ####

Java中有几种用于XML解析的模型，主要包括DOM、SAX和StAX。

*  **DOM（文档对象模型）**：DOM解析将整个XML文档加载到内存中，形成一个树状结构，允许您轻松地遍历和操作XML数据。DOM解析适用于小型XML文档，但可能在处理大型文档时占用大量内存。
 *  **SAX（简单API for XML）**：SAX解析是事件驱动的，逐行读取XML文档，触发事件来处理元素和数据。SAX解析适用于大型XML文档，因为它不需要将整个文档加载到内存中。
 *  **StAX（流API for XML）**：StAX解析是一种双向解析模型，允许您以类似流的方式读取和写入XML数据。它是一种高性能的解析模型，适用于大型文档。

### 使用DOM解析XML ###

DOM解析是一种将整个XML文档加载到内存中并构建树状结构的解析方式。它允许您轻松地遍历和操作XML数据。

#### 示例：解析XML文档 ####

让我们通过一个示例来演示如何使用DOM解析XML文档。我们将解析以下XML文档：

<employees>
        <employee>
            <name>John</name>
            <position>Manager</position>
        </employee>
        <employee>
            <name>Alice</name>
            <position>Engineer</position>
        </employee>
    </employees>

import javax.xml.parsers.*;
    import org.w3c.dom.*;
    import java.io.*;
    
    public class DOMParserExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个DocumentBuilder
                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                DocumentBuilder builder = factory.newDocumentBuilder();
    
                // 解析XML文件
                Document document = builder.parse(new File("employees.xml"));
    
                // 获取根元素
                Element root = document.getDocumentElement();
    
                // 获取所有employee元素
                NodeList employeeList = root.getElementsByTagName("employee");
    
                for (int i = 0; i < employeeList.getLength(); i++) {
        
                    Element employee = (Element) employeeList.item(i);
    
                    // 获取name元素的文本内容
                    String name = employee.getElementsByTagName("name").item(0).getTextContent();
    
                    // 获取position元素的文本内容
                    String position = employee.getElementsByTagName("position").item(0).getTextContent();
    
                    System.out.println("Employee Name: " + name);
                    System.out.println("Position: " + position);
                    System.out.println("---------------");
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

在上述示例中，我们使用`DocumentBuilderFactory`创建一个`DocumentBuilder`，然后使用`builder.parse()`方法解析XML文件。接下来，我们获取根元素`employees`，并遍历所有`employee`元素，提取`name`和`position`元素的文本内容。

#### 示例：创建XML文档 ####

DOM解析还允许您创建XML文档。以下是一个示例，演示如何使用DOM创建XML文档：

import javax.xml.parsers.*;
    import org.w3c.dom.*;
    import java.io.*;
    
    public class DOMCreateExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个DocumentBuilder
                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                DocumentBuilder builder = factory.newDocumentBuilder();
    
                // 创建一个新文档
                Document document = builder.newDocument();
    
                // 创建根元素
                Element employees = document.createElement("employees");
                document.appendChild(employees);
    
                // 创建第一个employee元素
                Element employee1 = document.createElement("employee");
                employees.appendChild(employee1);
    
                Element name1 = document.createElement("name");
                name1.appendChild(document.createTextNode("John"));
                employee1.appendChild(name1);
    
                Element position1 = document.createElement("position");
                position1.appendChild(document.createTextNode("Manager"));
                employee1.appendChild(position1);
    
                // 创建第二个employee元素
                Element employee2 = document.createElement("employee");
                employees.appendChild(employee2);
    
                Element name2 = document.createElement("name");
                name2.appendChild(document.createTextNode("Alice"));
                employee2.appendChild(name2);
    
                Element position2 = document.createElement("position");
                position2.appendChild(document.createTextNode("Engineer"));
                employee2.appendChild(position2);
    
                // 将文档写入文件
                TransformerFactory transformerFactory = TransformerFactory.newInstance();
                Transformer transformer = transformerFactory.newTransformer();
                DOMSource source = new DOMSource(document);
                StreamResult result = new StreamResult(new File("new_employees.xml"));
                transformer.transform(source, result);
    
                System.out.println("XML文档创建成功！");
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

在上述示例中，我们创建了一个新的`Document`对象，并使用`createElement`方法创建元素。然后，我们将元素添加到文档中，最后使用`Transformer`将文档写入文件。这将创建一个新的XML文档。

### 使用SAX解析XML ###

SAX解析是一种基于事件的解析模型，逐行读取XML文档并触发事件来处理元素和数据。相比DOM，SAX解析不需要将整个文档加载到内存中，因此适用于大型XML文档。

#### 示例：解析XML文档 ####

让我们通过一个示例来演示如何使用SAX解析XML文档：

import org.xml.sax.*;
    import org.xml.sax.helpers.DefaultHandler;
    import java.io.*;
    
    public class SAXParserExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个SAXParser
                SAXParserFactory factory = SAXParserFactory.newInstance();
                SAXParser parser = factory.newSAXParser();
    
                // 创建一个处理器
                DefaultHandler handler = new DefaultHandler() {
        
                    private boolean inEmployee = false;
                    private String name = null;
                    private String position = null;
    
                    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        
                        if (qName.equalsIgnoreCase("employee")) {
        
                            inEmployee = true;
                        }
                    }
    
                    public void endElement(String uri, String localName, String qName) throws SAXException {
        
                        if (qName.equalsIgnoreCase("employee")) {
        
                            inEmployee = false;
                            System.out.println("Employee Name: " + name);
                            System.out.println("Position: " + position);
                            System.out.println("---------------");
                        }
                    }
    
                    public void characters(char[] ch, int start, int length) throws SAXException {
        
                        if (inEmployee) {
        
                            String data = new String(ch, start, length);
                            if (name == null) {
        
                                name = data;
                            } else {
        
                                position = data;
                            }
                        }
                    }
                };
    
                // 解析XML文件
                parser.parse(new File("employees.xml"), handler);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

在上述示例中，我们创建了一个`SAXParser`和一个事件处理器`DefaultHandler`。事件处理器在遇到元素的开始和结束以及字符数据时触发事件。我们实现了`startElement`、`endElement`和`characters`方法，以处理相应的事件。

#### 示例：使用SAX解析器工厂 ####

SAX解析也可以使用解析器工厂来创建解析器。以下是一个示例：

import org.xml.sax.*;
    import org.xml.sax.helpers.DefaultHandler;
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    import java.io.*;
    
    public class SAXParserFactoryExample {
        
        public static void main(String[] args) {
        
            try {
        
                SAXParserFactory factory = SAXParserFactory.newInstance();
                SAXParser parser = factory.newSAXParser();
    
                DefaultHandler handler = new DefaultHandler() {
        
                    // 与前面的示例相同
                };
    
                parser.parse(new File("employees.xml"), handler);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

这个示例与之前的示例相似，但它使用了解析器工厂来创建SAX解析器。

### 使用StAX解析XML ###

StAX解析是一种基于流的解析模型，允许您以类似流的方式逐行读取和写入XML数据。StAX解析是一种高性能的解析模型，适用于大型XML文档。

#### 示例：解析XML文档 ####

让我们通过一个示例来演示如何使用StAX解析XML文档：

import javax.xml.stream.*;
    import java.io.*;
    
    public class StAXParserExample {
        
        public static void main(String[] args) {
        
            try {
        
                XMLInputFactory factory = XMLInputFactory.newInstance();
                XMLStreamReader reader = factory.createXMLStreamReader(new FileInputStream("employees.xml"));
    
                String currentElement = "";
                String name = "";
                String position = "";
    
                while (reader.hasNext()) {
        
                    int event = reader.next();
    
                    switch (event) {
        
                        case XMLStreamConstants.START_ELEMENT:
                            currentElement = reader.getLocalName();
                            break;
    
                        case XMLStreamConstants.CHARACTERS:
                            String data = reader.getText();
                            if ("name".equals(currentElement)) {
        
                                name = data;
                            } else if ("position".equals(currentElement)) {
        
                                position = data;
                            }
                            break;
    
                        case XMLStreamConstants.END_ELEMENT:
                            if ("employee".equals(reader.getLocalName())) {
        
                                System.out.println("Employee Name: " + name);
                                System.out.println("Position: " + position);
                                System.out.println("---------------");
                            }
                            break;
                    }
                }
    
                reader.close();
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

在上述示例中，我们使用`XMLInputFactory`创建一个`XMLStreamReader`，然后使用`while`循环逐行读取XML文档中的数据。我们跟踪当前元素的名称，并根据当前元素的内容提取`name`和`position`的值。最后，我们在遇到`</employee>`元素时打印员工信息。

#### 示例：使用StAX写入XML ####

StAX不仅可以用于解析XML，还可以用于创建XML文档。以下是一个示例，演示如何使用StAX创建XML文档：

import javax.xml.stream.*;
    import java.io.*;
    
    public class StAXCreateExample {
        
        public static void main(String[] args) {
        
            try {
        
                XMLOutputFactory factory = XMLOutputFactory.newInstance();
                XMLStreamWriter writer = factory.createXMLStreamWriter(new FileWriter("new_employees.xml"));
    
                writer.writeStartDocument();
                writer.writeStartElement("employees");
    
                // 创建第一个employee元素
                writer.writeStartElement("employee");
                writer.writeStartElement("name");
                writer.writeCharacters("John");
                writer.writeEndElement();
                writer.writeStartElement("position");
                writer.writeCharacters("Manager");
                writer.writeEndElement();
                writer.writeEndElement();
    
                // 创建第二个employee元素
                writer.writeStartElement("employee");
                writer.writeStartElement("name");
                writer.writeCharacters("Alice");
                writer.writeEndElement();
                writer.writeStartElement("position");
                writer.writeCharacters("Engineer");
                writer.writeEndElement();
                writer.writeEndElement();
    
                writer.writeEndElement();
                writer.writeEndDocument();
    
                writer.close();
    
                System.out.println("XML文档创建成功！");
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

在上述示例中，我们使用`XMLOutputFactory`创建一个`XMLStreamWriter`，然后使用`write`方法逐步创建XML文档。我们首先写入文档声明，然后创建根元素`employees`，并添加两个`employee`元素，每个元素都包含`name`和`position`元素。

### 选择合适的解析方法 ###

在选择XML解析方法时，需要考虑以下因素：

*  **内存消耗**：DOM解析通常需要将整个文档加载到内存中，可能导致内存消耗过大。SAX和StAX解析逐行读取文档，内存消耗较低。
 *  **性能**：SAX和StAX解析通常比DOM解析更快，尤其是在处理大型文档时。
 *  **复杂性**：DOM解析通常更容易编写，因为它允许您轻松地遍历和操作文档。SAX和StAX解析更复杂，因为您需要编写事件处理器来处理元素和数据。
 *  **灵活性**：如果您需要读取和写入XML，StAX解析是一种更灵活的选择，因为它支持双向操作。

根据您的具体需求，选择合适的解析方法非常重要。如果您需要处理小型文档并且希望方便地操作数据，DOM解析可能是不错的选择。如果您需要处理大型文档或需要更高的性能，SAX或StAX解析可能更适合。

### XML解析库 ###

Java提供了许多XML解析库，用于简化XML解析的过程。一些常见的XML解析库包括：

*  **JDOM**：JDOM是一种用于解析和操作XML的流行库，提供了简单的API。
 *  **DOM4J**：DOM4J是一个基于DOM的XML解析库，具有强大的功能和性能。
 *  **Jsoup**：Jsoup是一种用于解析HTML和XML的库，通常用于Web抓取和数据提取。
 *  **Jackson**：Jackson是一个处理JSON的库，但也可以用于处理XML。

这些库提供了不同的功能和性能特点，您可以根据自己的需求选择最合适的库。

### 使用XML Schema验证 ###

除了解析XML，还可以使用XML Schema（XSD）来验证XML文档的有效性。XML Schema定义了XML文档的结构和数据类型，可以确保文档符合规定的结构。

以下是一个使用XSD验证XML的示例：

import javax.xml.XMLConstants;
    import javax.xml.transform.Source;
    import javax.xml.transform.stream.StreamSource;
    import javax.xml.validation.Schema;
    import javax.xml.validation.SchemaFactory;
    import javax.xml.validation.Validator;
    import org.xml.sax.SAXException;
    import java.io.File;
    import java.io.IOException;
    
    public class XsdValidatorExample {
        
        public static void main(String[] args) {
        
            try {
        
                String xmlFile = "employees.xml";
                String xsdFile = "employees.xsd";
    
                SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
                Schema schema = factory.newSchema(new File(xsdFile));
                Validator validator = schema.newValidator();
    
                Source source = new StreamSource(new File(xmlFile));
                validator.validate(source);
    
                System.out.println("XML验证通过！");
            } catch (SAXException | IOException e) {
        
                System.out.println("XML验证错误: " + e.getMessage());
            }
        }
    }

在上述示例中，我们使用`SchemaFactory`创建一个`Schema`对象，该对象包含了我们之前定义的XSD约束。然后，我们使用`Validator`来验证XML文档。如果XML文档不符合XSD的约束，将抛出相应的错误。

### 实际应用示例 ###

让我们来看一个实际的应用示例：使用XML解析来处理Web服务的响应。假设您正在开发一个应用程序，通过调用Web服务来获取数据。 Web服务通常以XML形式返回数据，您可以使用XML解析来提取和处理Web服务的响应。

import java.io.StringReader;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    public class WebServiceExample {
        
        public static void main(String[] args) {
        
            // 假设这是Web服务的响应XML
            String responseXml = "<data><item>Item 1</item><item>Item 2</item></data>";
    
            try {
        
                // 创建一个DocumentBuilder
                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                DocumentBuilder builder = factory.newDocumentBuilder();
    
                // 解析Web服务的响应XML
                Document document = builder.parse(new InputSource(new StringReader(responseXml)));
    
                // 获取根元素
                Node root = document.getDocumentElement();
    
                // 获取所有item元素
                NodeList itemList = root.getChildNodes();
    
                for (int i = 0; i < itemList.getLength(); i++) {
        
                    Node itemNode = itemList.item(i);
    
                    if (itemNode.getNodeType() == Node.ELEMENT_NODE) {
        
                        String item = itemNode.getTextContent();
                        System.out.println("Item: " + item);
                    }
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

在这个示例中，我们模拟了Web服务的响应XML，并使用DOM解析来提取`item`元素的文本内容。这可以在实际应用程序中用于处理Web服务的响应数据，提取所需的信息。

### 总结 ###

本博客详细介绍了Java中的XML解析，包括DOM、SAX和StAX三种解析模型。您可以根据项目的需求选择最合适的解析方式。此外，我们还了解了如何使用XML Schema验证XML文档的有效性，以及一些常见的XML解析库。

XML解析是Java开发中常见的任务，它允许您与其他系统交换数据，读取和写入配置文件，访问Web服务的响应数据等。熟练掌握XML解析是Java开发中的一项重要技能。

希望本博客对您有所帮助，如果您有任何问题或需要进一步的指导，请随时提问。祝您在Java XML解析的学习和应用中取得成功！

<table> 
 <tbody> 
  <tr> 
   <td> <strong><font>作者信息</font></strong><br> <br> <font> 作者 ： 繁依Fanyi</font><br> <font>CSDN：</font> <a href="https://blog.csdn.net/qq_21484461?spm=1000.2115.3001.5343" rel="nofollow"><font>https://techfanyi.blog.csdn.net</font></a><br> <font>掘金：</font><a href="https://juejin.cn/user/4154386571867191" rel="nofollow"><font>https://juejin.cn/user/4154386571867191</font></a> </td> 
  </tr> 
 </tbody> 
</table>

[ee6246a97e76456ea2a96231b3fde401.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/046e27f6b6704ced8ff9e25d30a80f76.png