Configurazione di ObjectMapper in spring

il mio objective è configurare objectMapper nel modo in cui serializza solo gli elementi annotati con @JsonProperty .

Per fare ciò ho seguito questa spiegazione che dice come configurare objectmapper.

Ho incluso l’objectmapper personalizzato come descritto qui .

Tuttavia, quando la class NumbersOfNewEvents è serializzata, contiene ancora tutti gli attributi in json.

Qualcuno ha un suggerimento? Grazie in anticipo

Jackson 1.8.0 spring 3.0.5

CustomObjectMapper

 public class CompanyObjectMapper extends ObjectMapper { public CompanyObjectMapper() { super(); setVisibilityChecker(getSerializationConfig() .getDefaultVisibilityChecker() .withCreatorVisibility(JsonAutoDetect.Visibility.NONE) .withFieldVisibility(JsonAutoDetect.Visibility.NONE) .withGetterVisibility(JsonAutoDetect.Visibility.NONE) .withIsGetterVisibility(JsonAutoDetect.Visibility.NONE) .withSetterVisibility(JsonAutoDetect.Visibility.DEFAULT)); } } 

servlet.xml

                

NumbersOfNewEvents

 public class NumbersOfNewEvents implements StatusAttribute { public Integer newAccepts; public Integer openRequests; public NumbersOfNewEvents() { super(); } } 

Usando Spring Boot (1.2.4) e Jackson (2.4.6) la seguente configurazione basata su annotazioni ha funzionato per me.

 @Configuration public class JacksonConfiguration { @Bean public ObjectMapper objectMapper() { ObjectMapper mapper = new ObjectMapper(); mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); mapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, true); return mapper; } } 

Può essere perché sto usando Spring 3.1 (invece di Spring 3.0.5 come specificato nella tua domanda), ma la risposta di Steve Eastwood non ha funzionato per me. Questa soluzione funziona per Spring 3.1:

Nel tuo contesto xml primaverile:

           

Ho usato questo con Jackson 2.x e Spring 3.1.2+

servlet-context.xml:

Si noti che l’elemento root è , quindi potrebbe essere necessario rimuovere i beans e aggiungere mvc ad alcuni di questi elementi a seconda della configurazione.

            

au.edu.unimelb.atcom.transfer.json.mappers.JSONMapper.java:

 public class JSONMapper extends ObjectMapper { public JSONMapper() { SimpleModule module = new SimpleModule("JSONModule", new Version(2, 0, 0, null, null, null)); module.addSerializer(Date.class, new DateSerializer()); module.addDeserializer(Date.class, new DateDeserializer()); // Add more here ... registerModule(module); } } 

DateSerializer.java:

 public class DateSerializer extends StdSerializer { public DateSerializer() { super(Date.class); } @Override public void serialize(Date date, JsonGenerator json, SerializerProvider provider) throws IOException, JsonGenerationException { // The client side will handle presentation, we just want it accurate DateFormat df = StdDateFormat.getBlueprintISO8601Format(); String out = df.format(date); json.writeString(out); } } 

DateDeserializer.java:

 public class DateDeserializer extends StdDeserializer { public DateDeserializer() { super(Date.class); } @Override public Date deserialize(JsonParser json, DeserializationContext context) throws IOException, JsonProcessingException { try { DateFormat df = StdDateFormat.getBlueprintISO8601Format(); return df.parse(json.getText()); } catch (ParseException e) { return null; } } } 

Ho trovato la soluzione ora basata su https://github.com/FasterXML/jackson-module-hibernate

Ho esteso l’object mapper e aggiunto gli attributi nel costruttore ereditato.

Quindi il nuovo object mapper è registrato come bean.

             

C’è org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean per un lungo periodo di tempo. A partire dalla versione 1.2 di Spring Boot, org.springframework.http.converter.json.Jackson2ObjectMapperBuilder per Java Config.

In String Boot la configurazione può essere semplice come:

 spring.jackson.deserialization.=true|false spring.jackson.generator.=true|false spring.jackson.mapper.=true|false spring.jackson.parser.=true|false spring.jackson.serialization.=true|false spring.jackson.default-property-inclusion=always|non_null|non_absent|non_default|non_empty 

in classpath:application.properties o qualche codice Java nella class @Configuration :

 @Bean public Jackson2ObjectMapperBuilder jacksonBuilder() { Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder(); builder.indentOutput(true).dateFormat(new SimpleDateFormat("yyyy-MM-dd")); return builder; } 

Vedere:

Se vuoi aggiungere ObjectMapper personalizzato per la registrazione di serializzatori personalizzati, prova la mia risposta.

Nel mio caso (Spring 3.2.4 e Jackson 2.3.1), configurazione XML per serializzatore personalizzato:

                

era in modo inspiegabile sovrascritto di default da qualcosa.

Questo ha funzionato per me:

CustomObject.java

 @JsonSerialize(using = CustomObjectSerializer.class) public class CustomObject { private Long value; public Long getValue() { return value; } public void setValue(Long value) { this.value = value; } } 

CustomObjectSerializer.java

 public class CustomObjectSerializer extends JsonSerializer { @Override public void serialize(CustomObject value, JsonGenerator jgen, SerializerProvider provider) throws IOException,JsonProcessingException { jgen.writeStartObject(); jgen.writeNumberField("y", value.getValue()); jgen.writeEndObject(); } @Override public Class handledType() { return CustomObject.class; } } 

Nessuna configurazione XML ( (...) ) è necessaria nella mia soluzione.

Sto usando Spring 4.1.6 e Jackson FasterXML 2.1.4.

              

questo funziona con la mia confessione di applicationContext.xml

Sto usando Spring 3.2.4 e Jackson FasterXML 2.1.1.

Ho creato un JacksonObjectMapper personalizzato che funziona con annotazioni esplicite per ogni attributo degli oggetti mappati:

 package com.test; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializationFeature; public class MyJaxbJacksonObjectMapper extends ObjectMapper { public MyJaxbJacksonObjectMapper() { this.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY) .setVisibility(PropertyAccessor.CREATOR, JsonAutoDetect.Visibility.ANY) .setVisibility(PropertyAccessor.SETTER, JsonAutoDetect.Visibility.NONE) .setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.NONE) .setVisibility(PropertyAccessor.IS_GETTER, JsonAutoDetect.Visibility.NONE); this.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false); } } 

Quindi questo viene istanziato nella configurazione del contesto ( servlet-context.xml ):

          

Funziona bene!

Al di sopra della spring 4, non è necessario configurare MappingJacksonHttpMessageConverter se si intende solo configurare ObjectMapper .

(configurare MappingJacksonHttpMessageConverter ti farà perdere altri MessageConverter)

Devi solo fare:

 public class MyObjectMapper extends ObjectMapper { private static final long serialVersionUID = 4219938065516862637L; public MyObjectMapper() { super(); enable(SerializationFeature.INDENT_OUTPUT); } } 

E nella configurazione di Spring, crea questo bean:

 @Bean public MyObjectMapper myObjectMapper() { return new MyObjectMapper(); } 

Per configurare un convertitore di messaggi in spring-web semplice, in questo caso per abilitare JavaTimeModule Java 8 JSR-310, è necessario prima implementare WebMvcConfigurer nella class @Configuration e quindi eseguire l’override del metodo configureMessageConverters :

 @Override public void configureMessageConverters(List> converters) { ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().modules(new JavaTimeModule(), new Jdk8Module()).build() .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); converters.add(new MappingJackson2HttpMessageConverter(objectMapper)); } 

In questo modo è ansible registrare qualsiasi ObjectMapper personalizzato in una configurazione Spring basata su Java.