Como dizer ao Jackson para ignorar um campo durante a serialização se seu valor for nulo?

Como Jackson pode ser configurado para ignorar um valor de campo durante a serialização, se o valor desse campo for nulo.

Por exemplo:

public class SomeClass {
   // what jackson annotation causes jackson to skip over this value if it is null but will 
   // serialize it otherwise 
   private String someValue; 
}

Para suprimir propriedades de serialização com valores nulos usando Jackson> 2.0, você pode configurar ObjectMapperdiretamente ou fazer uso da @JsonIncludeanotação:

mapper.setSerializationInclusion(Include.NON_NULL);

ou:

@JsonInclude(Include.NON_NULL)
class Foo
{
  String bar;
}

Como alternativa, você pode usar @JsonIncludeem um getter para que o atributo seja mostrado se o valor não for nulo.

Um exemplo mais completo está disponível na minha resposta para Como impedir que valores nulos dentro de um mapa e campos nulos dentro de um bean sejam serializados através de Jackson .

Com Jackson> 1.9.11 e <2.x, use a @JsonSerializeanotação para fazer isso:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL)

Apenas para expandir as outras respostas - se você precisar controlar a omissão de valores nulos em uma base por campo, anote o campo em questão (ou, em alternativa, anote o 'getter' do campo).

exemplo - aqui somente fieldOneserá omitido do json se for nulo. fieldTwosempre será incluído, independentemente de ser nulo.

public class Foo {

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

    private String fieldTwo;
}

Para omitir todos os valores nulos na classe como padrão, anote a classe. As anotações por campo / obturador ainda podem ser usadas para substituir esse padrão, se necessário.

exemplo - aqui fieldOnee fieldTwoserá omitido de json se eles forem nulos, respectivamente, porque esse é o padrão definido pela anotação de classe. fieldThreeno entanto, substituirá o padrão e sempre será incluído, devido à anotação no campo.

@JsonInclude(JsonInclude.Include.NON_NULL)
public class Foo {

    private String fieldOne;

    private String fieldTwo;

    @JsonInclude(JsonInclude.Include.ALWAYS)
    private String fieldThree;
}

ATUALIZAR

O acima é para Jackson 2 . Para versões anteriores do Jackson, você precisa usar:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL) 

ao invés de

@JsonInclude(JsonInclude.Include.NON_NULL)

Se essa atualização for útil, faça o upvote da resposta do ZiglioUK abaixo, ela apontou a anotação mais recente do Jackson 2 muito antes de eu atualizar minha resposta para usá-la!

No Jackson 2.x, use:

@JsonInclude(JsonInclude.Include.NON_NULL)

Você pode usar a seguinte configuração do mapeador:

mapper.getSerializationConfig().setSerializationInclusion(Inclusion.NON_NULL);

Desde o 2.5, você pode usar:

mapper.setSerializationInclusion(Include.NON_NULL);

Você pode definir application.properties:

spring.jackson.default-property-inclusion=non_null

ou application.yaml:

spring:
  jackson:
    default-property-inclusion: non_null

http://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

No meu caso

@JsonInclude(Include.NON_EMPTY)

fez funcionar.

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonInclude(JsonInclude.Include.NON_EMPTY)

Deveria trabalhar.

Include.NON_EMPTYindica que a propriedade é serializada se seu valor não for nulo e não estiver vazio. Include.NON_NULLindica que a propriedade é serializada se seu valor não for nulo.

Se você deseja adicionar esta regra a todos os modelos no Jackson 2.6+, use:

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

Se no Spring Boot , você pode personalizar o jackson ObjectMapperdiretamente através dos arquivos de propriedades.

Exemplo application.yml:

spring:
  jackson:
    default-property-inclusion: non_null # only include props if non-null

Os valores possíveis são:

always|non_null|non_absent|non_default|non_empty

Mais: https://docs.spring.io/spring-boot/docs/current/reference/html/howto-spring-mvc.html#howto-customize-the-jackson-objectmapper

Isso funcionará nas inicializações Spring 2.0.3+ e Jackson 2.0+

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class ApiDTO
{
    // your class variable and 
    // methods
}

Para o Jackson 2.5, use:

@JsonInclude(content=Include.NON_NULL)

