Java 使用Jackson反序列化具有重复嵌套标记的xml

我试图反序列化一些具有相同名称的嵌套属性的xml，但每个属性的包装器名称都是唯一的。下面是XML示例

我尝试过切换包装器和属性名，但似乎不起作用

<response>
    <string>
        <item>Sample string.</item>
        <item>Another sample string.</item>
    </string>
    <number>
        <item>123123123</item>
        <item>900912</item>
    </number>
</response>

示例字符串。
另一个示例字符串。
123123123
900912

---

我正在尝试将上述XML反序列化为

列表

和

列表

变量。

我成功地创建了一对或多个ArrayList包装器作为内部类：

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;

@JacksonXmlRootElement(localName="response")
public class ResponseObjectList implements Serializable {

    @JacksonXmlProperty(localName = "string")
    private StringArrayListContainer string;

    @JacksonXmlProperty(localName = "number")
    private IntegerArrayListContainer number;

    public ResponseObjectList() {
        super();
    }

    public ResponseObjectList(List<String> stringItems, List<Integer> intItems) {
        super();
        this.string = new StringArrayListContainer(stringItems);
        this.number = new IntegerArrayListContainer(intItems);
    }

    public StringArrayListContainer getString() {
        return string;
    }

    public void setString(StringArrayListContainer string) {
        this.string = string;
    }

    public IntegerArrayListContainer getNumber() {
        return number;
    }

    public void setNumber(IntegerArrayListContainer number) {
        this.number = number;
    }

    public static class StringArrayListContainer extends ArrayListContainer<String>{

        public StringArrayListContainer() {
            super();
        }

        public StringArrayListContainer(List<String> item) {
            super(item);
        }

    }

    public static class IntegerArrayListContainer extends ArrayListContainer<Integer>{

        public IntegerArrayListContainer() {
            super();
        }

        public IntegerArrayListContainer(List<Integer> item) {
            super(item);
        }

    }

    public static class ArrayListContainer<T extends Serializable>{ 

        @JacksonXmlElementWrapper(useWrapping=false)
        @JacksonXmlProperty(localName="item")
        private List<T> item;

        public ArrayListContainer(List<T> item) {
            super();
            this.item = item;
        }

        public ArrayListContainer() {
            super();
        }

        public List<T> getItem() {
            return item;
        }

        public void setItem(List<T> item) {
            this.item = item;
        }

    }

}

import java.io.Serializable；
导入java.util.ArrayList；
导入java.util.List；
导入com.fasterxml.jackson.dataformat.xml.annotation.jacksonxmlementwrapper；
导入com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty；
导入com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement；
@JacksonXmlRootElement（localName=“response”）
公共类ResponseObjectList实现了可序列化{
@JacksonXmlProperty（localName=“string”）
私有StringArrayListContainer字符串；
@JacksonXmlProperty（localName=“number”）
私有IntegerArrayList容器号；
公共响应对象列表（）{
超级（）；
}
公共响应对象列表（列表项、列表项）{
超级（）；
this.string=新的StringArrayListContainer（stringItems）；
this.number=新的IntegerArrayListContainer（intItems）；
}
公共StringArrayListContainer getString（）{
返回字符串；
}
公共void集合字符串（StringArrayListContainer字符串）{
this.string=string；
}
公共IntegerArrayListContainer getNumber（）{
返回号码；
}
公共void集合号（IntegerArrayList容器号）{
这个数字=数字；
}
公共静态类StringArrayListContainer扩展了ArrayListContainer{
公共StringArrayListContainer（）{
超级（）；
}
公共StringArrayListContainer（列表项）{
超级（项目）；
}
}
公共静态类IntegerArrayListContainer扩展了ArrayListContainer{
公共IntegerArrayListContainer（）{
超级（）；
}
公共IntegerArrayListContainer（列表项）{
超级（项目）；
}
}
公共静态类ArrayListContainer{
@JacksonXmlElementWrapper（useWrapping=false）
@JacksonXmlProperty（localName=“item”）
私人清单项目；
公共ArrayListContainer（列表项）{
超级（）；
this.item=项目；
}
公共ArrayListContainer（）{
超级（）；
}
公共列表getItem（）{
退货项目；
}
公共无效集合项（列表项）{
this.item=项目；
}
}
}

测试看起来不错：

@Test
    public void test3() throws JsonProcessingException {
        ResponseObjectList response = new ResponseObjectList(
                    Arrays.asList(new String[] {"Sample string.","Another sample string"}),
                    Arrays.asList(new Integer[] {123123123,900912})
                );
        XmlMapper xmlMapper = new XmlMapper();
        String content = xmlMapper.writeValueAsString(response);
        this.logger.debug("content: " + content);
        // content: <response xmlns=""><string><item>Sample string.</item><item>Another sample string</item></string><number><item>123123123</item><item>900912</item></number></response>
    }

    @Test
    public void test4() throws JsonParseException, JsonMappingException, IOException {
        String xml = 
                "<response>"
                + "<string>"
                + "<item>Sample string.</item>"
                + "<item>Another sample string</item>"
                + "</string>"
                + "<number>"
                + "<item>123123123</item>"
                + "<item>900912</item>"
                + "</number>"
                + "</response>";

        XmlMapper xmlMapper = new XmlMapper();
        ResponseObjectList object = xmlMapper.readValue(xml, ResponseObjectList.class);
        Assert.assertFalse(object.getString().getItem().isEmpty());
        Assert.assertFalse(object.getNumber().getItem().isEmpty());
    }

@测试
public void test3（）引发JsonProcessingException{
ResponseObjectList response=新的ResponseObjectList(
asList（新字符串[]{“示例字符串”。，“另一个示例字符串”}），
Arrays.asList（新整数[]{123900912}）
);
XmlMapper XmlMapper=新的XmlMapper（）；
字符串内容=xmlMapper.writeValueAsString（响应）；
this.logger.debug（“内容：+content”）；
//内容：示例字符串。另一个示例字符串123900912
}
@试验
public void test4（）抛出JsonParseException、JsonMappingException、IOException{
字符串xml=
""
+ ""
+“示例字符串。”
+“另一个示例字符串”
+ ""
+ ""
+ "123123123"
+ "900912"
+ ""
+ "";
XmlMapper XmlMapper=新的XmlMapper（）；
ResponseObjectList对象=xmlMapper.readValue（xml，ResponseObjectList.class）；
Assert.assertFalse（object.getString（）.getItem（）.isEmpty（））；
Assert.assertFalse（object.getNumber（）.getItem（）.isEmpty（））；
}

---

对于包装器和测试，我使用了

List

s而不是

ArrayList

s，对于

2.9.9

simple

POJO

with

jacksonxmlementwrapper

注释的效果与预期一样：

class Response {

    @JacksonXmlElementWrapper(localName = "string")
    private List<String> strings;

    @JacksonXmlElementWrapper(localName = "number")
    private List<Integer> numbers;

    // getters, setters
}

类响应{
@JacksonXmlElementWrapper（localName=“string”）
私有列表字符串；
@JacksonXmlElementWrapper（localName=“number”）
私人名单号码；
//能手，二传手
}

序列化时如何使用不同的内部标记，它可以是任何东西而不是“项”？@MoizNoorani，请看一看。这里有一个使用

JAXB

的例子，可以帮助解决这个问题。如果它不适合您，您需要为列表创建自定义序列化程序。