Éviter Jackson sérialisation non récupérés paresseux objets

J'ai enfin trouvé la solution! grâce à indybee pour me donner une idée.

Le tutoriel Printemps 3.1, Hibernate 4 et Jackson-Module-Hibernate une bonne solution pour le Printemps 3.1 et versions antérieures. Mais depuis la version 3.1.2 de Printemps ont son propre MappingJackson2HttpMessageConverter avec presque les mêmes fonctionnalités que celui du tutoriel, nous n'avons pas besoin de créer cette coutume HTTPMessageConverter.

Avec javaconfig nous n'avons pas besoin de créer un HibernateAwareObjectMapper trop, nous avons juste besoin d'ajouter le Hibernate4Module à la valeur par défaut MappingJackson2HttpMessageConverter que le Printemps et l'ajouter à la HttpMessageConverters de l'application, nous avons donc besoin de:

1. Étendre notre printemps config classe de WebMvcConfigurerAdapter et remplacer la méthode configureMessageConverters.

2. Sur la méthode ajouter le MappingJackson2HttpMessageConverter avec le Hibernate4Module inscrit dans un previus méthode.

Notre config de classe devrait ressembler à ceci:

@Configuration
@EnableWebMvc
public class MyConfigClass extends WebMvcConfigurerAdapter{

    //More configuration....

    /* Here we register the Hibernate4Module into an ObjectMapper, then set this custom-configured ObjectMapper
     * to the MessageConverter and return it to be added to the HttpMessageConverters of our application*/
    public MappingJackson2HttpMessageConverter jacksonMessageConverter(){
        MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();

        ObjectMapper mapper = new ObjectMapper();
        //Registering Hibernate4Module to support lazy objects
        mapper.registerModule(new Hibernate4Module());

        messageConverter.setObjectMapper(mapper);
        return messageConverter;

    }

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        //Here we add our custom-configured HttpMessageConverter
        converters.add(jacksonMessageConverter());
        super.configureMessageConverters(converters);
    }

    //More configuration....
}

Si vous avez un fichier xml de configuration, vous n'avez pas besoin de créer votre propre MappingJackson2HttpMessageConverter soit, mais vous avez besoin de créer l'personnalisé mappeur qui apparaît dans le tutoriel (HibernateAwareObjectMapper), de sorte que votre configuration xml devrait ressembler à ceci:

<mvc:message-converters>
    <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <property name="objectMapper">
            <bean class="com.pastelstudios.json.HibernateAwareObjectMapper" />
        </property>
    </bean>
</mvc:message-converters>

Espère que cette réponse soit compréhensible et aider quelqu'un à trouver la solution à ce problème, des questions n'hésitez pas à demander!

Ceci est similaire à la solution retenue par @rick.

Si vous ne voulez pas toucher message existant convertisseurs de configuration, vous pouvez simplement déclarer un Jackson2ObjectMapperBuilder bean comme:

@Bean
public Jackson2ObjectMapperBuilder configureObjectMapper() {
    return new Jackson2ObjectMapperBuilder()
        .modulesToInstall(Hibernate4Module.class);
}

Ne pas oublier d'ajouter la dépendance suivant à votre Gradle fichier (ou Maven):

compile 'com.fasterxml.jackson.datatype:jackson-datatype-hibernate4:2.4.4'

Utile si vous avez un spring-boot de l'application et que vous souhaitez garder la possibilité de modifier Jackson caractéristiques de application.properties fichier.

Si vous utilisez XML de configuration et d'utilisation <annotation-driven />, j'ai trouvé que vous avez à nid <message-converters> à l'intérieur de <annotation-driven> comme recommandé sur le Jackson compte Github.

Comme suit:

<annotation-driven>
  <message-converters>
    <beans:bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
      <beans:property name="objectMapper">
        <beans:bean class="com.pastelstudios.json.HibernateAwareObjectMapper" />
      </beans:property>
    </beans:bean> 
  </message-converters>
</annotation-driven>

