如何避免JAXB编组List<String>时生成额外<name>包装节点

核心问题在于默认@XmlElement会将Object类型的List值包装在一个父<name>节点中，要实现多个<name>直接作为employee的子节点，需要通过@XmlAnyElement配合自定义XmlAdapter来直接生成目标元素，而非依赖JAXB的自动包装逻辑。

步骤1：修改Employee类的注解 #

将原@XmlElement替换为@XmlAnyElement，让JAXB直接处理Adapter生成的XML元素，而非自动包装：

import jakarta.xml.bind.annotation.XmlRootElement;
import jakarta.xml.bind.annotation.XmlAnyElement;
import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import java.util.List;

@XmlRootElement(name = "employee")
public class Employee {
    private Object name;

    @XmlAnyElement
    @XmlJavaTypeAdapter(NameAdapter.class)
    public Object getName() {
        return name;
    }

    public void setName(Object name) {
        this.name = name;
    }
}

步骤2：重写XmlAdapter生成目标元素 #

自定义Adapter直接创建单个或多个<name>元素，避免嵌套：

import jakarta.xml.bind.annotation.adapters.XmlAdapter;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import jakarta.xml.bind.DatatypeConverter;
import java.util.List;

public class NameAdapter extends XmlAdapter<Object, Object> {
    private Document document;

    private Document getDocument() {
        if (document == null) {
            try {
                document = DatatypeConverter.parseDocument("<temp/>");
            } catch (Exception e) {
                throw new RuntimeException("Failed to create DOM document", e);
            }
        }
        return document;
    }

    @Override
    public Object unmarshal(Object v) throws Exception {
        // 反序列化逻辑：单个Element返回String，多个Element返回List<String>
        if (v instanceof Element element) {
            return element.getTextContent();
        }
        // 扩展处理多个name元素的场景（比如NodeList转List<String>）
        return null;
    }

    @Override
    public Object marshal(Object v) throws Exception {
        if (v instanceof String str) {
            Element nameElement = getDocument().createElement("name");
            nameElement.setTextContent(str);
            return nameElement;
        } else if (v instanceof List<?> list) {
            Element[] nameElements = new Element[list.size()];
            for (int i = 0; i < list.size(); i++) {
                Object item = list.get(i);
                if (item instanceof String str) {
                    Element elem = getDocument().createElement("name");
                    elem.setTextContent(str);
                    nameElements[i] = elem;
                }
            }
            return nameElements;
        }
        return null;
    }
}

步骤3：测试验证 #

编写测试代码验证两种场景的输出：

import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.Marshaller;
import java.util.List;

public class MarshalTest {
    public static void main(String[] args) throws Exception {
        JAXBContext context = JAXBContext.newInstance(Employee.class);
        Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

        // 单个name场景
        Employee singleNameEmp = new Employee();
        singleNameEmp.setName("Alice");
        marshaller.marshal(singleNameEmp, System.out);

        // 多个name场景
        Employee multiNameEmp = new Employee();
        multiNameEmp.setName(List.of("Bob", "Charlie"));
        marshaller.marshal(multiNameEmp, System.out);
    }
}

输出效果 #

• 单个name时：

<employee>
    <name>Alice</name>
</employee>

• 多个name时：

<employee>
    <name>Bob</name>
    <name>Charlie</name>
</employee>

关键逻辑说明 #

• @XmlAnyElement：告诉JAXB该字段的内容是任意XML元素，不会自动添加外层包装节点
• 自定义Adapter直接生成<name>元素（单个或数组），JAXB会将这些元素直接作为employee的子节点，避免嵌套问题

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