Ignore Null Fields During Jackson Serialization in Java

You will learn how Jackson decides whether a Java property appears in JSON and how to omit properties whose values are null. You will see the field-level @JsonInclude(JsonInclude.Include.NON_NULL) annotation, class-wide and global alternatives, and common configuration mistakes.

Jackson serializes Java objects into JSON. By default, a property with a null value is usually written explicitly:

{
  "someValue": null
}

Sometimes an API should instead omit that property entirely:

{}

Use @JsonInclude(JsonInclude.Include.NON_NULL) to tell Jackson: include this property only when its value is not null.

This matters because an omitted JSON property and a property containing null can have different meanings:

• Missing property: the sender did not provide a value.
• Property set to null: the sender explicitly provided no value.

Whether that distinction is appropriate depends on your API contract. The annotation affects serialization—turning Java objects into JSON. It does not by itself change how JSON is deserialized into Java objects.

Think of each Java field as an item that may be packed into a JSON box.

• Normal Jackson behavior puts every item in the box, even an empty one labeled null.
• Include.NON_NULL is a packing rule: “Only pack this item if it contains something.”

If someValue is "hello", Jackson packs it. If it is null, Jackson leaves it out.

Import JsonInclude and apply it to the field:

import com.fasterxml.jackson.annotation.JsonInclude;

public class SomeClass {

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String someValue;

    public SomeClass(String someValue) {
        this.someValue = someValue;
    }

    public String getSomeValue() {
        return someValue;
    }
}

Serializing an instance with a value:

ObjectMapper mapper = new ObjectMapper();

String json = mapper.writeValueAsString(new SomeClass("available"));
System.out.println(json);

Output:

{"someValue":"available"}

Serializing an instance whose field is :

Consider this complete example:

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;

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

        SomeClass withValue = new SomeClass("active");
        SomeClass withoutValue = new SomeClass(null);

        System.out.println(mapper.writeValueAsString(withValue));
        System.out.println(mapper.writeValueAsString(withoutValue));
    }

    static class SomeClass {
        @JsonInclude(JsonInclude.Include.NON_NULL)
        private final String someValue;

        SomeClass(String someValue) {
            this.someValue = someValue;
        }

        public String getSomeValue() {
             someValue;
        }
    }
}

• REST API responses: Do not send optional profile fields such as middleName or avatarUrl when no value exists.
• Database-backed services: Database columns that are NULL can be omitted from response JSON when that matches the API contract.
• Partial data integrations: An external provider may not supply all details; your response can include only known values.
• Event payloads: Keep messages smaller by leaving out unused optional metadata.
• Configuration endpoints: Return only settings that have been explicitly configured.

In projects, developers choose the scope of null exclusion based on the API design.

One optional property

Annotate the individual field or getter:

@JsonInclude(JsonInclude.Include.NON_NULL)
private String avatarUrl;

This is best when most properties should retain their normal behavior but one property is optional.

All properties in one DTO

Annotate the class:

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class UserResponse {
    private String id;
    private String displayName;
    private String avatarUrl;
}

This is common for response DTOs, where many fields are optional.

All serialized objects

Configure the shared ObjectMapper:

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;

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

Using the wrong annotation

@JsonIgnore always excludes a property. It does not include it again when a value is present.

@JsonIgnore
private String someValue;

With @JsonIgnore, someValue is never serialized, including when it contains "hello".

Use this instead:

@JsonInclude(JsonInclude.Include.NON_NULL)
private String someValue;

Expecting NON_NULL to remove empty strings

An empty string is not null:

new SomeClass("");

With NON_NULL, Jackson produces:

{"someValue":""}

If you also need to omit empty strings, normalize input before serialization or use a custom serializer when appropriate.

import com.fasterxml.jackson.annotation.JsonInclude;

Omit one null field

@JsonInclude(JsonInclude.Include.NON_NULL)
private String someValue;

Omit null properties for a class

@JsonInclude(JsonInclude.Include.NON_NULL)
public class ApiResponse {
    // fields
}

Omit null properties globally

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

Spring Boot default

spring.jackson.default-property-inclusion=non_null

Key rules

• NON_NULL omits only null values.
• "" and [] are not null.
• Use NON_EMPTY to omit empty strings and empty collections too.

How do I ignore null values in Jackson?

Annotate the field, getter, or class with @JsonInclude(JsonInclude.Include.NON_NULL).

Does @JsonInclude(NON_NULL) hide a field with a real value?

No. Jackson serializes the property normally when its value is non-null.

What is the difference between NON_NULL and NON_EMPTY?

NON_NULL excludes only null. NON_EMPTY also excludes empty strings, empty collections, and empty arrays.

Can I configure Jackson to ignore nulls for every class?

Yes. Configure the shared ObjectMapper with setSerializationInclusion(JsonInclude.Include.NON_NULL), or set Spring Boot's spring.jackson.default-property-inclusion=non_null property.

Does this annotation affect JSON deserialization?

Its purpose is controlling inclusion during serialization. It does not prevent incoming JSON null values from being deserialized into a Java property.

Should an API omit nulls or return null values?

Follow the API contract. Omission is useful for optional data, while explicit null can be useful when clients need to distinguish “known to be empty” from “not provided.”

• Jackson ObjectMapper — The main object used to serialize Java objects and configure serialization behavior.
• JSON serialization and deserialization — The conversion between Java objects and JSON text.
• @JsonIgnore — Hides a property completely rather than only when it is null.
• @JsonProperty — Controls a JSON property's name and access behavior.
• Data transfer objects (DTOs) — Response-specific classes where inclusion rules are commonly defined.
• Spring Boot Jackson configuration — Lets an application set default JSON behavior through configuration files.