Setting Default Values to Null Fields in Jackson Mapping

1. Overview

Due to its relative simplicity and robustness, JavaScript Object Notation (JSON) has established itself as the go-to data format when it comes to both human readability and machine parsing. Still, there can be quirks with some JSON objects and properties, which require special processing.

In this tutorial, we’ll look at different ways to handle null or missing values in JSON Strings when parsing them using Jackson. Specifically, we’ll explore three options with varying levels of control.

2. Setting a Default Value at the Class Level

To begin with, let’s demonstrate how we get default values into POJOs when they’re missing entirely from incoming JSON Strings.

As an example, we create an object with two fields, one required, and the second optional, both called with their respective name:

class NonAnnotatedDefaultValue {
    String required;
    String optional = "defaultValue";
    // Standard getters and setters
}

Thus, we only assigned a value to the field called optional. Because of this, Jackson uses the predefined String if the field is missing in an incoming JSON object.

To demonstrate, let’s use the new object by asking Jackson to map a JSON String without any field called optional in it. To that end, use the ObjectMapper object and its readValue() method:

@Test
void givenAClassWithADefaultValue_whenReadingJsonWithoutOptionalValue_thenExpectDefaultValueInResult()
  throws JsonProcessingException {
    String noOptionalField = "{\"required\": \"value\"}";
    ObjectMapper objectMapper = new ObjectMapper();
    NonAnnotatedDefaultValue createdObject = objectMapper.readValue(noOptionalField, NonAnnotatedDefaultValue.class);
    assert(createdObject.getRequired()).equals("value");
    assert(createdObject.getOptional()).equals("defaultValue");
}

We can see from the assertions that the resulting object has both the value from the JSON and the default value we specified earlier.

The drawback of this method is that it only works if the property is missing entirely from the incoming JSON. If the property is present with a null value, then Jackson won’t apply the default.

In the following sections, we explore approaches that enable us to handle nulls efficiently.

3. Implementing a Setter Method for Maximum Control

Of course, we can take complete control of the mapping process by implementing a setter method for an optional field for which we want to provide a value.

So, let’s create an object with the required setter that Jackson uses when creating the objects:

class SetterDefaultValue {
   String required;
   String optional = "valueIfMissingEntirely";

    public void setOptional(String optional) {
        if (optional == null) {
            this.optional = "valueIfNull";
        }
    }
   // Standard getters and setters
}

Thus, we provided a default value at the class level like before. However, we also provided a setter method. Within that setter method, we can perform any desired checks. In this example, we explicitly provided the expected behavior if the value is null. Jackson now sets optional to valueIfMissingEntirely if we don’t include the property in the JSON, or valueIfNull should it be included but set to null.

We could’ve also made both values the same if that met the requirements:

@Test
void givenAClassWithASetter_whenReadingJsonWithNullOptionalValue_thenExpectDefaultValueInResult()
  throws JsonProcessingException {
    String nullOptionalField = "{\"required\": \"value\", \"optional\": null}";
    ObjectMapper objectMapper = new ObjectMapper();
    JsonSetterDefaultValue createdObject = objectMapper.readValue(nullOptionalField, JsonSetterDefaultValue.class);
    assert(createdObject.getRequired()).equals("value");
    assert(createdObject.getOptional()).equals("valueIfNull");
}

Here, we provided a JSON string, which has the field named optional set to null. Consequently, we can see from the assertions that in the resulting object that Jackson creates, the field has been set to valueIfNull, thanks to the setter annotation.

This makes the general setter approach very flexible. For instance, we could also check for empty Strings and apply a default in the same way if desired or required.

Furthermore, setters can be even more complex.

4. Deserializing Null Strings as Empty Strings

On top of the previous methods, we can use the setter method to deserialize null in the optional field as empty strings.

Let’s again create a POJO class with a setter method for the optional field for Jackson to create objects accordingly:

class SetterDefaultValueAsEmptyString {
    String required;
    String optional = "valueIfMissingEntirely";

    public void setOptional(String optional) {
        if (optional == null) {
            this.optional = "";
        }
    }
    
    // Standard getters and setters
}

In the setter method, we explicitly defined the expected behavior for a null value. Jackson sets the optional field to valueIfMissingEntirely if we don’t include the property in the JSON, as before. However, this time it also sets the optional field to an empty string if it’s included but set to null.

Let’s use a test method to verify that the null value gets mapped to an empty string:

@Test
public void givenAClassWithASetter_whenReadingJsonWithNullOptionalValue_thenEmptyStringInResult() throws JsonProcessingException {
    String nullOptionalField = "{\"required\": \"value\", \"optional\": null}";
    ObjectMapper objectMapper = new ObjectMapper();
    SetterDefaultValueAsEmptyString createdObject = objectMapper.readValue(nullOptionalField, SetterDefaultValueAsEmptyString.class);
    assert(createdObject.getRequired()).equals("value");
    assert(createdObject.getOptional()).equals("");
}

This time, the provided JSON has the field named optional set to null. As we can see from the assertions, the resulting object created by Jackson contains the field with its value set to an empty string.

5. Using @JsonSetter With Nulls.SKIP

The final option we look at utilizes @JsonSetter and extends the usage to tell it to ignore nulls.

Let’s create a new class:

class NullsSkipDefaultValue {
    private String required;
    @JsonSetter(nulls = Nulls.SKIP)
    private String optional = "defaultValue";
    // standard getters and setters
}

The Nulls.SKIP argument tells @JsonSetter to skip any input with a null value. Jackson then uses the provided default value instead. There are several other options we can use within the Nulls enum. For example, Nulls.SET tells Jackson to translate a null in the JSON to the Java null in the POJO:

@Test
void givenAClassWithAJsonSetterNullsSkip_whenReadingJsonWithNullOptionalValue_thenExpectDefaultValueInResult() throws JsonProcessingException {
    String nullOptionalField = "{\"required\": \"value\", \"optional\": null}";
    ObjectMapper objectMapper = new ObjectMapper();
    NullsSkipDefaultValue createdObject = objectMapper.readValue(nullOptionalField, NullsSkipDefaultValue.class);
    assert(createdObject.getRequired()).equals("value");
    assert(createdObject.getOptional()).equals("defaultValue");
}

Above, we can see that given the input JSON, where the optional field is assigned to null, we get the default value we wanted. This method also gives the same result if we don’t provide an optional field.

6. Conclusion

In this article, we explored four ways of dealing with missing or null values in JSON that we want to parse using Jackson.

Setting the value at the class level is useful but fails if we have a null value. Instead, we can implement a setter method for maximum control.  Thus, we can set a null to a desired value. On the other hand, a null value can also be set to an empty string in the setter method.  Alternatively, we can use @JsonSetter over the field declaration to simply ignore nulls.

All four method may be suitable depending on the use case. The most important consideration is how we want the application to handle a property with the value null.