8

I am trying to deserialize the following XML:

<root>
    <foo name="AAA" />
    <bar name="BBB" />
    <foo name="CCC" />
</root>

My Jackson classes are:

@Data
public class Foo {
    @JacksonXmlProperty(isAttribute = true)
    private String name;
}

Bar is identical, just a different class name. (In the real code they are different, this is just an example).

And the root class is

@Data
public class Root {
    @JacksonXmlProperty(localName = "foo")
    @JacksonXmlElementWrapper(useWrapping = false)
    private List<Foo> foos;
    @JacksonXmlProperty(localName = "bar")
    @JacksonXmlElementWrapper(useWrapping = false)
    private List<Bar> bars;
}

When I try to deserialize the XML, using this code

System.out.println(new XmlMapper().readValue(theXml, Root.class));

The result is this (note the lack of "AAA"):

Root(foos=[Foo(name=CCC)], bars=[Bar(name=BBB)])

However, if I move the fields in the XML so that both foo tags are next to each other, it prints

Root(foos=[Foo(name=AAA), Foo(name=CCC)], bars=[Bar(name=BBB)])

I'm using jackson-dataformat-xml 2.11.1 which is the latest.

What is going on here, and how can I fix it?

Michael
  • 41,989
  • 11
  • 82
  • 128

3 Answers3

9

For any property, you can specify a method to use as the setter or getter using Jackson annotations (JsonSetter and JsonGetter). When you just a need a little modification to what Jackson is doing, then this seems easier that writing a custom deserializer / serializer for the whole class. Jackson also has a JsonAnySetter annotation that is a fallback to use for something not specified in your class (I've found that to be handy sometimes; I've used that to put all XML attributes of a type of element into a single Map rather than having to have properties for every possible attribute).

You could add custom XML deserialization methods to your Root class. Something like this:

@JsonSetter(value =  "foo")
public void setFooFromXml(Foo foo) {
    if (this.foos == null) {
        this.foos = new ArrayList<Foo>();
    } 
    this.foos.add(foo);
}

@JsonSetter(value =  "bar")
public void setBarFromXml(Bar bar) {
    if (this.bars == null) {
        this.bars = new ArrayList<Bar>();
    } 
    this.bars.add(bar);
}

Using Jackson to deserialize the XML like this:

try {
    String input = "<root><foo name=\"AAA\" /><bar name=\"BBB\" /><foo name=\"CCC\" /></root>";
    XmlMapper mapper = new XmlMapper();
    Root root = mapper.readValue(input, Root.class);
    System.out.println(root.getBars());
    System.out.println(root.getFoos());
    
} catch (Exception e) {
    e.printStackTrace();
}

Gives an output of this (after adding some simple toString() and getter methods):

[Bar [name=BBB]]
[Foo [name=AAA], Foo [name=CCC]]
jnorman
  • 606
  • 8
  • 14
2

I must recognize that I usually only use Jackson for JSON handling, but it seems that it is a known limitation of the jackson-dataformat-xml library:

Prior to 2.12 (not yet released as of May 2020), handling of repeated XML elements was problematic (it could only retain the last element read), but #403 improves handling

Maybe this issue could be related with your problem.

As a workaround, if possible, you can apply some kind of XSLT transformation to the XML documents before processing them, so that all nodes with the same name are grouped together, and see if the result is as expected.

You can also try another deserialization alternatives, mainly, JAXB, or direct XML processing.

jccampanero
  • 50,989
  • 3
  • 20
  • 49
0

I've found a solution for grouping repeated, non-consecutive XML fields into one list using Jackson, but it also uses Lombok.

  1. Create a Lombok for the class with '@Builder': https://projectlombok.org/features/Builder
  2. Add the '@Jacksonized' annotation to the class, which makes Jackson use that builder to deserialize: https://projectlombok.org/features/experimental/Jacksonized
  3. Add the '@Singular' annotation to the List field, which makes Lombok create a method for adding a single element instead: https://projectlombok.org/features/Builder#singular
  4. Put the field name in the @Singular annotation, e.g. '@Singular("item")', which makes that method that takes one element have the field name

Together, these make Jackson pass each field as it is reached to the Lombok Builder, which has a single-item builder method that accumulates a list. Interleaving is fine.

son0fether
  • 1