Converting JSON to XML in Java

1. Overview

JSON and XML are two popular formats for data exchange. In real-world applications, we often need to convert between them.

In this tutorial, we’ll look at different ways to convert JSON to XML in Java.

2. JSON-Java Library

Firstly, the JSON-Java library provides a simple method to convert JSON to XML.

2.1. Dependency

Let’s start by adding the JSON-Java dependency to our pom.xml:

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20240303</version>
</dependency>

2.2. Code Example

We can use test cases to demonstrate the conversion. Let’s create a test case to convert a JSON string to XML:

@Test
public void givenJsonString_whenConvertToXMLUsingJsonJava_thenConverted() {
    String jsonString = "{\"name\":\"John\", \"age\":20, \"address\":{\"street\":\"Wall Street\", \"city\":\"New York\"}}";
    JSONObject jsonObject = new JSONObject(jsonString);
    String xmlString = XML.toString(jsonObject);
    Assertions.assertEquals("<address><city>New York</city><street>Wall Street</street></address><name>John</name><age>20</age>", xmlString);
}

As we can see, we can convert a JSON string to XML using the XML.toString() method. This method takes a JSONObject as an argument and returns an XML string. We then assert that the string is as expected.

This method creates a compact XML string where each key is converted to an XML tag, and the value is the tag’s text content.

3. Jackson

Jackson is a popular JSON library for Java. It can also be used to convert JSON to XML.

3.1. Dependency

Let’s start by adding the Jackson dependency to our pom.xml:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

3.2. Code Example

Next, we’ll create a test case to convert a JSON string to XML using Jackson:

@Test
public void givenJsonString_whenConvertToXMLUsingJackson_thenConverted() throws JsonProcessingException {
    String jsonString = "{\"name\":\"John\", \"age\":20, \"address\":{\"street\":\"Wall Street\", \"city\":\"New York\"}}";
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(jsonString);
    String xmlString = new XmlMapper().writeValueAsString(jsonNode);
    Assertions.assertEquals("<ObjectNode><name>John</name><age>20</age><address><street>Wall Street</street><city>New York</city></address></ObjectNode>", xmlString);
}

As we can see, we can convert a JSON string to XML using the XmlMapper class. The class has a writeValueAsString() method that takes a JsonNode as an argument and returns an XML string. Additionally, the output tags are wrapped in an ObjectNode tag.

3.3. Customizing the Output

In the previous example, we saw that the output XML string isn’t formatted, has no XML declaration, and the root tag is ObjectNode. Since this isn’t in accordance with the XML standard, we can customize the output to make it more readable and standard-compliant.

Let’s add a few configuration options to the XmlMapper object to customize the output:

@Test
public void givenJsonString_whenConvertToXMLUsingJacksonWithXMLDeclarationAndRoot_thenConverted() throws JsonProcessingException {
    String jsonString = "{\"name\":\"John\", \"age\":20, \"address\":{\"street\":\"Wall Street\", \"city\":\"New York\"}}";
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(jsonString);
    
    XmlMapper xmlMapper = new XmlMapper();
    xmlMapper.configure(SerializationFeature.INDENT_OUTPUT, true);
    xmlMapper.configure(ToXmlGenerator.Feature.WRITE_XML_DECLARATION, true);
    xmlMapper.configure(ToXmlGenerator.Feature.WRITE_XML_1_1, true);
    
    String xmlString = xmlMapper.writer().withRootName("root").writeValueAsString(jsonNode);
    
    Assertions.assertEquals("<?xml version='1.1' encoding='UTF-8'?>" + System.lineSeparator() +
      "<root>" + System.lineSeparator() +
      " <name>John</name>" + System.lineSeparator() +
      " <age>20</age>" + System.lineSeparator() +
      " <address>" + System.lineSeparator() +
      " <street>Wall Street</street>" + System.lineSeparator() +
      " <city>New York</city>" + System.lineSeparator() +
      " </address>" + System.lineSeparator() +
      "</root>" + System.lineSeparator(), xmlString);
}

Here, we’ve added a few configuration options to the XmlMapper object:

• SerializationFeature.INDENT_OUTPUT indents the output XML string to make it more readable
• ToXmlGenerator.Feature.WRITE_XML_DECLARATION adds an XML declaration to the output XML string
• ToXmlGenerator.Feature.WRITE_XML_1_1 adds XML version 1.1 to the XML declaration
• withRootName() sets the root tag name to root instead of ObjectNode

As we can see, the output XML string is now formatted, has an XML declaration, and the root tag is root.

4. Using Underscore-java

Underscore-java is a utility library that provides methods to convert JSON to XML. Notably, it requires Java 11 or higher to work.

In the Jackson example, we had to add a few configuration options to the XmlMapper object to customize the output as per the XML standard. Underscore-java follows the XML standard by default and doesn’t require these configuration options.

4.1. Dependency

Let’s start by adding the Underscore-java dependency to our pom.xml:

<dependency>
    <groupId>com.github.javadev</groupId>
    <artifactId>underscore-java</artifactId>
    <version>1.89</version>
</dependency>

4.2. Code Example

Next, let’s create a test case to convert a JSON string to XML using Underscore-java:

@Test
public void givenJsonString_whenConvertToXMLUsingUnderscoreJava_thenConverted() {
    String jsonString = "{\"name\":\"John\", \"age\":20}";
    String xmlString = U.jsonToXml(jsonString);
    Assertions.assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
      "<root>\n" +
      "  <name>John</name>\n" +
      "  <age number=\"true\">20</age>\n" +
      "</root>", xmlString);
}

As we can see, we can convert a JSON string to XML using the U.jsonToXml() method.

It also adds the root element and the declaration to the XML string. Unlike other libraries, the output is formatted by default for readability.

For all non-string fields, it adds a type attribute to the tag. For example, it adds the number attribute to the age element. This makes it easier to parse the XML string back to JSON if needed.

If we don’t need the attributes, we can disable them using the U.JsonToXmlMode.REMOVE_ATTRIBUTES option:

@Test
public void givenJsonString_whenConvertToXMLUsingUnderscoreJavaWithoutAttributes_thenConverted() {
    String jsonString = "{\"name\":\"John\", \"age\":20}";
    String xmlString = U.jsonToXml(jsonString, U.JsonToXmlMode.REMOVE_ATTRIBUTES);
    Assertions.assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
      "<root>\n" +
      "  <name>John</name>\n" +
      "  <age>20</age>\n" +
      "</root>", xmlString);
}

As we can see, the number attribute isn’t added to the age element anymore.

5. Conclusion

In this article, we looked at different ways to convert JSON to XML in Java. We also looked at a few test cases to understand the conversion.

As always, the code examples are available over on GitHub.