Forcing Jackson to Deserialize to Specific Type

1. Overview

In this tutorial, we’ll explore how to force Jackson to deserialize a JSON value to a specific type.

By default, Jackson deserializes JSON values to a type specified by the target field. Sometimes, it’s possible that the target field type isn’t specific. This is done to allow multiple types of values. In such cases, Jackson may deserialize the value by choosing the closest matching subtype of the specified type. This may lead to unexpected results.

We’ll explore how to restrict Jackson from deserializing a JSON value to a specific type.

2. Code Example Setup

For our example, we’ll define a JSON structure with a field that can have multiple types of values. We’ll then create a Java class to represent the JSON structure and use Jackson to deserialize the value to a specific type in certain cases.

2.1. Dependencies

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

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

2.2. JSON Structure

Next, let’s look at our input JSON structure:

{
  "person": [
    {
      "key": "name",
      "value": "John"
    },
    {
      "key": "id",
      "value": 25
    }
  ]
}

Here we have a person object with multiple key-value properties. The value field can have different types of values.

2.3. DTO

Next, we’ll create a DTO class to represent the JSON structure:

public class PersonDTO {
    private List<KeyValuePair> person;

    // constructors, getters and setters
    
    public static class KeyValuePair {
        private String key;
        private Object value;

        // constructors, getters and setters
    }
}

The PersonDTO class contains a list of key-value pairs that represent a person. Here, the value field is of type Object to allow multiple types of values.

3. Default Deserialization

To demonstrate our problem, let’s see how default deserialization works in Jackson.

3.1. Reading JSON

We’ll define a method that reads our input JSON and deserializes it to a PersonDTO object:

public PersonDTO readJson(String json) throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    return mapper.readValue(json, PersonDTO.class);
}

Here, we use the ObjectMapper class to read the JSON string and convert it to a PersonDTO object. We want the value for id to be deserialized to a Long type. We’ll write a test to verify this behavior.

3.2. Testing the Default Deserialization

Now, let’s test our method by reading the JSON and checking the type of its fields:

@Test
void givenJsonWithDifferentValueTypes_whenDeserialize_thenIntValue() throws JsonProcessingException {
    String json = "{\"person\": [{\"key\": \"name\", \"value\": \"John\"}, {\"key\": \"id\", \"value\": 25}]}";
    PersonDTO personDTO = readJson(json);
    assertEquals(String.class, personDTO.getPerson().get(0).getValue().getClass());
    assertEquals(Integer.class, personDTO.getPerson().get(1).getValue().getClass()); // Integer by default
}

When we run the test, we’ll see that it passes. Jackson deserializes the id value to an Integer type instead of a Long type since the value can fit in an Integer type.

In the next sections, we’ll explore how we can modify this default behavior.

4. Custom Deserialization to Specific Type

The simplest way to force Jackson to deserialize the value to a specific type is to use a custom deserializer.

Let’s create a custom deserializer for the value field in the KeyValuePair class:

public class ValueDeserializer extends JsonDeserializer<Object> {
    @Override
    public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        JsonToken currentToken = p.getCurrentToken();
        if (currentToken == JsonToken.VALUE_NUMBER_INT) {
            return p.getLongValue();
        } else if (currentToken == JsonToken.VALUE_STRING) {
            return p.getText();
        } 
        return null;
    }
}

Here we get the current token from the JsonParser and check if it’s a number or a string. If it’s a number, we return the value as a Long type. If it’s a string, we return the value as a String type. In this way, we force Jackson to deserialize the value to a long if it’s a number.

Next, we’ll annotate the value field in the KeyValuePair class with the @JsonDeserialize annotation to use the custom deserializer:

public static class KeyValuePair {
    private String key;

    @JsonDeserialize(using = ValueDeserializer.class)
    private Object value;
}

We can write another test to verify that a Long value is returned now:

@Test
void givenJsonWithDifferentValueTypes_whenDeserialize_thenLongValue() throws JsonProcessingException {
    String json = "{\"person\": [{\"key\": \"name\", \"value\": \"John\"}, {\"key\": \"id\", \"value\": 25}]}";
    PersonDTOWithCustomDeserializer personDTO = readJsonWithCustomDeserializer(json);
    assertEquals(String.class, personDTO.getPerson().get(0).getValue().getClass());
    assertEquals(Long.class, personDTO.getPerson().get(1).getValue().getClass());
}

