Deserialization: Converting JSON to Map Using Jackson API

When working with JSON data in Java applications, you often need to transform JSON objects into a data structure for further processing. One common use case is converting JSON data into a Map. The Jackson API provides a robust and straightforward mechanism for this transformation.

In this blog post, we’ll explore how to deserialize JSON into a Map using Jackson API with step-by-step examples.

What is Deserialization?

Deserialization is the process of converting a JSON string into an equivalent Java object. For example, a JSON object like this:

{

  "name": "Pavan",

  "role": "SDET-QA",

  "skills": ["Java", "Selenium", "TestNG"]

}

can be converted into a Java Map<String, Object> where the keys are strings, and the values are objects.

Why Use Map for JSON Deserialization?

  1. Dynamic Structure: A Map can store any type of key-value pairs, making it suitable for JSON data with varying structures.
  2. Flexibility: No need to create a specific POJO (Plain Old Java Object) class for every JSON structure.
  3. Ease of Access: Direct access to JSON elements using keys.

Steps to Deserialize JSON to Map Using Jackson API

Step 1: Add Jackson Dependencies

Ensure you have Jackson dependencies in your project. If you're using Maven, include the following:

<dependency>

    <groupId>com.fasterxml.jackson.core</groupId>

    <artifactId>jackson-databind</artifactId>

    <version>2.15.2</version>

</dependency>

Step 2: Create the JSON Data

Here’s an example JSON string we’ll use for this demonstration:

{

  "name": "Pavan",

  "role": "SDET-QA",

  "skills": ["Java", "Selenium", "TestNG"]

}

Step 3: Use ObjectMapper to Deserialize

Jackson’s ObjectMapper class provides methods to easily convert JSON strings to Java objects, including Map.

Here’s the code:

import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Map;


public class JsonToMapExample {

    public static void main(String[] args) {

        String json = "{\n" +

                      "  \"name\": \"Pavan\",\n" +

                      "  \"role\": \"SDET-QA\",\n" +

                      "  \"skills\": [\"Java\", \"Selenium\", \"TestNG\"]\n" +

                      "}";


        try {

            // Create an ObjectMapper instance

            ObjectMapper objectMapper = new ObjectMapper();


            // Deserialize JSON string into a Map

            Map<String, Object> map = objectMapper.readValue(json, Map.class);


            // Print the Map

            System.out.println("Deserialized Map: " + map);


            // Access individual elements

            System.out.println("Name: " + map.get("name"));

            System.out.println("Role: " + map.get("role"));

            System.out.println("Skills: " + map.get("skills"));

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

Step 4: Execute the Program

When you run the above program, you’ll get the following output:

Deserialized Map: {name=Pavan, role=SDET-QA, skills=[Java, Selenium, TestNG]}

Name: Pavan

Role: SDET-QA

Skills: [Java, Selenium, TestNG]

Handling Nested JSON Structures

If your JSON contains nested objects, Jackson will automatically handle it and convert nested structures into a Map or appropriate Java object.

For example:

{

  "name": "Pavan",

  "role": "SDET-QA",

  "details": {

    "experience": 5,

    "location": "Hyderabad"

  }

}

The code remains the same, and the nested JSON will be deserialized into another Map within the main Map:

System.out.println("Details Map: " + map.get("details"));

Output:

Details Map: {experience=5, location=Hyderabad}

Key Points to Remember

  1. Use ObjectMapper.readValue() to convert JSON to Map.
  2. The generic type of the Map should typically be Map<String, Object> to accommodate different value types.
  3. Nested JSON structures will be converted into nested Map objects.

When to Use POJOs Instead of Map?

While using Map is convenient for dynamic JSON structures, it’s better to use POJOs when:

  • You need strong type safety.
  • The JSON structure is well-defined and unlikely to change.
  • You want to perform validations on deserialized data.

Followers