如何在Java中读取指定结构的XML配置文件

Alright, let's break down how to read this specific XML configuration structure in Java. First, let's make sure we have the complete XML (since your snippet was cut off, I'll fill in a reasonable exception section for context):

<?xml version="1.0" encoding="UTF-8"?>
<properties>
    <config>
        <seperator>
            <entry key="fileSeprator">|</entry>
        </seperator>
        <columncount>
            <entry key="colcount">4</entry>
        </columncount>
        <columnName>
            <entry key="0">ClientID</entry>
            <entry key="1">ID</entry>
            <entry key="2">FirstName</entry>
            <entry key="3">LastName</entry>
        </columnName>
        <exception>
            <entry key="0">FileNotFoundException</entry>
            <entry key="1">InvalidColumnCountException</entry>
        </exception>
    </config>
</properties>

I'll cover two common approaches: using Java's built-in DOM parser (no extra dependencies) and using Jackson XML (cleaner, object-mapped code).

1. Java Native DOM Parser (No External Libraries) #

DOM parsing loads the entire XML into memory as a tree structure, which is great for small-to-medium config files. Here's how to implement it:

import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

public class XmlConfigReader {
    public static void main(String[] args) {
        try {
            // Load the XML file
            File configFile = new File("config.xml");
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.parse(configFile);
            doc.getDocumentElement().normalize(); // Clean up whitespace issues

            // Read file separator
            Node separatorNode = doc.getElementsByTagName("seperator").item(0);
            Element separatorElem = (Element) separatorNode;
            String fileSeparator = separatorElem.getElementsByTagName("entry").item(0).getTextContent();
            System.out.println("File Separator: " + fileSeparator);

            // Read column count (parse to int)
            Node columnCountNode = doc.getElementsByTagName("columncount").item(0);
            Element columnCountElem = (Element) columnCountNode;
            int columnCount = Integer.parseInt(columnCountElem.getElementsByTagName("entry").item(0).getTextContent());
            System.out.println("Total Columns: " + columnCount);

            // Read all column names (loop through entries)
            System.out.println("\nColumn Names:");
            Node columnNameParent = doc.getElementsByTagName("columnName").item(0);
            NodeList columnEntries = ((Element) columnNameParent).getElementsByTagName("entry");
            for (int i = 0; i < columnEntries.getLength(); i++) {
                Element entry = (Element) columnEntries.item(i);
                String key = entry.getAttribute("key");
                String columnName = entry.getTextContent();
                System.out.printf("Index %s: %s%n", key, columnName);
            }

            // Read exception configurations
            System.out.println("\nException Types:");
            Node exceptionParent = doc.getElementsByTagName("exception").item(0);
            NodeList exceptionEntries = ((Element) exceptionParent).getElementsByTagName("entry");
            for (int i = 0; i < exceptionEntries.getLength(); i++) {
                Element entry = (Element) exceptionEntries.item(i);
                String key = entry.getAttribute("key");
                String exceptionType = entry.getTextContent();
                System.out.printf("Code %s: %s%n", key, exceptionType);
            }

        } catch (Exception e) {
            // Handle common errors: file not found, invalid XML, etc.
            e.printStackTrace();
        }
    }
}

Notes on DOM Parsing: #

• It's straightforward but can get verbose for complex XML structures.
• Always call normalize() to fix inconsistent whitespace in the XML.
• Cast nodes to Element when you need to access attributes or child nodes.

2. Jackson XML (Object-Mapped Approach) #

If you want to avoid writing all that manual DOM traversal code, Jackson's XML module lets you map XML directly to Java objects. This is cleaner and easier to maintain for fixed XML structures.

Step 1: Add Dependency (Maven Example) #

First, add the Jackson XML dependency to your pom.xml:

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.15.2</version> <!-- Use the latest stable version -->
</dependency>

Step 2: Create Java Classes to Map the XML #

We'll create nested classes that mirror the XML structure:

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import java.util.List;

@JacksonXmlRootElement(localName = "properties")
public class AppConfig {
    private Config config;

    // Getters and Setters
    public Config getConfig() { return config; }
    public void setConfig(Config config) { this.config = config; }

    public static class Config {
        private Separator seperator;
        private ColumnCount columncount;
        private List<Entry> columnName;
        private List<Entry> exception;

        // Getters and Setters
        public Separator getSeperator() { return seperator; }
        public void setSeperator(Separator seperator) { this.seperator = seperator; }
        public ColumnCount getColumncount() { return columncount; }
        public void setColumncount(ColumnCount columncount) { this.columncount = columncount; }
        public List<Entry> getColumnName() { return columnName; }
        public void setColumnName(List<Entry> columnName) { this.columnName = columnName; }
        public List<Entry> getException() { return exception; }
        public void setException(List<Entry> exception) { this.exception = exception; }
    }

    public static class Separator {
        @JacksonXmlProperty(localName = "entry")
        private Entry entry;

        // Getter and Setter
        public Entry getEntry() { return entry; }
        public void setEntry(Entry entry) { this.entry = entry; }
    }

    public static class ColumnCount {
        @JacksonXmlProperty(localName = "entry")
        private Entry entry;

        // Getter and Setter
        public Entry getEntry() { return entry; }
        public void setEntry(Entry entry) { this.entry = entry; }
    }

    public static class Entry {
        @JacksonXmlProperty(isAttribute = true)
        private String key;

        @JacksonXmlProperty(isAttribute = false)
        private String value;

        // Getters and Setters
        public String getKey() { return key; }
        public void setKey(String key) { this.key = key; }
        public String getValue() { return value; }
        public void setValue(String value) { this.value = value; }
    }
}

Step 3: Read the XML with Jackson #

Now we can parse the XML into our Java objects in just a few lines:

import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import java.io.File;

public class JacksonConfigReader {
    public static void main(String[] args) {
        try {
            XmlMapper xmlMapper = new XmlMapper();
            AppConfig config = xmlMapper.readValue(new File("config.xml"), AppConfig.class);

            // Access file separator
            String fileSeparator = config.getConfig().getSeperator().getEntry().getValue();
            System.out.println("File Separator: " + fileSeparator);

            // Access column count
            int columnCount = Integer.parseInt(config.getConfig().getColumncount().getEntry().getValue());
            System.out.println("Total Columns: " + columnCount);

            // Iterate over column names
            System.out.println("\nColumn Names:");
            for (AppConfig.Entry entry : config.getConfig().getColumnName()) {
                System.out.printf("Index %s: %s%n", entry.getKey(), entry.getValue());
            }

            // Iterate over exceptions
            System.out.println("\nException Types:");
            for (AppConfig.Entry entry : config.getConfig().getException()) {
                System.out.printf("Code %s: %s%n", entry.getKey(), entry.getValue());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Notes on Jackson XML: #

• The @JacksonXmlRootElement annotation maps the root XML tag to our top-level class.
• @JacksonXmlProperty(isAttribute = true) tells Jackson that the key field maps to an XML attribute, not a child tag.
• This approach is far more scalable for larger XML files or when you need to reuse the config objects elsewhere in your code.

General Tips #

• If your config file is in the classpath (e.g., inside src/main/resources), use ClassLoader.getResourceAsStream("config.xml") instead of a File object to avoid path issues.
• Always handle exceptions properly—don't just print the stack trace in production code!
• Validate your XML against a schema if you need to ensure it adheres to the expected structure.

内容的提问来源于stack exchange，提问作者user9370262