Cómo especificar jackson para usar solo campos, preferiblemente globalmente

El comportamiento de jackon predeterminado parece utilizar tanto propiedades (getters y setters) como campos para serializar y deserializar a json.

Me gustaría usar los campos como la fuente canónica de la configuración de serialización y, por lo tanto, no quiero que Jackson vea las propiedades en absoluto.

Puedo hacer esto en una clase individual con la anotación:

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

Pero no quiero tener que poner esto en cada clase ...

¿Es posible configurar esto globalmente? ¿Te gusta agregar algunos al Object Mapper?

Puede configurar ObjectMappers individuales de esta manera:

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 desea establecerlo globalmente, generalmente accedo a un asignador configurado a través de una clase de contenedor.

En Jackson 2.0 y versiones posteriores, simplemente puede usar:

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

para desactivar la autodetección.

Específicamente para boolean is*()captadores:

He dedicado mucho tiempo a por qué ni a continuación

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

ni esto

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

trabajé para mi Boolean Getter / Setter.

La solución es simple:

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

ACTUALIZACIÓN: spring-boot permitió configurarlo:

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

Ver Propiedades de aplicación comunes # JACKSON

para jackson 1.9.10 yo uso

ObjectMapper mapper = new ObjectMapper();

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

a la vuelta de autodedection.

¿Qué tal esto? Lo usé con un mixin

objeto no 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 {}

Uso:

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

No hay nada que diga que no se puede predecir cualquier cantidad de clases y aplicar el mismo mixin.

Si no está familiarizado con mixins, son conceptualmente simple: La estructura del mixin se impuso súper en la clase de objetivo (de acuerdo con Jackson, no en lo que se refiere a la JVM).

Si desea una manera de hacer esto globalmente sin preocuparse por la configuración de su ObjectMapper, puede crear su propia anotación:

@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 {
}

¡Ahora solo tienes que anotar tus clases @JsonExplicity listo!

También asegúrese de editar la llamada anterior para @JsonAutoDetectasegurarse de tener los valores establecidos para lo que funciona con su programa.

Gracias a https://stackoverflow.com/a/13408807 por ayudarme a conocer@JacksonAnnotationsInside

Si usa Spring Boot, puede configurar Jackson globalmente de la siguiente manera:

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

}