Home

repost: XML Serialization and Deserialization with Jackson

# 1. Overview

In this tutorial, we’ll learn how to serialize Java objects to XML data using Jackson 2.x, and deserialize them back to a POJO.

We’ll focus on the basic operation that doesn’t require a lot of complexity or customization.

# 2. XmlMapper Object

XmlMapper is the main class from Jackson 2.x that helps us in serialization, so we’ll need to create an instance of it:

1
XmlMapper mapper = new XmlMapper();

This mapper is available in the jackson-dataformat-xml jar, so we have to add it as a dependency to our pom.xml:

1
2
3
4
5
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.11.1</version>
</dependency>

Please check the latest version of the jackson-dataformat-xml dependency in the Maven repository.

# 3. Serialize Java to XML

XmlMapper is a subclass of ObjectMapper, which is used in JSON serialization; however, it adds some XML specific tweaks to the parent class.

Let’s look at how to use it to do the actual serialization. Let’s create a Java class first:

1
2
3
4
5
6
class SimpleBean {
    private int x = 1;
    private int y = 2;

    //standard setters and getters
}

# 3.1. Serialize to the XML String

We can serialize our Java object into the XML String:

1
2
3
4
5
6
@Test
public void whenJavaSerializedToXmlStr_thenCorrect() throws JsonProcessingException {
    XmlMapper xmlMapper = new XmlMapper();
    String xml = xmlMapper.writeValueAsString(new SimpleBean());
    assertNotNull(xml);
}

As a result, we’ll get:

1
2
3
4
<SimpleBean>
    <x>1</x>
    <y>2</y>
</SimpleBean>

# 3.2. Serialize to the XML File

We can also serialize our Java object to the XML file:

1
2
3
4
5
6
7
@Test
public void whenJavaSerializedToXmlFile_thenCorrect() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    xmlMapper.writeValue(new File("simple_bean.xml"), new SimpleBean());
    File file = new File("simple_bean.xml");
    assertNotNull(file);
}

And below we can see the content of the resulting file named simple_bean.xml:

1
2
3
4
<SimpleBean>
    <x>1</x>
    <y>2</y>
</SimpleBean>

# 4. Deserialize XML to Java

In this section, we’ll look at how to obtain Java objects from XML.

# 4.1. Deserialize From the XML String

As with serialization, we can also deserialize an XML String back to a Java object:

1
2
3
4
5
6
7
@Test
public void whenJavaGotFromXmlStr_thenCorrect() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    SimpleBean value
      = xmlMapper.readValue("<SimpleBean><x>1</x><y>2</y></SimpleBean>", SimpleBean.class);
    assertTrue(value.getX() == 1 && value.getY() == 2);
}

# 4.2. Deserialize From the XML File

Likewise, if we have an XML file, we can convert it back to a Java object.

1
2
3
4
5
6
7
@Test
public void whenJavaGotFromXmlFile_thenCorrect() throws IOException {
    File file = new File("simple_bean.xml");
    XmlMapper xmlMapper = new XmlMapper();
    SimpleBean value = xmlMapper.readValue(file, SimpleBean.class);
    assertTrue(value.getX() == 1 && value.getY() == 2);
}

# 5. Handling Capitalised Elements

In this section, we’ll discuss how to handle scenarios where we either have XML with capitalized elements to deserialize, or we need to serialize Java objects to XML with one or more elements capitalized.

# 5.1. Deserialize From the XML String

Let’s say we have an XML with one field capitalized:

1
2
3
4
<SimpleBeanForCapitalizedFields>
    <X>1</X>
    <y>2</y>
</SimpleBeanForCapitalizedFields>

In order to correctly handle capitalized elements, we need to annotate the “x” field with the @JsonProperty annotation:

1
2
3
4
5
6
7
class SimpleBeanForCapitalizedFields {
    @JsonProperty("X")
    private int x = 1;
    private int y = 2;

    // standard getters, setters
}

We can now correctly deserialize an XML String back to a Java object:

1
2
3
4
5
6
7
8
9
@Test
public void whenJavaGotFromXmlStrWithCapitalElem_thenCorrect() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    SimpleBeanForCapitalizedFields value
      = xmlMapper.readValue(
      "<SimpleBeanForCapitalizedFields><X>1</X><y>2</y></SimpleBeanForCapitalizedFields>",
      SimpleBeanForCapitalizedFields.class);
    assertTrue(value.getX() == 1 && value.getY() == 2);
}

# 5.2. Serialize to the XML String

By annotating the required fields with @JsonProperty, we can correctly serialize a Java object into an XML String with one or more capitalized elements:

1
2
3
4
5
6
7
8
9
@Test
public void whenJavaSerializedToXmlFileWithCapitalizedField_thenCorrect()
  throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    xmlMapper.writeValue(new File("target/simple_bean_capitalized.xml"),
      new SimpleBeanForCapitalizedFields());
    File file = new File("target/simple_bean_capitalized.xml");
    assertNotNull(file);
}

# 6. Serialize List to XML

The XmlMapper is able to serialize an entire Java bean into a document. To convert a Java object to XML, we’ll take a simple example with a nested object and arrays.

Our intent is to serialize a Person object, along with its composed Address object, into XML.

Our final XML will look something like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<Person>
    <firstName>Rohan</firstName>
    <lastName>Daye</lastName>
    <phoneNumbers>
        <phoneNumbers>9911034731</phoneNumbers>
        <phoneNumbers>9911033478</phoneNumbers>
    </phoneNumbers>
    <address>
        <streetName>Name1</streetName>
        <city>City1</city>
    </address>
    <address>
        <streetName>Name2</streetName>
        <city>City2</city>
    </address>
</Person>

Notice that our phone numbers are encapsulated in a phoneNumbers wrapper, while our address isn’t.

We can express this nuance via the @JacksonXMLElementWrapper annotation in our Person class:

1
2
3
4
5
6
7
8
9
public final class Person {
    private String firstName;
    private String lastName;
    private List<String> phoneNumbers = new ArrayList<>();
    @JacksonXmlElementWrapper(useWrapping = false)
    private List<Address> address = new ArrayList<>();

    //standard setters and getters
}

In fact, we can change the wrapping element name with @JacksonXmlElementWrapper(localName = ‘phoneNumbers’). Or, if we don’t want to wrap our elements, we can disable the mapping with @JacksonXmlElementWrapper(useWrapping = false).

Then we’ll define our Address type:

1
2
3
4
5
public class Address {
    String streetName;
    String city;
    //standard setters and getters
}

Jackson takes care of the rest for us. Like before, we can simply call writeValue again:

1
2
3
4
5
6
7
8
9
10
private static final String XML = "<Person>...</Person>";

@Test
public void whenJavaSerializedToXmlFile_thenSuccess() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    Person person = testPerson(); // test data
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    xmlMapper.writeValue(byteArrayOutputStream, person);
    assertEquals(XML, byteArrayOutputStream.toString());
}

# 7. Deserialize XML to List

Jackson can read XML that contains lists of objects as well.

If we take our same XML as before, the readValue method does just fine:

1
2
3
4
5
6
7
@Test
public void whenJavaDeserializedFromXmlFile_thenCorrect() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    Person value = xmlMapper.readValue(XML, Person.class);
    assertEquals("City1", value.getAddress().get(0).getCity());
    assertEquals("City2", value.getAddress().get(1).getCity());
}

# 8. Conclusion

This brief article illustrated how to serialize a simple POJO to XML, and obtain a POJO from basic XML data.

We also explored how to serialize and deserialize complex beans that contain collections.

Edited on