Comment spécifier Jackson pour n'utiliser que des champs - de préférence globalement

Le comportement de jackon par défaut semble utiliser à la fois les propriétés (getters et setters) et les champs pour sérialiser et désérialiser en json.

Je voudrais utiliser les champs comme source canonique de la configuration de sérialisation et je ne veux donc pas que Jackson regarde du tout les propriétés.

Je peux le faire sur une base de classe individuelle avec l'annotation:

 @JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, setterVisibility = Visibility.NONE)

Mais je ne veux pas avoir à mettre ça sur chaque classe ...

Est-il possible de configurer cela globalement? Vous aimez en ajouter à l'Object Mapper?

Vous pouvez configurer des ObjectMappers individuels comme ceci:

ObjectMapper mapper  = new ObjectMapper();
mapper.setVisibility(mapper.getSerializationConfig().getDefaultVisibilityChecker()
                .withFieldVisibility(JsonAutoDetect.Visibility.ANY)
                .withGetterVisibility(JsonAutoDetect.Visibility.NONE)
                .withSetterVisibility(JsonAutoDetect.Visibility.NONE)
                .withCreatorVisibility(JsonAutoDetect.Visibility.NONE));

Si vous voulez qu'il soit défini globalement, j'accède généralement à un mappeur configuré via une classe wrapper.

Dans Jackson 2.0 et versions ultérieures, vous pouvez simplement utiliser:

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;   

...

ObjectMapper mapper = new ObjectMapper();    
mapper.setVisibility(PropertyAccessor.ALL, Visibility.NONE);
mapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);

pour désactiver la détection automatique.

Spécifiquement pour les boolean is*()getters:

J'ai passé beaucoup de temps sur pourquoi ni en dessous

  @JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, setterVisibility = Visibility.NONE)

ni ça

  setVisibility(PropertyAccessor.SETTER, JsonAutoDetect.Visibility.NONE);
  setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.NONE);
  setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);

a travaillé pour mon Boolean Getter / Setter.

La solution est simple:

  @JsonAutoDetect(isGetterVisibility = Visibility.NONE, ...          
  setVisibility(PropertyAccessor.IS_GETTER, JsonAutoDetect.Visibility.NONE);

MISE À JOUR: spring-boot autorisé le configurer:

jackson:
  visibility.field: any
  visibility.getter: none
  visibility.setter: none
  visibility.is-getter: none

Voir les propriétés d'application communes # JACKSON

pour jackson 1.9.10 j'utilise

ObjectMapper mapper = new ObjectMapper();

mapper.setVisibility(JsonMethod.ALL, Visibility.NONE);
mapper.setVisibility(JsonMethod.FIELD, Visibility.ANY);

pour désactiver la déduction automatique.

Que diriez-vous de ceci: je l'ai utilisé avec un mixin

objet non conforme

@Entity
@Getter
@NoArgsConstructor
public class Telemetry {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long pk;
    private String id;
    private String organizationId;
    private String baseType;
    private String name;
    private Double lat;
    private Double lon;
    private Instant updateTimestamp;
}

Mixin:

@JsonAutoDetect(fieldVisibility = ANY, getterVisibility = NONE, setterVisibility = NONE)
public static class TelemetryMixin {}

Usage:

    ObjectMapper om = objectMapper.addMixIn(Telemetry.class, TelemetryMixin.class);
    Telemetry[] telemetries = om.readValue(someJson, Telemetry[].class);

Il n'y a rien qui dit que vous ne pouvez pas foreach un certain nombre de classes et appliquer le même mixin.

Si vous n'êtes pas familier avec les mixins, ils sont conceptuellement simples: la structure du mixin est superposée à la classe cible (selon jackson, pas en ce qui concerne la JVM).

Si vous souhaitez un moyen de le faire globalement sans vous soucier de la configuration de votre ObjectMapper, vous pouvez créer votre propre annotation:

@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonAutoDetect(
        getterVisibility = JsonAutoDetect.Visibility.NONE, isGetterVisibility = JsonAutoDetect.Visibility.NONE,
        setterVisibility = JsonAutoDetect.Visibility.NONE, fieldVisibility = JsonAutoDetect.Visibility.NONE,
        creatorVisibility = JsonAutoDetect.Visibility.NONE
)
public @interface JsonExplicit {
}

Il ne vous reste plus qu'à annoter vos cours avec @JsonExplicitet vous êtes prêt à partir!

Assurez-vous également de modifier l'appel ci-dessus pour @JsonAutoDetectvous assurer que les valeurs sont définies sur ce qui fonctionne avec votre programme.

Merci à https://stackoverflow.com/a/13408807 pour m'avoir aidé à en savoir plus@JacksonAnnotationsInside

Si vous utilisez Spring Boot, vous pouvez configurer Jackson globalement comme suit:

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;

@Configuration
public class JacksonObjectMapperConfiguration implements Jackson2ObjectMapperBuilderCustomizer {

    @Override
    public void customize(Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder) {
        jacksonObjectMapperBuilder.visibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE);
        jacksonObjectMapperBuilder.visibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
        jacksonObjectMapperBuilder.visibility(PropertyAccessor.CREATOR, JsonAutoDetect.Visibility.ANY);
    }

}