Éviter la sérialisation de Jackson sur les objets paresseux non récupérés

à partir du printemps 4.2 et en utilisant la botte de printemps et javaconfig, enregistrer le Hibernate4Module est maintenant aussi simple que de l'ajouter à votre configuration:

@Bean
public Module datatypeHibernateModule() {
  return new Hibernate4Module();
}

réf: https://spring.io/blog/2014/12/02/latest-jackson-integration-improvements-in-spring

c'est similaire à la solution acceptée par @rick.

si vous ne voulez pas toucher à la configuration existante des convertisseurs de messages, Vous pouvez simplement déclarer un Jackson2ObjectMapperBuilder bean like:

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

n'oubliez pas d'ajouter la dépendance suivante à votre fichier Gradle (ou Maven):

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

utile si vous avez un spring-boot application et vous voulez garder la possibilité de modifier Jackson caractéristiques du fichier application.properties .

dans le cas de données de printemps reste alors, alors que la solution Postée par @r1ckr fonctionne, tout ce qui est nécessaire est d'ajouter une des dépendances suivantes en fonction de votre version D'hibernation:

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-hibernate4</artifactId>
    <version>${jackson.version}</version>
</dependency>

ou

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-hibernate5</artifactId>
    <version>${jackson.version}</version>
</dependency>

dans le repos de données de printemps il y a une classe:

org.springframework.data.rest.webmvc.json.Jackson2DatatypeHelper

qui détectera automatiquement et enregistrera le Module au démarrage de l'application.

Il y a cependant un problème:

Problème De Sérialisation Paresseux @ManyToOne

si vous utilisez XML config et utilisez <annotation-driven /> , j'ai trouvé que vous devez faire un nid <message-converters> à l'intérieur de <annotation-driven> comme recommandé sur le compte Jackson 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>

`

pour ceux qui sont venus ici à la recherche de la solution pour le service RESTful basé sur Apache CXF, la configuration qui le corrige est ci-dessous:

<jaxrs:providers>
    <bean class="com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider">
        <property name="mapper" ref="objectMapper"/>
    </bean>
</jaxrs:providers>

<bean id="objectMapper" class="path.to.your.HibernateAwareObjectMapper"/>

où HibernateAwareObjectMapper est défini comme:

public class HibernateAwareObjectMapper extends ObjectMapper {
    public HibernateAwareObjectMapper() {
        registerModule(new Hibernate5Module());
    }
}

la dépendance suivante est requise à partir de juin 2016 (à condition que vous utilisiez Hibernate5):

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

vous pouvez utiliser l'aide suivante du projet Spring Data Rest:

Jackson2DatatypeHelper.configureObjectMapper(objectMapper);

j'ai essayé la réponse utile de @rick's , mais j'ai rencontré le problème que les" modules bien connus "tels que jackson-datatype-jsr310 n'étaient pas automatiquement enregistrés alors qu'ils étaient sur le chemin de classe. (Ce post de blog explique l'auto-inscription.)

en prolongeant la réponse de @rick's, voici une variation utilisant le Jackson2ObjectMapperBuilder "151950920 de Spring pour créer le ObjectMapper . Cela enregistre automatiquement les" modules bien connus "et définit certaines fonctionnalités en plus de l'installation du 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);
    }
}

bien que cette question soit légèrement différente de celle-ci : Exception Jackson étrange étant lancé lors de la sérialisation de L'objet Hibernate , le problème sous-jacent peut être corrigé de la même manière avec ce code:

@Provider
public class MyJacksonJsonProvider extends JacksonJsonProvider {
    public MyJacksonJsonProvider() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        setMapper(mapper);
    }
}

j'ai essayé et j'ai 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 mapper:

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