Comment dire à Jackson d'ignorer un champ lors de la sérialisation si sa valeur est nulle?

Comment Jackson peut-il être configuré pour ignorer une valeur de champ pendant la sérialisation si la valeur de ce champ est nulle.

Par exemple:

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; 
}

Pour supprimer les propriétés de sérialisation avec des valeurs nulles à l'aide de Jackson> 2.0, vous pouvez configurer ObjectMapperdirectement ou utiliser l' @JsonIncludeannotation:

mapper.setSerializationInclusion(Include.NON_NULL);

ou:

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

Alternativement, vous pouvez utiliser @JsonIncludedans un getter afin que l'attribut soit affiché si la valeur n'est pas nulle.

Un exemple plus complet est disponible dans ma réponse à Comment empêcher les valeurs nulles à l'intérieur d'une carte et les champs null à l'intérieur d'un bean d'être sérialisés via Jackson .

Avec Jackson> 1.9.11 et <2.x, utilisez l' @JsonSerializeannotation pour ce faire:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL)

Juste pour développer les autres réponses - si vous devez contrôler l'omission des valeurs nulles sur une base par champ, annotez le champ en question (ou annotez alternativement le 'getter' du champ).

exemple - ici seulement fieldOnesera omis de json s'il est nul. fieldTwosera toujours inclus, qu'il soit nul ou non.

public class Foo {

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

    private String fieldTwo;
}

Pour omettre toutes les valeurs nulles de la classe par défaut, annotez la classe. Les annotations par champ / getter peuvent toujours être utilisées pour remplacer cette valeur par défaut si nécessaire.

exemple - ici fieldOneet fieldTwoseront supprimés de json s'ils sont respectivement nuls, car il s'agit de la valeur par défaut définie par l'annotation de classe. fieldThreecependant, remplacera la valeur par défaut et sera toujours inclus, en raison de l'annotation sur le champ.

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

    private String fieldOne;

    private String fieldTwo;

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

MISE À JOUR

Ce qui précède est pour Jackson 2 . Pour les versions antérieures de Jackson, vous devez utiliser:

@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL) 

au lieu de

@JsonInclude(JsonInclude.Include.NON_NULL)

Si cette mise à jour est utile, veuillez noter la réponse de ZiglioUK ci-dessous, elle a souligné la nouvelle annotation Jackson 2 bien avant de mettre à jour ma réponse pour l'utiliser!

Dans Jackson 2.x, utilisez:

@JsonInclude(JsonInclude.Include.NON_NULL)

Vous pouvez utiliser la configuration de mappeur suivante:

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

Depuis 2.5, vous pouvez utiliser:

mapper.setSerializationInclusion(Include.NON_NULL);

Vous pouvez définir 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

dans mon cas

@JsonInclude(Include.NON_EMPTY)

l'a fait fonctionner.

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

devrait marcher.

Include.NON_EMPTYindique que la propriété est sérialisée si sa valeur n'est pas nulle et non vide. Include.NON_NULLindique que la propriété est sérialisée si sa valeur n'est pas nulle.

Si vous souhaitez ajouter cette règle à tous les modèles de Jackson 2.6+, utilisez:

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

Si dans Spring Boot , vous pouvez personnaliser le jackson ObjectMapperdirectement via les fichiers de propriétés.

Exemple application.yml:

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

Les valeurs possibles sont:

always|non_null|non_absent|non_default|non_empty

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

Cela fonctionnera dans Spring boot 2.0.3+ et Jackson 2.0+

import com.fasterxml.jackson.annotation.JsonInclude;

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

Pour Jackson 2.5, utilisez:

@JsonInclude(content=Include.NON_NULL)

Cela me préoccupe depuis un certain temps et j'ai finalement trouvé le problème. Le problème était dû à une mauvaise importation. Plus tôt, j'utilisais

com.fasterxml.jackson.databind.annotation.JsonSerialize

Qui avait été déprécié. Remplacez simplement l'importation par

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

et l'utiliser comme

@JsonSerialize(include=Inclusion.NON_NULL)

Configuration globale si vous utilisez 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 vous essayez de sérialiser une liste d'objets et que l'un d'eux est nul, vous finirez par inclure l'élément nul dans le JSON même avec

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

aura pour résultat:

[{myObject},null]

pour obtenir ceci:

[{myObject}]

on peut faire quelque chose comme:

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

CONSEIL: Si vous utilisez DropWizard, vous pouvez récupérer celui ObjectMapperutilisé par Jersey en utilisantenvironment.getObjectMapper()

Nous avons beaucoup de réponses à cette question. Cette réponse peut être utile dans certains scénarios. Si vous souhaitez ignorer les valeurs nulles, vous pouvez utiliser NOT_NULL au niveau de la classe. comme ci-dessous

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

Parfois, vous devrez peut-être ignorer les valeurs vides telles que vous avez peut-être initialisé le arrayList, mais il n'y a aucun élément dans cette liste.

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

Jackson 2.x + utilisation

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

De plus, vous devez changer votre approche lorsque vous utilisez Map myVariable comme décrit dans la documentation pour éliminer les valeurs Null:

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

Premier cas

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

Deuxième cas

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

Si someStringest nul, il sera ignoré dans les deux cas. SisomeString est "", il ne sera ignoré que dans le deuxième cas.

La même chose pour List = nullouList.size() = 0