Course – LS (cat=JSON/Jackson)

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:


1. Introduction

In modern software development, data exchange between different systems is a common requirement. One popular data interchange format is JSON (JavaScript Object Notation). JSON’s primary purpose is efficiently sending organized data between a server and web applications over network connections. It acts as a convenient format for this data transmission.

Additionally, JSON is frequently used in web services and APIs to offer public data in a consistent and standardized way. Its flexibility enables smooth integration with various programming languages, platforms, and technologies.

One of the most common Java programming tasks when dealing with JSON is to convert a JSON object, represented by a JsonNode, into a Map structure for easier manipulation and access.

Throughout the upcoming sections of this tutorial, we’ll explore and demonstrate two approaches for converting a JsonNode object into a Map using Jackson and Gson libraries.

2. Overview

Converting JsonNode to a Map is a way to represent JSON data as a structure with keys and values, similar to a dictionary, where keys are strings, and values can be other JSON elements or simple data types. To be specific, this conversion is especially useful for developers because it allows them to work with JSON data using familiar Java Map and List interfaces, making data manipulation more straightforward and intuitive.

In our example scenario, we’ve a Java string named jsonString that holds a JSON-formatted data structure, creating a JSON object with various properties such as “id“, “name“, “email“, “age“, “address“, “skills“, and “isActive“.


String jsonString = "{\"id\": 123456, \"name\": \"John Doe\", \"email\": \"[email protected]\", " +
        "\"age\": 30, \"address\": { \"street\": \"123 Main St\", \"city\": \"New York\", " +
        "\"country\": \"USA\" }, \"skills\": [ \"Java\", \"Python\", \"JavaScript\" ], \"isActive\": true }";

Here’s a breakdown of the JSON object:

  "id": 123456,
  "name": "John Doe",
  "email": "[email protected]",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "New York",
    "country": "USA"
  "skills": ["Java", "Python", "JavaScript"],
  "isActive": true

To achieve the conversion of this jsonString into a Java Map, we’ll use two popular Java libraries, Jackson and Gson. These libraries provide easy-to-use methods to handle JSON data serialization and deserialization.

2. Using the Jackson Library

Jackson is a widely-used Java library that makes working with JSON data a breeze. It offers robust support for parsing and serializing JSON.

To use Jackson, let’s first add its dependency to our pom.xml file:


After adding this required dependency, we’ll use the ObjectMapper class from Jackson to convert the JsonNode into a Java Map:

public void givenJsonData_whenUsingJackson_thenConvertJsonNodeToMap() throws Exception {
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(jsonString);

    Map<String, Object> map = objectMapper.convertValue(jsonNode, Map.class);
    Assert.assertEquals(123456, map.get("id"));
    Assert.assertEquals("John Doe", map.get("name"));
    Assert.assertEquals("[email protected]", map.get("email"));
    Assert.assertEquals(30, map.get("age"));

    Map<String, Object> address = (Map<String, Object>) map.get("address");
    Assert.assertEquals("123 Main St", address.get("street"));
    Assert.assertEquals("New York", address.get("city"));
    Assert.assertEquals("USA", address.get("country"));

    List<String> skills = (List<String>) map.get("skills");
    Assert.assertEquals("Java", skills.get(0));
    Assert.assertEquals("Python", skills.get(1));
    Assert.assertEquals("JavaScript", skills.get(2));

    Assert.assertEquals(true, map.get("isActive"));

The code begins by creating an ObjectMapper instance, which is responsible for reading and writing JSON data. Then, the provided JSON string is then converted into a JsonNode object using the readTree() method. Moreover, the convertValue() method converts the JsonNode into a Map<String, Object>, enabling easy access to the JSON data using key-value pairs.

The code then performs a series of assertions to validate the extracted values, checking if the expected values match those in the converted Map. Nested objects within the JSON structure are accessed by casting the corresponding values to Map<String, Object>, while lists are accessed by casting them to List<String>. The final assertion verifies the value associated with the isActive key.

Overall, the code illustrates how we can use Jackson’s ObjectMapper to convert JSON data into a Map and perform data validation.

3. Using the Gson Library

Gson is another popular library for JSON processing in Java. It provides a simple and flexible API for converting JSON to Java objects.

To convert a JsonNode object to a Map using Gson, first, we should add the Gson dependency to the pom.xml file:


Next, we’ll write a test method that utilizes the Gson library to convert a JsonNode into a Java Map:

public void given_JsonData_whenUsingGson_thenConvertJsonNodeToMap() {
    JsonElement jsonElement = JsonParser.parseString(jsonString);
    Gson gson = new Gson();

    Map<String, Object> map = gson.fromJson(jsonElement, Map.class);
    assertEquals(123456, ((Number) map.get("id")).intValue());
    assertEquals("John Doe", map.get("name"));
    assertEquals("[email protected]", map.get("email"));
    assertEquals(30, ((Number) map.get("age")).intValue());

    Map<String, Object> address = (Map<String, Object>) map.get("address");
    assertEquals("123 Main St", address.get("street"));
    assertEquals("New York", address.get("city"));
    assertEquals("USA", address.get("country"));

    List<String> skills = (List<String>) map.get("skills");
    assertEquals("Java", skills.get(0));
    assertEquals("Python", skills.get(1));
    assertEquals("JavaScript", skills.get(2));

    assertEquals(true, map.get("isActive"));

According to the above test method, the JsonParser class from Gson is utilized to parse the JSON string and convert it into a JsonElement object. Then, a Gson instance is created to convert from JsonElement to Map<String, Object>.

The code includes several assertions to verify that the converted Map contains the expected values. For example, it checks if the value associated with the key id equals 123456, and if the value associated with the key name is equal to John Doe.

Nested objects, such as the address object, can be accessed by casting the corresponding value in the Map to Map<String, Object>. Similarly, the skills array is accessed by casting its value to List<String>. As in the previous example, a new assertion is added to confirm whether the value associated with the key isActive equals true.

This code demonstrates the Gson library’s capability to convert JsonNode into a Java Map and perform assertions on the extracted values.

4. Conclusion

Converting a JsonNode object to a Map is a common requirement when working with JSON data in Java. We can easily perform this conversion by using libraries like Jackson or Gson.

In this tutorial, we provided detailed examples along with test cases to demonstrate the process of converting a JsonNode object to a Map using both Jackson and Gson libraries. By applying these examples, we can efficiently handle JSON data and manipulate it.

As always, the complete code samples for this article can be found over on GitHub.

Course – LS (cat=JSON/Jackson)

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

res – Jackson (eBook) (cat=Jackson)
Comments are closed on this article!