Configurando ObjectMapper en Spring

mi objective es configurar objectMapper de la misma forma que solo serializa los elementos que están anotados con @JsonProperty .

Para hacerlo, seguí esta explicación que dice cómo configurar el ObjectMapper.

Incluí el ObjectMapper personalizado como se describe aquí .

Sin embargo, cuando la clase NumbersOfNewEvents está serializada, todavía contiene todos los atributos en el json.

¿Alguien tiene una pista? Gracias por adelantado

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) y Jackson (2.4.6), la siguiente configuración basada en anotaciones funcionó para mí.

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

Puede ser porque utilizo Spring 3.1 (en lugar de Spring 3.0.5 como se especifica su pregunta), pero la respuesta de Steve Eastwood no funcionó para mí. Esta solución funciona para Spring 3.1:

En su contexto de spring xml:

           

Lo he usado con Jackson 2.x y Spring 3.1.2+

servlet-context.xml:

Tenga en cuenta que el elemento raíz es , por lo que es posible que deba eliminar beans y agregar mvc a algunos de estos elementos, según su configuración.

            

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

Encontré la solución ahora basada en https://github.com/FasterXML/jackson-module-hibernate

Extendí el mapeador de objetos y agregué los atributos en el constructor heredado.

Entonces el nuevo mapeador de objetos se registra como un bean.

             

Hay org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean durante mucho tiempo. A partir de la versión 1.2 de Spring Boot, se encuentra org.springframework.http.converter.json.Jackson2ObjectMapperBuilder for Java Config.

En la configuración de arranque de cadena puede ser tan simple como:

 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 

en classpath:application.properties o algún código de Java en la clase @Configuration :

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

Ver:

Si desea agregar ObjectMapper personalizado para registrar serializadores personalizados, intente con mi respuesta.

En mi caso (Spring 3.2.4 y Jackson 2.3.1), configuración XML para el serializador personalizado:

                

fue de forma inexplicable sobrescrito de nuevo al valor predeterminado por algo.

Esto funcionó para mí:

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

No se necesita ninguna configuración XML ( (...) ) en mi solución.

Estoy usando Spring 4.1.6 y Jackson FasterXML 2.1.4.

              

esto funciona en mi configuración applicationContext.xml

Estoy usando Spring 3.2.4 y Jackson FasterXML 2.1.1.

Creé un JacksonObjectMapper personalizado que funciona con anotaciones explícitas para cada atributo de los objetos asignados:

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

A continuación, se crea una instancia en la configuración de contexto ( servlet-context.xml ):

          

Esto funciona bien!

Por encima de Spring 4, no es necesario configurar MappingJacksonHttpMessageConverter si solo tiene la intención de configurar ObjectMapper .

(configure MappingJacksonHttpMessageConverter hará que pierda otro MessageConverter)

Solo tienes que hacer:

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

Y en su configuración de Spring, cree este bean:

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

Para configurar un convertidor de mensajes en web spring simple, en este caso para habilitar JavaT JSR-310 JavaTimeModule, primero necesita implementar WebMvcConfigurer en su clase @Configuration y luego anular el método 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)); } 

De esta manera, puede registrar cualquier ObjectMapper personalizado en una configuración de Spring basada en Java.