Ignore Null Fields with Jackson

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

When serializing Java objects to JSON, it’s common to omit properties that don’t carry meaningful values. Jackson provides several ways to exclude null fields from the output, depending on how broadly the behavior should apply.

In this tutorial, we look at how to ignore null values at the class level, the field level, and globally through the ObjectMapper.

Jackson - Change Name of Field

Jackson - Change the name of a field to adhere to a specific JSON format.

Jackson - Decide What Fields Get Serialized/Deserialized

How to control which fields get serialized/deserialized by Jackson and which fields get ignored.

2. Ignore Null Fields on the Class

Jackson supports configuring null exclusion directly on a class. This approach scopes the behavior to a single type and keeps global configuration untouched:

@JsonInclude(Include.NON_NULL)
public class MyDto { ... }

For finer control, the same annotation can be applied to individual fields instead:

public class MyDto {

    @JsonInclude(Include.NON_NULL)
    private String stringValue;

    private int intValue;

    // standard getters and setters
}

With either approach, Jackson omits the annotated null values during serialization.

Let’s verify the behavior with a simple test case:

@Test
public void givenNullsIgnoredOnClass_whenWritingObjectWithNullField_thenIgnored()
  throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    MyDto dtoObject = new MyDto();

    String dtoAsString = mapper.writeValueAsString(dtoObject);

    assertThat(dtoAsString, containsString("intValue"));
    assertThat(dtoAsString, not(containsString("stringValue")));
}

Thus, we confirm that applying the annotation at the class or field level prevents null values from appearing in the JSON output.

3. Ignore Null Fields Globally

Additionally, some applications require consistent null exclusion across all serialized classes.

Specifically, we configure this behavior on the ObjectMapper using default property inclusion:

ObjectMapper mapper = new ObjectMapper();
mapper.setDefaultPropertyInclusion(
  JsonInclude.Value.construct(
    JsonInclude.Include.NON_NULL,
    JsonInclude.Include.NON_NULL
  )
);

With this configuration in place, the mapper omits null properties from the resulting JSON.

Notably, the behavior applies consistently without requiring annotations on individual classes:

@Test
public void givenNullsIgnoredGlobally_whenWritingObjectWithNullField_thenIgnored() 
  throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setDefaultPropertyInclusion(
      JsonInclude.Value.construct(
        JsonInclude.Include.NON_NULL,
        JsonInclude.Include.NON_NULL
      )
    );
    MyDto dtoObject = new MyDto();
    String dtoAsString = mapper.writeValueAsString(dtoObject);

    assertThat(dtoAsString, containsString("intValue"));
    assertThat(dtoAsString, not(containsString("stringValue")));
}

This way, we verify that the global configuration applies uniformly to all serialized objects handled by the mapper.

4. Conclusion

In this article, we covered several ways to exclude null fields when serializing objects with Jackson. Class-level and field-level annotations provide fine-grained control, while global configuration ensures consistent behavior across an application.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.