Comment dire à Jackson d'ignorer un champ lors de la sérialisation si sa valeur est null?
Comment Jackson peut-il être configuré pour ignorer une valeur de champ pendant la sérialisation si la valeur de ce champ est null.
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 la sérialisation des propriétés avec des valeurs NULL à l'aide de Jackson> 2.0, vous pouvez configurer directement le ObjectMapper , ou utiliser le @JsonInclude :
_mapper.setSerializationInclusion(Include.NON_NULL);
_ou:
_@JsonInclude(Include.NON_NULL)
class Foo
{
String bar;
}
_Vous pouvez également utiliser _@JsonInclude_ dans un getter afin que l'attribut soit affiché si la valeur n'est pas null.
Un exemple plus complet est disponible dans ma réponse à Comment empêcher les valeurs NULL dans une Carte et les champs NULL dans un bean de se sérialiser via Jackson .
Avec Jackson> 1.9.11 et <2.x, utilisez l'annotation @JsonSerialize pour le faire:
@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL)
Juste pour développer les autres réponses - si vous devez contrôler l'omission de valeurs nulles pour chaque champ, annotez le champ en question (ou annotez le "getter" du champ).
exemple - ici seulement fieldOne sera ignoré de json s'il est nul. fieldTwo sera 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 NULL dans la classe par défaut, annotez la classe. Les annotations par champ/getter peuvent toujours être utilisées pour remplacer ce paramètre par défaut si nécessaire.
exemple - ici fieldOne et fieldTwo seront exclus de json s'ils sont nuls, respectivement, car il s'agit de la valeur par défaut définie par l'annotation de la classe. fieldThree va toutefois remplacer la valeur par défaut et sera toujours inclus, à cause 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;
}
UPDATE
Ce qui précède est pour Jackson 2. Pour 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 inverser la réponse de ZiglioUK ci-dessous, elle a souligné la nouvelle annotation de Jackson 2 bien avant que je mette à 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 la version 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)
fait le travail.
@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonInclude(JsonInclude.Include.NON_EMPTY)
devrait marcher.
Include.NON_EMPTY indique que la propriété est sérialisée si sa valeur n'est ni nulle ni vide. Include.NON_NULL indique que la propriété est sérialisée si sa valeur n'est pas null.
Si dans Spring Boot , vous pouvez personnaliser le jackson ObjectMapper directement par le biais de 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
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
}
Si vous souhaitez ajouter cette règle à tous les modèles de Jackson 2.6+, utilisez:
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
Pour Jackson 2.5, utilisez:
@JsonInclude(content=Include.NON_NULL)
Si vous essayez de sérialiser une liste d'objets et que l'un d'eux est null, vous finirez par inclure l'élément null dans le JSON même avec
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
aura pour résultat:
[{myObject}, null]
pour obtenir ceci:
[{monObjet}]
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 le ObjectMapper utilisé par Jersey à l’aide de environment.getObjectMapper ().
Cela me trouble depuis un certain temps et j'ai finalement trouvé le problème. Le problème était dû à une mauvaise importation. Plus tôt j'avais utilisé
com.fasterxml.jackson.databind.annotation.JsonSerialize
Ce qui avait été déconseillé. Il suffit de remplacer 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;
}
}
Utilisation de Jackson 2.x +
mapper.getSerializationConfig().withSerializationInclusion(JsonInclude.Include.NON_NULL);
En outre, vous devez modifier votre approche lorsque vous utilisez Map myVariable, comme indiqué dans la documentation, afin d'é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