This article explores the issue that when using Jackson for JSON deserialization, the Boolean type field in the Lombok generated class defaults to null instead of false when missing in JSON. By comparing the Boolean wrapper types and the boolean primitive types, the article elaborates on how to effectively solve this problem by changing the field type from Boolean to boolean, and provides sample code and best practice suggestions to ensure that the default value of the field is false when missing in JSON.

Understand Jackson deserialization and Java type default values

In Java, basic data types (such as boolean, int, double, etc.) have their default values. For example, the default value of boolean is false, and the default value of int is 0. However, their packaging types (such as Boolean, Integer, Double, etc.) are used as objects, and their default value is null.

When the Jackson library does JSON deserialization, it tries to map JSON data to fields of a Java object. If a field in JSON is missing, Jackson will handle it according to the type of Java field:

• For basic type fields : If the corresponding field is missing in JSON, Jackson will directly use the default value of the basic type. For example, if the negate field is of boolean type and no negate field is provided in JSON, then negate will be automatically initialized to false.
• For wrapping type fields : If the corresponding field is missing in JSON, Jackson will set it to null. This is because the wrapper type is an object and null is its valid "empty" state.

This is why when the negate field is defined as a Boolean, if the incoming JSON does not contain the negate field, it will be deserialized to null, which may cause a NullPointerException when trying to access negate.

Solution: Use the basic type boolean

The most straightforward and recommended way to solve this problem is to change the type of the field from the Boolean wrapper type to the boolean primitive type.

Consider the following original class definitions:

 import lombok.AllArgsConstructor;
import lombok.Data;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

import java.util.List;

@Data
@AllArgsConstructor
@ApiModel
public class RelationEntityTypeFilter {

    @ApiModelProperty(position = 1, value = "Type of the relationship between root entity and other entity (eg 'Contains' or 'Manages').", example = "Contains")
    private String relationType;

    @ApiModelProperty(position = 2, value = "Array of entity types to filter the related entities (eg 'DEVICE', 'ASSET').")
    private List<entitytype> entityTypes;

    @ApiModelProperty(position = 3, value = "Negate relationship type between root entity and other entity.")
    private Boolean negate = false; // Problem: Boolean type}</entitytype>

Change the type of the negate field to boolean:

 import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor; // It is recommended to add, if you need to deserialize the constructor without arguments import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

import java.util.List;

@Data
@NoArgsConstructor // Add parameterless constructor to support Jackson deserialization @AllArgsConstructor
@ApiModel
public class RelationEntityTypeFilter {

    @ApiModelProperty(position = 1, value = "Type of the relationship between root entity and other entity (eg 'Contains' or 'Manages').", example = "Contains")
    private String relationType;

    @ApiModelProperty(position = 2, value = "Array of entity types to filter the related entities (eg 'DEVICE', 'ASSET').")
    private List<entitytype> entityTypes;

    @ApiModelProperty(position = 3, value = "Negate relationship type between root entity and other entity.")
    private boolean negate; // Solution: Change to boolean basic type// Note: = false here; initialization is no longer necessary, because boolean defaults to false
}</entitytype>

When the negate field becomes boolean type, even if the incoming JSON does not contain the negate field, Jackson will set it to false when deserialized, thus avoiding NullPointerException.

Sample code verification

We can verify this behavior with a simple Jackson deserialization example.

First, define a simplified version of the class that only contains fields of type boolean:

 import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

public class JacksonBooleanDefaultExample {

    @NoArgsConstructor
    @Getter
    @Setter
    @ToString
    public static class SimpleFilter {
        private boolean negate; // Use boolean basic type}

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        // Case 1: Negate field is missing in JSON String negateIsMissingJson = "{ }";
        SimpleFilter filter1 = mapper.readValue(negateIsMissingJson, SimpleFilter.class);
        System.out.println("JSON missing field: " filter1); // Expected output: SimpleFilter(negate=false)

        // Case 2: Negate is explicitly specified in JSON to false
        String negativeIsFalseJson = """
            {
                "negate" : false
            }
            """;
        SimpleFilter filter2 = mapper.readValue(negateIsFalseJson, SimpleFilter.class);
        System.out.println("JSON explicitly specifies false: " filter2); // Expected output: SimpleFilter(negate=false)

        // Case 3: Negate is explicitly specified in JSON to true
        String negateIsTrueJson = """
            {
                "negate" : true
            }
            """;
        SimpleFilter filter3 = mapper.readValue(negateIsTrueJson, SimpleFilter.class);
        System.out.println("JSON explicitly specifies true: " filter3); // Expected output: SimpleFilter(negate=true)
    }
}

Run the above code and the output will be:

 JSON missing field: SimpleFilter(negate=false)
JSON explicitly specifies false: SimpleFilter(negate=false)
JSON explicitly specifies true: SimpleFilter(negate=true)

From the output, we can see that when the negate field is missing in JSON, the negate field of boolean type is correctly deserialized to false.

Best Practices and Precautions

1. Priority use of basic types : For simple boolean flags, priority is given to boolean primitive types. It not only solves the default value issue when Jackson deserializing, but also has better memory efficiency and performance, as it does not require additional object overhead.
2. When to use the wrapper type Boolean :
   • When a field may need to represent three states: true, false, and null (e.g., "Yes", "No", "No/Unset"). But please note that this situation usually requires a clear business implication and should be used with caution in API design to avoid ambiguity.
   • When it is necessary to store boolean values in a collection (such as List, Map), Java collections can only store objects.
   • When used as a generic parameter (e.g. Optional).
3. Lombok and default values : Lombok's @Data annotation will generate constructors, Getters/Setters, etc. If the field is a primitive type, Java's default initialization rules still apply. For boolean, it will be false. Even if = false is explicitly written when the field is declared, this is more of a hint of code readability for the boolean type, because Java will automatically initialize it to false.
4. @JsonInclude(JsonInclude.Include.NON_NULL) : This Jackson annotation is usually used for serialization, indicating that if the field value is null during serialization, the field is not included. It does not affect the processing of null during deserialization. For the primitive type boolean, it is usually not set to null, so this annotation has little effect on it.
5. @JsonProperty(defaultValue = "false") : Although Jackson provides the defaultValue property annotated by @JsonProperty, it is mainly used for document purposes or some specific data binding frameworks. Jackson's own deserializer usually does not directly use this property to set the default value of missing fields . Best practice is still to rely on the default behavior of the Java type itself or initialize it in the constructor/Setter.

Summarize

In Java applications, especially when using Jackson for JSON deserialization, it is crucial to the selection of Boolean fields. To avoid NullPointerException caused by missing fields in JSON and to ensure that the default behavior is as expected, it is strongly recommended to define a simple boolean flag as a boolean primitive type rather than a Boolean wrapper type. This not only simplifies code logic, but also improves program robustness and performance.

The above is the detailed content of Solve the problem of default value when the Lombok Boolean field is missing in Jackson. For more information, please follow other related articles on the PHP Chinese website!