Spring @ResponseBody Jackson JsonSerializer avec JodaTime

Question

J'ai ci-dessous sérialiseur pour la manutention JodaTime:

public class JodaDateTimeJsonSerializer extends JsonSerializer<DateTime> { 

    private static final String dateFormat = ("MM/dd/yyyy"); 

    @Override 
    public void serialize(DateTime date, JsonGenerator gen, SerializerProvider provider) 
      throws IOException, JsonProcessingException { 

     String formattedDate = DateTimeFormat.forPattern(dateFormat).print(date); 

     gen.writeString(formattedDate); 
    } 

} 

Ensuite, sur chaque objet du modèle, je fais ceci:

@JsonSerialize(using=JodaDateTimeJsonSerializer.class) 
public DateTime getEffectiveDate() { 
    return effectiveDate; 
} 

Avec les paramètres ci-dessus, @ResponseBody et Jackson Mapper fonctionne bien. Cependant, je n'aime pas l'idée où je continue à écrire @JsonSerialize. Ce dont j'ai besoin, c'est d'une solution sans les @JsonSerialize sur les objets modèles. Est-il possible d'écrire cette configuration quelque part au printemps xml en tant que configuration unique?

Appréciez votre aide.

Answer 1

Bien que vous puissiez mettre une annotation pour chaque champ de date, mieux vaut effectuer une configuration globale pour votre mappeur d'objet. Si vous utilisez jackson vous pouvez configurer votre ressort comme suit:

<bean id="jacksonObjectMapper" class="com.company.CustomObjectMapper" /> 

<bean id="jacksonSerializationConfig" class="org.codehaus.jackson.map.SerializationConfig" 
    factory-bean="jacksonObjectMapper" factory-method="getSerializationConfig" > 
</bean> 

Pour CustomObjectMapper:

public class CustomObjectMapper extends ObjectMapper { 

    public CustomObjectMapper() { 
     super(); 
     configure(Feature.WRITE_DATES_AS_TIMESTAMPS, false); 
     setDateFormat(new SimpleDateFormat("EEE MMM dd yyyy HH:mm:ss 'GMT'ZZZ (z)")); 
    } 
} 

Bien sûr, SimpleDateFormat peut utiliser tout format dont vous avez besoin.

Answer 2

Si vous avez simplement les JAR de Jackson sur votre chemin de classe et que vous renvoyez un @ResponseBody, Spring convertira automatiquement l'objet Modèle en JSON. Vous n'avez pas besoin d'annoter quoi que ce soit dans le modèle pour que cela fonctionne.

Answer 3

@Moesio l'a bien compris. Voici ma config:

<!-- Configures the @Controller programming model --> 
<mvc:annotation-driven/> 

<!-- Instantiation of the Default serializer in order to configure it --> 
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapterConfigurer" init-method="init"> 
    <property name="messageConverters"> 
     <list> 
      <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"> 
       <property name="objectMapper" ref="jacksonObjectMapper" /> 
      </bean> 
     </list> 
    </property> 
</bean> 

<bean id="jacksonObjectMapper" class="My Custom ObjectMapper"/> 

<bean id="jacksonSerializationConfig" class="org.codehaus.jackson.map.SerializationConfig" 
    factory-bean="jacksonObjectMapper" factory-method="getSerializationConfig" /> 

Le bit qui m'a est que <mvc:annotation-driven/> fait son propre AnnotationMethodHandler et ne tient pas celui que vous faites manuellement. J'ai eu l'idée BeanPostProcessing de http://scottfrederick.blogspot.com/2011/03/customizing-spring-3-mvcannotation.html pour configurer celle qui est utilisée, et voilà! Fonctionne comme un charme.

Answer 4

Même en utilisant JavaConfig du printemps 3:

@Configuration 
@ComponentScan() 
@EnableWebMvc 
public class WebConfig extends WebMvcConfigurerAdapter 
{ 

    @Override 
    public void configureMessageConverters(final List<HttpMessageConverter<?>> converters) 
    { 
     converters.add(0, jsonConverter()); 
    } 

    @Bean 
    public MappingJacksonHttpMessageConverter jsonConverter() 
    { 
     final MappingJacksonHttpMessageConverter converter = new MappingJacksonHttpMessageConverter(); 
     converter.setObjectMapper(new CustomObjectMapper()); 

     return converter; 
    } 
}