Isso está me incomodando há algum tempo e finalmente encontrei o problema. O problema ocorreu devido a uma importação incorreta. Antes eu estava usando

com.fasterxml.jackson.databind.annotation.JsonSerialize

O qual foi preterido. Basta substituir a importação por

import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;

e use-o como

@JsonSerialize(include=Inclusion.NON_NULL)

Configuração global se você usar o Spring

@Configuration
public class JsonConfigurations {

    @Bean
    public Jackson2ObjectMapperBuilder objectMapperBuilder() {
        Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
        builder.serializationInclusion(JsonInclude.Include.NON_NULL);
        builder.serializationInclusion(JsonInclude.Include.NON_EMPTY);
        builder.failOnUnknownProperties(false);
        return builder;
    }

}

Se você estiver tentando serializar uma lista de objetos e um deles for nulo, você acabará incluindo o item nulo no JSON, mesmo com

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

vai resultar em:

[{myObject},null]

para conseguir esta:

[{myObject}]

pode-se fazer algo como:

mapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
        @Override
        public void serialize(Object obj, JsonGenerator jsonGen, SerializerProvider unused)
                throws IOException
        {
            //IGNORES NULL VALUES!
        }
    });

DICA: Se você estiver usando o DropWizard, poderá recuperar o que ObjectMapperestá sendo usado por Jersey usandoenvironment.getObjectMapper()

Temos muitas respostas para essa pergunta. Esta resposta pode ser útil em alguns cenários. Se você deseja ignorar os valores nulos, pode usar o NOT_NULL no nível da classe. como abaixo

@JsonInclude(Include.NON_NULL)
class Foo
{
  String bar;
}

Às vezes, você pode precisar ignorar os valores vazios, como você pode ter inicializado o arrayList, mas não há elementos nessa lista. Nesse período, usando a anotação NOT_EMPTY para ignorar esses campos de valores vazios

@JsonInclude(Include.NON_EMPTY)
class Foo
{
  String bar;
}

Jackson 2.x + use

mapper.getSerializationConfig().withSerializationInclusion(JsonInclude.Include.NON_NULL);

Além disso, você deve alterar sua abordagem ao usar o Map myVariable, conforme descrito na documentação para eliminar nulos:

From documentation:
com.fasterxml.jackson.annotation.JsonInclude

@JacksonAnnotation
@Target(value={ANNOTATION_TYPE, FIELD, METHOD, PARAMETER, TYPE})
@Retention(value=RUNTIME)
Annotation used to indicate when value of the annotated property (when used for a field, method or constructor parameter), or all properties of the annotated class, is to be serialized. Without annotation property values are always included, but by using this annotation one can specify simple exclusion rules to reduce amount of properties to write out.

*Note that the main inclusion criteria (one annotated with value) is checked on Java object level, for the annotated type, and NOT on JSON output -- so even with Include.NON_NULL it is possible that JSON null values are output, if object reference in question is not `null`. An example is java.util.concurrent.atomic.AtomicReference instance constructed to reference null value: such a value would be serialized as JSON null, and not filtered out.

To base inclusion on value of contained value(s), you will typically also need to specify content() annotation; for example, specifying only value as Include.NON_EMPTY for a {link java.util.Map} would exclude Maps with no values, but would include Maps with `null` values. To exclude Map with only `null` value, you would use both annotations like so:
public class Bean {
   @JsonInclude(value=Include.NON_EMPTY, content=Include.NON_NULL)
   public Map<String,String> entries;
}

Similarly you could Maps that only contain "empty" elements, or "non-default" values (see Include.NON_EMPTY and Include.NON_DEFAULT for more details).
In addition to `Map`s, `content` concept is also supported for referential types (like java.util.concurrent.atomic.AtomicReference). Note that `content` is NOT currently (as of Jackson 2.9) supported for arrays or java.util.Collections, but supported may be added in future versions.
Since:
2.0

Caso um

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

Caso dois

@JsonInclude(JsonInclude.Include.NON_EMPTY)
private String someString;

Se someStringfor nulo, será ignorado nos dois casos. Se someStringestiver "", apenas será ignorado no caso dois.

O mesmo para List = nullouList.size() = 0