¿Cómo decirle a Jackson que ignore un campo durante la serialización si su valor es nulo?

¿Cómo se puede configurar Jackson para ignorar un valor de campo durante la serialización si el valor de ese campo es nulo?

Por ejemplo:

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 las propiedades de serialización con valores nulos usando Jackson> 2.0, puede configurar ObjectMapperdirectamente o hacer uso de la @JsonIncludeanotación:

mapper.setSerializationInclusion(Include.NON_NULL);

o:

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

Alternativamente, puede usarlo @JsonIncludeen un captador para que el atributo se muestre si el valor no es nulo.

Un ejemplo más completo está disponible en mi respuesta a Cómo evitar que los valores nulos dentro de un Mapa y los campos nulos dentro de un bean se serialicen a través de Jackson .

Con Jackson> 1.9.11 y <2.x use la @JsonSerializeanotación para hacer eso:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL)

Solo para ampliar las otras respuestas: si necesita controlar la omisión de valores nulos por campo, anote el campo en cuestión (o, alternativamente, anote el 'captador' del campo).

ejemplo: aquí solo fieldOnese omitirá de json si es nulo. fieldTwosiempre se incluirá independientemente de si es nulo.

public class Foo {

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

    private String fieldTwo;
}

Para omitir todos los valores nulos en la clase por defecto, anote la clase. Las anotaciones por campo / captador todavía se pueden usar para anular este valor predeterminado si es necesario.

ejemplo: aquí fieldOney fieldTwose omitirá de json si son nulos, respectivamente, porque este es el valor predeterminado establecido por la anotación de clase. fieldThreesin embargo, anulará el valor predeterminado y siempre se incluirá, debido a la anotación en el campo.

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

    private String fieldOne;

    private String fieldTwo;

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

ACTUALIZAR

Lo anterior es para Jackson 2 . Para versiones anteriores de Jackson necesitas usar:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL) 

en vez de

@JsonInclude(JsonInclude.Include.NON_NULL)

Si esta actualización es útil, vota la respuesta de ZiglioUK a continuación, ¡señaló la nueva anotación Jackson 2 mucho antes de que actualizara mi respuesta para usarla!

En Jackson 2.x, use:

@JsonInclude(JsonInclude.Include.NON_NULL)

Puede usar la siguiente configuración del mapeador:

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

Desde 2.5 puedes usar:

mapper.setSerializationInclusion(Include.NON_NULL);

Puedes configurar application.properties:

spring.jackson.default-property-inclusion=non_null

o application.yaml:

spring:
  jackson:
    default-property-inclusion: non_null

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

en mi caso

@JsonInclude(Include.NON_EMPTY)

Lo hizo funcionar.

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

Deberia trabajar.

Include.NON_EMPTYindica que la propiedad se serializa si su valor no es nulo y no está vacío. Include.NON_NULLindica que la propiedad se serializa si su valor no es nulo.

Si desea agregar esta regla a todos los modelos en Jackson 2.6+ use:

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

Si está en Spring Boot , puede personalizar el jackson ObjectMapperdirectamente a través de los archivos de propiedades.

Ejemplo application.yml:

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

Los valores posibles son:

always|non_null|non_absent|non_default|non_empty

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

Esto funcionará en Spring boot 2.0.3+ y Jackson 2.0+

import com.fasterxml.jackson.annotation.JsonInclude;

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

Para Jackson 2.5 use:

@JsonInclude(content=Include.NON_NULL)

Esto me ha estado preocupando durante bastante tiempo y finalmente encontré el problema. El problema se debió a una importación incorrecta. Anteriormente había estado usando

com.fasterxml.jackson.databind.annotation.JsonSerialize

Que había quedado en desuso. Simplemente reemplace la importación por

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

y úsalo como

@JsonSerialize(include=Inclusion.NON_NULL)

Configuración global si usa 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;
    }

}

Si está intentando serializar una lista de objetos y uno de ellos es nulo, terminará incluyendo el elemento nulo en el JSON incluso con

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

resultará en:

[{myObject},null]

para obtener esto:

[{myObject}]

uno puede hacer algo como:

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

SUGERENCIA: si está utilizando DropWizard, puede recuperar el ObjectMapperque Jersey está utilizandoenvironment.getObjectMapper()

Tenemos muchas respuestas a esta pregunta. Esta respuesta puede ser útil en algunos escenarios. Si desea ignorar los valores nulos, puede usar NOT_NULL en el nivel de clase. como a continuación

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

Algunas veces es posible que deba ignorar los valores vacíos, como haber inicializado el arrayList, pero no hay elementos en esa lista. En ese momento, use la anotación NOT_EMPTY para ignorar esos campos de valores vacíos

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

Jackson 2.x + uso

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

Además, debe cambiar su enfoque al usar Map myVariable como se describe en la documentación para eliminar los valores 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 uno

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

Caso dos

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

Si someStringes nulo, se ignorará en ambos casos. SisomeString es "" solo se ignorará en el caso dos.

Lo mismo para List = nulloList.size() = 0