Configuring Jackson to Ignore Empty or Null Values During Serialization

Problem Background and Common Mistakes

When using Jackson for object serialization, developers often need to filter out empty or null fields. As seen in the provided Q&A data, a typical error is misplacing the @JsonInclude annotation at the field level instead of the class level. For instance, in the JsonOperation.Request class, although fields like requestType and data.username are annotated with @JsonInclude(Include.NON_EMPTY), the serialized output still includes multiple null-valued fields such as birthday:null and email:null. This configuration does not work in Jackson 2.x because the @JsonInclude annotation is designed to be applied at the class level to control the serialization behavior of the entire class.

Correct Annotation Configuration

To properly ignore null fields, the @JsonInclude annotation should be placed on the class definition. For example, modify the JsonOperation.Request class as follows:

@JsonInclude(JsonInclude.Include.NON_NULL)
public static class Request {
    String requestType;
    Data data = new Data();
    
    public static class Data {
        String username;
        String email;
        // other fields...
    }
}

Here, Include.NON_NULL specifies that all fields with null values should be ignored during serialization. If you want to ignore "empty" values such as empty strings or collections, use Include.NON_EMPTY. Note that in versions prior to Jackson 2.0, the annotation @JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL) should be used, with slightly different syntax.

Global Configuration as an Alternative

In addition to annotation-based configuration, Jackson supports global settings via the ObjectMapper, which is particularly useful when handling multiple classes uniformly. The code is as follows:

ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

This configuration affects all objects serialized through this ObjectMapper instance, ensuring that no null fields appear in the JSON output. This approach avoids repeating annotations on each class, improving code maintainability.

Code Example and Verification

Based on the scenario in the Q&A, we refactor the serialization process. First, ensure the class-level annotation is correct:

@JsonInclude(JsonInclude.Include.NON_NULL)
public static class Request {
    String requestType;
    Data data = new Data();
    
    public static class Data {
        String username;
        String email;
        String password;
        // other fields...
    }
}

Then, perform serialization using the configured ObjectMapper:

ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
// Optional: global setting mapper.setSerializationInclusion(Include.NON_NULL);

JsonOperation subscribe = new JsonOperation();
subscribe.request.requestType = "login";
subscribe.request.data.username = "Vincent";
subscribe.request.data.password = "test";
// Other fields remain null or default

String jsonString = mapper.writeValueAsString(subscribe.request);
System.out.println(jsonString);  // Output: {"data":{"username":"Vincent","password":"test"},"requestType":"login"}

At this point, the output JSON will only include non-null fields, matching the expected result. Further verification can be done through unit tests, such as using JUnit assertions to check for the presence of specific fields in the output.

In-Depth Analysis and Best Practices

Ignoring null fields is common in REST API development, as it reduces data transmission volume and improves performance. According to the reference article, the @JsonInclude annotation supports other options like NON_EMPTY (ignoring empty strings, collections, etc.) and NON_DEFAULT (ignoring default values). Developers should choose the appropriate option based on business needs. Although field-level annotation does not directly support ignoring null in Jackson 2.x, similar functionality can be achieved with custom serializers or the @JsonIgnore annotation, but this may add complexity.

In practice, it is recommended to prioritize class-level annotations or global configurations for code simplicity. If different fields require different handling strategies, consider using configuration classes or conditional serialization methods. In summary, properly configuring Jackson serialization options can significantly enhance the quality and efficiency of JSON output.