Java 中读取 XML 文件

简介

在 Java 开发中，处理 XML 文件是一项常见的任务。XML（可扩展标记语言）以结构化的方式存储数据，广泛应用于数据交换、配置文件等场景。本文将详细介绍在 Java 中读取 XML 文件的相关知识，包括基础概念、使用方法、常见实践以及最佳实践，帮助读者全面掌握这一技术。

目录

1. 基础概念
   • XML 结构简介
   • Java 中处理 XML 的常用 API
2. 使用方法
   • 使用 DOM 解析 XML 文件
   • 使用 SAX 解析 XML 文件
   • 使用 JAXB 解析 XML 文件
3. 常见实践
   • 从文件系统读取 XML
   • 从网络读取 XML
4. 最佳实践
   • 性能优化
   • 错误处理
5. 小结
6. 参考资料

基础概念

XML 结构简介

XML 文件由元素、属性、文本节点等组成。一个简单的 XML 文件示例如下：

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
    <book category="fiction">
        <title lang="en">Harry Potter</title>
        <author>J.K. Rowling</author>
        <price>29.99</price>
    </book>
</bookstore>

在这个例子中，bookstore 是根元素，book 是子元素，category 是 book 元素的属性，title、author 和 price 是 book 元素的子元素，lang 是 title 元素的属性。

Java 中处理 XML 的常用 API

• DOM（Document Object Model）：将整个 XML 文档加载到内存中，形成一个树形结构，允许对文档进行随机访问和修改。
• SAX（Simple API for XML）：基于事件驱动的解析模型，逐行读取 XML 文件，适合处理大型 XML 文件，因为它不需要将整个文档加载到内存中。
• JAXB（Java Architecture for XML Binding）：用于将 Java 对象与 XML 文档进行绑定，实现对象与 XML 之间的自动转换。

使用方法

使用 DOM 解析 XML 文件

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

public class DOMExample {
    public static void main(String[] args) {
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.parse("books.xml");
            doc.getDocumentElement().normalize();

            System.out.println("Root element: " + doc.getDocumentElement().getNodeName());
            NodeList nodeList = doc.getElementsByTagName("book");

            for (int i = 0; i < nodeList.getLength(); i++) {
                Element element = (Element) nodeList.item(i);
                System.out.println("Book category: " + element.getAttribute("category"));

                NodeList titleList = element.getElementsByTagName("title");
                Element titleElement = (Element) titleList.item(0);
                System.out.println("Title: " + titleElement.getTextContent());

                NodeList authorList = element.getElementsByTagName("author");
                Element authorElement = (Element) authorList.item(0);
                System.out.println("Author: " + authorElement.getTextContent());

                NodeList priceList = element.getElementsByTagName("price");
                Element priceElement = (Element) priceList.item(0);
                System.out.println("Price: " + priceElement.getTextContent());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

使用 SAX 解析 XML 文件

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.IOException;

public class SAXExample {
    public static void main(String[] args) {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        try {
            SAXParser parser = factory.newSAXParser();
            DefaultHandler handler = new DefaultHandler() {
                boolean bTitle = false;
                boolean bAuthor = false;
                boolean bPrice = false;

                @Override
                public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
                    if (qName.equalsIgnoreCase("book")) {
                        System.out.println("Book category: " + attributes.getValue("category"));
                    } else if (qName.equalsIgnoreCase("title")) {
                        bTitle = true;
                    } else if (qName.equalsIgnoreCase("author")) {
                        bAuthor = true;
                    } else if (qName.equalsIgnoreCase("price")) {
                        bPrice = true;
                    }
                }

                @Override
                public void characters(char[] ch, int start, int length) throws SAXException {
                    if (bTitle) {
                        System.out.println("Title: " + new String(ch, start, length));
                        bTitle = false;
                    } else if (bAuthor) {
                        System.out.println("Author: " + new String(ch, start, length));
                        bAuthor = false;
                    } else if (bPrice) {
                        System.out.println("Price: " + new String(ch, start, length));
                        bPrice = false;
                    }
                }
            };
            parser.parse("books.xml", handler);
        } catch (ParserConfigurationException | SAXException | IOException e) {
            e.printStackTrace();
        }
    }
}

使用 JAXB 解析 XML 文件

首先定义 Java 类与 XML 结构对应：

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "book")
public class Book {
    private String category;
    private String title;
    private String author;
    private String price;

    @XmlAttribute(name = "category")
    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }

    @XmlElement(name = "title")
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @XmlElement(name = "author")
    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @XmlElement(name = "price")
    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }
}

然后进行解析：

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import java.io.File;

public class JAXBExample {
    public static void main(String[] args) {
        try {
            File file = new File("books.xml");
            JAXBContext jaxbContext = JAXBContext.newInstance(Book.class);
            Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
            Book book = (Book) jaxbUnmarshaller.unmarshal(file);
            System.out.println("Book category: " + book.getCategory());
            System.out.println("Title: " + book.getTitle());
            System.out.println("Author: " + book.getAuthor());
            System.out.println("Price: " + book.getPrice());
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

常见实践

从文件系统读取 XML

上述代码示例均展示了从文件系统读取 XML 文件的方法。通过 File 类或相关解析器的 parse 方法指定文件路径即可读取。

从网络读取 XML

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;

public class NetworkXMLReader {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://example.com/books.xml");
            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

读取到 XML 内容后，可使用上述解析方法进行进一步处理。

最佳实践

性能优化

• 对于大型 XML 文件，优先使用 SAX 解析：因为 SAX 基于事件驱动，不会将整个文档加载到内存中，可减少内存消耗。
• 使用缓冲流：在读取 XML 文件时，使用缓冲流可以提高读取效率。

错误处理

• 捕获异常：在解析 XML 文件时，要捕获可能出现的异常，如 ParserConfigurationException、SAXException、JAXBException 等，并进行适当处理。
• 验证 XML 格式：在解析前可使用 XML 模式（XSD）验证 XML 文件的格式是否正确，以避免解析过程中出现错误。

小结

本文详细介绍了在 Java 中读取 XML 文件的基础概念、多种使用方法、常见实践以及最佳实践。通过 DOM、SAX 和 JAXB 等不同的 API，开发者可以根据具体需求选择合适的方式来处理 XML 文件。在实际应用中，要注意性能优化和错误处理，以确保程序的高效稳定运行。

参考资料

• Java XML Tutorial
• DOM API Documentation
• SAX API Documentation
• JAXB API Documentation