5. Configuring ObjectMapper

The above method is good when we want custom behavior for a specific field. However, if the same rule applies to all fields of a class or multiple classes, we can configure the ObjectMapper to use the USE_LONG_FOR_INTS deserialization feature:

PersonDTO readJsonWithLongForInts(String json) throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(DeserializationFeature.USE_LONG_FOR_INTS);
    return mapper.readValue(json, PersonDTO.class);
}

Here, we enable the USE_LONG_FOR_INTS feature in the ObjectMapper to force Jackson to deserialize all integer values to Long type.

Let’s test if this configuration works as expected:

@Test
void givenJsonWithDifferentValueTypes_whenDeserializeWithLongForInts_thenLongValue() throws JsonProcessingException {
    String json = "{\"person\": [{\"key\": \"name\", \"value\": \"John\"}, {\"key\": \"id\", \"value\": 25}]}";
    PersonDTO personDTO = readJsonWithLongForInts(json);
    assertEquals(String.class, personDTO.getPerson().get(0).getValue().getClass());
    assertEquals(Long.class, personDTO.getPerson().get(1).getValue().getClass());
}

When we run the test, we’ll see that it passes. Any integer value in the JSON is deserialized to a Long type.

6. Using @JsonTypeInfo

The above two methods convert all integer values in the value field to Long type. If we want to convert the values to a specific type dynamically, we can use the @JsonTypeInfo annotation. However, this requires the input JSON to contain the type information.

6.1. Adding Type to the JSON

We modify the JSON structure to include the type information for the value field:

{
  "person": [
    {
      "key": "name",
      "type": "string",
      "value": "John"
    },
    {
      "key": "id",
      "type": "long",
      "value": 25
    },
    {
      "key": "age",
      "type": "int",
      "value": 30
    }
  ]
}

Here we add a type field in our objects. We also add an Integer field age to test that both int and long values are deserialized correctly.

6.2. Customizing the DTO

Next, we’ll modify the KeyValuePair class to include the type information:

public class PersonDTOWithType {
    private List<KeyValuePair> person;

    public static class KeyValuePair {
        private String key;

        @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXTERNAL_PROPERTY, property = "type")
        @JsonSubTypes({
            @JsonSubTypes.Type(value = String.class, name = "string"),
            @JsonSubTypes.Type(value = Long.class, name = "long"),
            @JsonSubTypes.Type(value = Integer.class, name = "int")
        })
        private Object value;

        // constructors, getters and setters
    }
}

Here, we use the @JsonTypeInfo annotation to specify the type information for the value field. We specify that an external property with the name “type” contains the type information.

We also use the @JsonSubTypes annotation to define all the subtypes that the value can have. If the type field has the value “string” we convert it to an object of type String.

Now, when Jackson deserializes the value, it uses the type information to determine the exact type of the value.

6.3. Testing

Let’s write a test to verify this behavior:

@Test
void givenJsonWithDifferentValueTypes_whenDeserializeWithTypeInfo_thenSuccess() throws JsonProcessingException {
    String json = "{\"person\": [{\"key\": \"name\", \"type\": \"string\", \"value\": \"John\"}, {\"key\": \"id\", \"type\": \"long\", \"value\": 25}, {\"key\": \"age\", \"type\": \"int\", \"value\": 30}]}";
    PersonDTOWithType personDTO = readJsonWithValueType(json);
    assertEquals(String.class, personDTO.getPerson().get(0).getValue().getClass());
    assertEquals(Long.class, personDTO.getPerson().get(1).getValue().getClass());
    assertEquals(Integer.class, personDTO.getPerson().get(2).getValue().getClass());
}

When we run the test, we see that it passes successfully. The id value is converted to Long and the age value is converted to Integer.

7. Conclusion

In this article, we learned how to force Jackson to deserialize a JSON value to a specific type. We explored different methods to achieve this, such as using a custom deserializer, configuring the ObjectMapper to use a deserialization feature, and using the @JsonTypeInfo annotation to specify the type information for the value field.