如何用FasterXML Jackson映射混合列表子元素并解析指定XML片段？

当然可以用Jackson来映射XML里的混合列表子元素！针对你给出的XML片段，我来一步步讲解具体的实现方法：

核心思路 #

Jackson XML模块支持通过类型信息注解来区分不同的XML元素，把混合的<category>和<setting>子元素映射到对应的Java实体类，甚至能轻松处理嵌套的层级结构。

步骤1：准备依赖 #

首先确保你的项目里引入了Jackson XML相关的依赖（以Maven为例）：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.15.2</version> <!-- 替换为最新稳定版即可 -->
</dependency>

步骤2：定义实体类 #

我们需要定义几个类来对应XML的结构，关键是用@JsonTypeInfo和@JsonSubTypes来关联XML元素名和Java类：

1. 抽象父类（统一类型） #

定义一个抽象父类作为<category>和<setting>的共同类型，方便在列表中统一存储：

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;

@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.WRAPPER_ELEMENT // 用XML元素名作为类型标识
)
@JsonSubTypes({
    @JsonSubTypes.Type(value = Category.class, name = "category"), // <category>对应Category类
    @JsonSubTypes.Type(value = Setting.class, name = "setting")    // <setting>对应Setting类
})
public abstract class XmlNode {
    // 父类无需定义属性，仅作为类型标记
}

2. Setting类（对应<setting>元素） #

import com.fasterxml.jackson.annotation.JsonProperty;

public class Setting extends XmlNode {
    @JsonProperty("@type") // 映射XML的type属性（@前缀表示XML属性）
    private String type;
    
    private String name; // 直接映射<name>子元素

    // Getters & Setters
    public String getType() { return type; }
    public void setType(String type) { this.type = type; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

3. Category类（对应<category>元素，支持嵌套） #

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;

public class Category extends XmlNode {
    @JsonProperty("@name") // 映射XML的name属性
    private String name;
    
    @JsonInclude(JsonInclude.Include.NON_EMPTY) // 空列表不序列化（可选优化）
    private List<XmlNode> children; // 嵌套的子元素，同样可以是Category或Setting

    // Getters & Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public List<XmlNode> getChildren() { return children; }
    public void setChildren(List<XmlNode> children) { this.children = children; }
}

4. 根类Categories（对应<categories>根元素） #

import java.util.List;

public class Categories {
    private List<XmlNode> content; // 根元素下的所有混合子元素

    // Getter & Setter
    public List<XmlNode> getContent() { return content; }
    public void setContent(List<XmlNode> content) { this.content = content; }
}

步骤3：解析XML #

用XmlMapper来解析你的XML片段，代码示例：

import com.fasterxml.jackson.dataformat.xml.XmlMapper;

public class XmlParser {
    public static void main(String[] args) throws Exception {
        // 补全后的XML片段
        String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
                     "<categories>\n" +
                     "  <category name=\"A\">\n" +
                     "    <category name=\"B\">\n" +
                     "      <setting type=\"Float\">\n" +
                     "        <name>Bar</name>\n" +
                     "      </setting>\n" +
                     "    </category>\n" +
                     "    <setting type=\"Float\">\n" +
                     "      <name>Foo</name>\n" +
                     "    </setting>\n" +
                     "    <category name=\"C\">\n" +
                     "      <setting type=\"Float\">\n" +
                     "        <name>Baz</name>\n" +
                     "      </setting>\n" +
                     "    </category>\n" +
                     "</categories>";

        // 初始化XmlMapper
        XmlMapper mapper = XmlMapper.builder()
                .defaultUseWrapper(false) // 根元素直接包含子元素，不需要额外包装
                .build();

        // 解析XML到Java对象
        Categories categories = mapper.readValue(xml, Categories.class);

        // 遍历解析结果（验证用）
        for (XmlNode node : categories.getContent()) {
            if (node instanceof Category) {
                Category cat = (Category) node;
                System.out.println("找到分类: " + cat.getName());
                // 递归处理嵌套子元素
                if (cat.getChildren() != null) {
                    processNodes(cat.getChildren());
                }
            } else if (node instanceof Setting) {
                Setting setting = (Setting) node;
                System.out.println("找到设置: " + setting.getName() + " (类型: " + setting.getType() + ")");
            }
        }
    }

    // 递归处理嵌套节点的辅助方法
    private static void processNodes(List<XmlNode> nodes) {
        for (XmlNode node : nodes) {
            if (node instanceof Category) {
                Category cat = (Category) node;
                System.out.println("  子分类: " + cat.getName());
                if (cat.getChildren() != null) {
                    processNodes(cat.getChildren());
                }
            } else if (node instanceof Setting) {
                Setting setting = (Setting) node;
                System.out.println("  子设置: " + setting.getName() + " (类型: " + setting.getType() + ")");
            }
        }
    }
}

关键细节说明 #

• @JsonProperty("@xxx")：用来映射XML元素的属性（比如name="A"），@前缀是Jackson XML模块约定的属性标识。
• @JsonTypeInfo和@JsonSubTypes：告诉Jackson如何根据XML元素名来实例化对应的Java类，这是处理混合类型的核心。
• 嵌套支持：Category类里的children列表同样使用XmlNode类型，所以可以递归解析嵌套的<category>和<setting>。

运行上面的代码，就能正确解析出XML里的所有混合子元素啦！

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