`

La solution suivante est pour le Printemps 4.3, (non-démarrage) & Hibernate 5.1 où nous avons passé tous les fetchtypes à fetch=FetchType.LAZY de cas de fetch=FetchType.EAGER pour des raisons de performances. Immédiatement, nous avons vu la com.fasterxml.jackson.databind.JsonMappingException: could not initialize proxy exception en raison de la charge paresseux question.

Tout d'abord, on ajoute ce qui suit maven dependency:

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-hibernate5</artifactId>
</dependency>  

Puis le suivant est ajouté à notre Java MVC fichier de configuration:

@Configuration
@EnableWebMvc 
public class MvcConfig extends WebMvcConfigurerAdapter {

@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {

    Hibernate5Module h5module = new Hibernate5Module();
    h5module.disable(Hibernate5Module.Feature.USE_TRANSIENT_ANNOTATION);
    h5module.enable(Hibernate5Module.Feature.FORCE_LAZY_LOADING);

    for (HttpMessageConverter<?> mc : converters){
        if (mc instanceof MappingJackson2HttpMessageConverter || mc instanceof MappingJackson2XmlHttpMessageConverter) {
            ((AbstractJackson2HttpMessageConverter) mc).getObjectMapper().registerModule(h5module);
        }
    }
    return;
}

Notes:

• Vous avez besoin pour créer et configurer la Hibernate5Module pour obtenir un comportement similaire à Jackson sans ce module. La valeur par défaut rend incompatible hypothèses.

• Notre WebMvcConfigurerAdapter a beaucoup d'autres configuration et nous voulions éviter une autre configuration de la classe, c'est pourquoi nous n'avons pas utilisé la WebMvcConfigurationSupport#addDefaultHttpMessageConverters fonction qui a été évoqué sur d'autres postes.

• WebMvcConfigurerAdapter#configureMessageConverters désactive tous de Printemps de la configuration interne de message convertisseurs. Nous avons préféré éviter les problèmes potentiels autour de ce.

• À l'aide de extendMessageConverters activé l'accès à tous les automatiquement configuré Jackson classes sans perdre la configuration de tous les autres message convertisseurs.

• À l'aide de getObjectMapper#registerModule nous avons été en mesure d'ajouter le Hibernate5Module existant pour les convertisseurs.

• Le module a été ajouté à l'JSON et XML processeurs

Cet ajout a résolu le problème avec Hibernate et le chargement paresseux, mais a entraîné une résiduelle problème avec le format JSON généré. Comme indiqué dans cette question github, la mise en veille prolongée-jackson lazy load module actuellement ignore l' @JsonUnwrapped annotation, menant à d'éventuelles erreurs de données. Cela se produit indépendamment de la force de chargement de paramètre de fonction. Le problème a été là depuis de 2016.

Note

Il semble que, par adjonction, à des classes qui sont paresseux-chargé, le haut-ObjectMapper fonctionne sans l'ajout de la hibernate5 module:

@JsonIgnoreProperties(  {"handler","hibernateLazyInitializer"} )
public class Anyclass {

J'ai essayé @rick réponse utile, mais a couru dans le problème que "bien connus des modules" comme jackson-type de données-jsr310 n'étaient pas automatiquement inscrits malgré eux d'être dans le classpath. (Ce post de blog explique l'auto-enregistrement.)

Expansion sur @la réponse de rick, voici une variation à l'aide du Printemps Jackson2ObjectMapperBuilder pour créer le ObjectMapper. Cette auto-inscrit le "bien connu des modules" et définit certaines caractéristiques, en plus de l'installation de la Hibernate4Module.

@Configuration
@EnableWebMvc
public class MyWebConfig extends WebMvcConfigurerAdapter {

    //get a configured Hibernate4Module
    //here as an example with a disabled USE_TRANSIENT_ANNOTATION feature
    private Hibernate4Module hibernate4Module() {
        return new Hibernate4Module().disable(Hibernate4Module.Feature.USE_TRANSIENT_ANNOTATION);
    }

    //create the ObjectMapper with Spring's Jackson2ObjectMapperBuilder
    //and passing the hibernate4Module to modulesToInstall()
    private MappingJackson2HttpMessageConverter jacksonMessageConverter(){
        Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder()
            .featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
            .modulesToInstall(hibernate4Module());
        return new MappingJackson2HttpMessageConverter(builder.build());
  }

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(jacksonMessageConverter());
        super.configureMessageConverters(converters);
    }
}

J'ai essayé cela, et a travaillé:

//configuration personnalisée pour le chargement paresseux

public static class HibernateLazyInitializerSerializer extends JsonSerializer<JavassistLazyInitializer> {

    @Override
    public void serialize(JavassistLazyInitializer initializer, JsonGenerator jsonGenerator,
            SerializerProvider serializerProvider)
            throws IOException, JsonProcessingException {
        jsonGenerator.writeNull();
    }
}

et configurer mappeur:

    mapper = new JacksonMapper();
    SimpleModule simpleModule = new SimpleModule(
            "SimpleModule", new Version(1,0,0,null)
    );
    simpleModule.addSerializer(
            JavassistLazyInitializer.class,
            new HibernateLazyInitializerSerializer()
    );
    mapper.registerModule(simpleModule);