Printemps, Jackson et la Personnalisation (par exemple CustomDeserializer)

Être encore un peu familier avec le Printemps, j'ai rencontré un problème qui rend nécessaire la mise en œuvre de mes personnalisé deserialzer pour Jackson. La procédure est décrite dans un petit tutoriel, cependant, je suis coincé avec le Printemps. Je ne comprends pas, où

 ObjectMapper mapper = new ObjectMapper();

dans Spring MVC est effectué lors de l'json est désérialise par une méthode de la classe du contrôleur. Donc je ne sais pas, quoi faire pour remplacer la valeur par défaut deserializer par un deserialiser.

Toutes les suggestions que la plupart de bienvenue.

InformationsquelleAutor Ta Sas | 2010-08-28

19

Vous ne dites pas comment vous utilisez Jackson au Printemps, donc je vais supposer que vous êtes à l'utiliser via <mvc:annotation-driven/> et la @RequestBody et/ou @ResponseBody annotations.

L'une des choses que <mvc:annotation-driven/> n'est à enregistrer un AnnotationMethodHandlerAdapter bean qui est livré avec un certain nombre de pré-configuré HttpMessageConverter haricots, y compris MappingJacksonHttpMessageConverter, qui s'occupe de l'ordonnancement et de Jackson-modèle annoté classes.

Maintenant MappingJacksonHttpMessageConverter a un setObjectMapper() méthode, qui permet de remplacer la valeur par défaut ObjectMapper. Mais depuis MappingJacksonHttpMessageConverter est créé en coulisses par <mvc:annotation-driven/>, vous ne pouvez pas l'obtenir.

Cependant, <mvc:annotation-driven/> est juste un moyen pratique de raccourci. C'est tout aussi valable pour déclarer votre propre AnnotationMethodHandlerAdapter bean, injecter votre propre MappingJacksonHttpMessageConverter bean (via le messageConverters de la propriété), et l'injection de votre propre personnalisé ObjectMapper dans que.

Vous avez alors le problème de savoir comment construire une coutume ObjectMapper, car elle n'est pas très Printemps-amicale de la classe. Je suggère la rédaction de votre propre simple de mise en œuvre de interface factorybean.

Donc, si vous voulez retrouver avec quelque chose comme ceci:
```
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
   <property name="messageConverters">
      <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
         <property name="objectMapper">
            <bean class="com.x.MyObjectMapperFactoryBean"/>
         </property>
      </bean>
   </property>
</bean>
```
InformationsquelleAutor skaffman

Nouvelle façon de faire de ce Printemps 3.1:

http://magicmonster.com/kb/prg/java/spring/webmvc/mvc_spring_config_namespace.html

http://blog.springsource.org/2011/02/21/spring-3-1-m1-mvc-namespace-enhancements-and-configuration/

Vous permet de faire quelque chose comme ceci:

<mvc:annotation-driven>
      <mvc:message-converters>
          <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
              <property name="objectMapper" ref="customObjectMapper"/>
          </bean>
      </mvc:message-converters>
  </mvc:annotation-driven>

InformationsquelleAutor Ryan Walls

La solution référencé par Rakesh susceptibles fonctionne avec Spring MVC 3.0 mais avec 3,1 certains de la MVC de l'infrastructure a changé. En conséquence, vous ne pouvez pas avoir un AnnotationMethodHandlerAdapter bean enregistré dans votre contexte de l'application et vous vous retrouverez avec un BeanCreationException pendant la phase d'initialisation.

Pour Spring MVC 3.1 la mvc:annotation-driven élément va créer un RequestMappingHandlerAdapter pour vous, alors vous devriez autowire ce type à la place. Il sera toujours fournir un accès à la liste des HttpMessageConverters et vous permettent de définir le ObjectMapper bien sur la MappingJacksonHttpMessageConverter. Cela nécessite aussi un léger changement dans le init. méthode pour le type de la HttpMessageConverters de référence.

La mise à jour de classe ressemble à:

@Component
public class JacksonFix {
    private RequestMappingHandlerAdapter requestMappingHandlerAdapter;
    private CustomObjectMapper objectMapper;

    @PostConstruct
    public void init() {
        List<HttpMessageConverter<?>> messageConverters = requestMappingHandlerAdapter.getMessageConverters();
        for (HttpMessageConverter<?> messageConverter : messageConverters) {
            if (messageConverter instanceof MappingJacksonHttpMessageConverter) {
                MappingJacksonHttpMessageConverter m = (MappingJacksonHttpMessageConverter) messageConverter;
                m.setObjectMapper(objectMapper);
            }
        }
    }

    //this will exist due to the <mvc:annotation-driven/> bean
    @Autowired
    public void setRequestMappingHandlerAdapter(RequestMappingHandlerAdapter requestMappingHandlerAdapter) {
        this.requestMappingHandlerAdapter = requestMappingHandlerAdapter;
    }

    @Autowired
    public void setObjectMapper(CustomObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }
}

Mise à JOUR: Il s'avère absolue de la chose la plus facile à faire avec Printemps 3.1 est d'ajouter une configuration supplémentaire pour votre MVC configuration:

<mvc:annotation-driven conversion-service="applicationConversionService">
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
            <property name="objectMapper" ref="customObjectMapper" />
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

Qui va ajouter une nouvelle instance de MappingJacksonHttpMessageConverter avec la coutume ObjectMapper avant tout de la valeur par défaut HttpMessageConverters (qui sont encore présents en raison de register-defaults="true").

InformationsquelleAutor kylesm

Dans mon cas (Printemps 3.2.4 et Jackson 2.3.1), de configuration XML personnalisé sérialiseur:

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="false">
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="serializers">
                        <array>
                            <bean class="com.example.business.serializer.json.CustomObjectSerializer"/>
                        </array>
                    </property>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

était dans inexpliquée façon écrasé par défaut par quelque chose.

Cela a fonctionné pour moi:

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<CustomObject> {

    @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<CustomObject> handledType() {
        return CustomObject.class;
    }
}

Pas de configuration XML (<mvc:message-converters>(...)</mvc:message-converters>) est nécessaire dans ma solution.

InformationsquelleAutor user11153

0

Je souhaite que je savais Spring MVC mieux, mais avec Jax-RS implémentations comme Jersey et RESTeasy, l'un des registres des fournisseurs. Peut-être que le Printemps fait quelque chose de similaire?

InformationsquelleAutor StaxMan
0

Le printemps docs pour MappingJacksonHttpMessageConverter état:

2.4.5 MappingJacksonHttpMessageConverter

Un HttpMessageConverter de mise en œuvre qui peut lire et écrire JSON à l'aide de Jackson JSON du Processeur ObjectMapper. JSON cartographie peut être personnalisée en tant que de besoin par le biais de l'utilisation de Jackson a fourni des annotations. Lorsque plus de contrôle est nécessaire, une coutume ObjectMapper peut être injecté dans le ObjectMapper propriété pour les cas où JSON personnalisé sérialiseurs/deserializers doivent être fournis pour des types spécifiques. Par défaut, ce convertisseur prend en charge (application/json).

Ne pourriez-vous autowire l'accès à la ObjectMapper afin de modifier son comportement?

InformationsquelleAutor Bruce Edge

Vous devez vous connecter pour publier un commentaire.