Come specificare jackson per usare solo i campi, preferibilmente a livello globale

Il comportamento del jackon predefinito sembra utilizzare sia proprietà (getter e setter) sia campi per serializzare e deserializzare su json.

Vorrei usare i campi come fonte canonica di configurazione della serializzazione e quindi non voglio che Jackson guardasse le proprietà.

Posso farlo su una classe individuale con l'annotazione:

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

Ma non voglio metterlo su ogni singola classe ...

È possibile configurarlo a livello globale? Ti piace aggiungerne un po 'a Object Mapper?

Puoi configurare singoli ObjectMapper in questo modo:

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

Se vuoi che sia impostato a livello globale, di solito accedo a un mappatore configurato tramite una classe wrapper.

In Jackson 2.0 e versioni successive puoi semplicemente usare:

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

per disattivare il rilevamento automatico.

In particolare per i boolean is*()getter:

Ho trascorso molto tempo sul perché né sotto

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

né questo

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

ha lavorato per il mio Getter / Setter booleano.

La soluzione è semplice:

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

AGGIORNAMENTO: avvio a molla consentito configurarlo:

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

Vedi Proprietà comuni dell'applicazione # JACKSON

per jackson 1.9.10 che uso

ObjectMapper mapper = new ObjectMapper();

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

per disattivare la deduzione automatica.

Che ne dici di questo: l'ho usato con un mixin

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

Uso:

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

Non c'è nulla che dica che non puoi prevedere un numero qualsiasi di classi e applicare lo stesso mixin.

Se non hai familiarità con i mixin, sono concettualmente semplicemente: la struttura del mixin è super imposta alla classe target (secondo Jackson, non per quanto riguarda la JVM).

Se vuoi un modo per farlo a livello globale senza preoccuparti della configurazione del tuo ObjectMapper, puoi creare la tua annotazione:

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

Ora devi solo annotare le tue lezioni @JsonExplicite sei a posto!

Assicurati anche di modificare la chiamata sopra per @JsonAutoDetectassicurarti di avere i valori impostati su ciò che funziona con il tuo programma.

Ringraziamo https://stackoverflow.com/a/13408807 per avermi aiutato a scoprire@JacksonAnnotationsInside

Se usi Spring Boot, puoi configurare Jackson a livello globale come segue:

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

}