Deserialization: How to Convert JSON to Java Object Using Jackson API

Serialization and deserialization are fundamental concepts in data handling when working with APIs. Serialization converts Java objects into a format (e.g., JSON) suitable for storage or transmission, while deserialization does the reverse—converting JSON into Java objects. In this blog, we’ll explore how to perform deserialization using the popular Jackson API.

What is Jackson?

Jackson is a widely used library in Java for parsing JSON data. It provides a rich set of features for reading, writing, and manipulating JSON, including support for serialization and deserialization.

The key components of Jackson are:

  • ObjectMapper: Core class for JSON parsing and conversion.
  • Annotations: Used for fine-grained control over serialization and deserialization.
  • Modules: Provide support for custom data types like Java 8 LocalDate.

Why Use Jackson for Deserialization?

  • Ease of Use: Simplifies mapping JSON to POJOs (Plain Old Java Objects).
  • Performance: Known for its speed and efficiency.
  • Flexibility: Handles complex JSON structures, nested objects, and arrays.

Step-by-Step Guide to Deserialize JSON into a Java Object

1. Add Jackson Dependency

Ensure that Jackson is included in your project. If you're using Maven, add the following dependency to your pom.xml file:

<dependency>

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

    <artifactId>jackson-databind</artifactId>

    <version>2.15.2</version>

</dependency>

2. Create the POJO Class

Create a class that represents the structure of your JSON. For instance, consider the following JSON:

{

  "id": 101,

  "name": "Pavan Kumar",

  "email": "pavan@example.com"

}

The corresponding Java class would be:

public class User {
    private int id;
    private String name;
    private String email;

    // Getters and Setters
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
}

3. Use ObjectMapper for Deserialization

The ObjectMapper class is the heart of Jackson's functionality. Here’s how you can deserialize the JSON string into a Java object:

import com.fasterxml.jackson.databind.ObjectMapper;


public class JsonToObject {

    public static void main(String[] args) {

        String json = "{ \"id\": 101, \"name\": \"Pavan Kumar\", \"email\": \"pavan@example.com\" }";


        ObjectMapper mapper = new ObjectMapper();


        try {

            // Convert JSON string to Java object

            User user = mapper.readValue(json, User.class);


            // Print user details

            System.out.println("ID: " + user.getId());

            System.out.println("Name: " + user.getName());

            System.out.println("Email: " + user.getEmail());

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

4. Handling Nested JSON

For JSON with nested objects, define separate POJOs for each nested level. Example:

JSON:

{
  "id": 101,
  "name": "Pavan Kumar",
  "contact": {
    "phone": "1234567890",
    "address": "Hyderabad"
  }
}

POJO Classes:

public class Contact {
    private String phone;
    private String address;

    // Getters and Setters
}

public class User {
    private int id;
    private String name;
    private Contact contact;

    // Getters and Setters
}

Deserialization remains the same:

User user = mapper.readValue(json, User.class);
System.out.println("Phone: " + user.getContact().getPhone());

Common Challenges and Solutions

1. Unmatched JSON Field Names

If the JSON field names don’t match the Java field names, use the @JsonProperty annotation:

import com.fasterxml.jackson.annotation.JsonProperty;


public class User {

    @JsonProperty("user_id")

    private int id;


    private String name;


    @JsonProperty("email_address")

    private String email;


    // Getters and Setters

}

2. Handling Unknown Fields

If your JSON contains fields not present in the POJO, configure ObjectMapper to ignore them:

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

3. Null Values

Handle default values for null fields using annotations like @JsonSetter or specify them programmatically in the POJO.

Followers