गैर-प्राप्त आलसी वस्तुओं पर जैक्सन क्रमांकन से बचें

Question 1

मेरे पास एक साधारण नियंत्रक है जो एक उपयोगकर्ता ऑब्जेक्ट को लौटाता है, इस उपयोगकर्ता के पास एक विशेषता निर्देशांक है जिसमें हाइबरनेट संपत्ति FetchType.AZY है।

जब मैं इस उपयोगकर्ता को प्राप्त करने की कोशिश करता हूं, तो मुझे उपयोगकर्ता ऑब्जेक्ट प्राप्त करने के लिए हमेशा सभी निर्देशांक लोड करने होते हैं, अन्यथा जब जैक्सन उपयोगकर्ता को क्रमबद्ध करने की कोशिश करता है तो अपवाद को फेंकता है:

com.fasterxml.jackson.databind.JsonMappingException: प्रॉक्सी को प्रारंभ नहीं कर सका - कोई सत्र नहीं

यह जैक्सन के कारण इस अधूरे ऑब्जेक्ट को लाने की कोशिश कर रहा है। यहाँ वस्तुएं हैं:

public class User{

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
    @JsonManagedReference("user-coordinate")
    private List<Coordinate> coordinates;
}

public class Coordinate {

    @ManyToOne
    @JoinColumn(name = "user_id", nullable = false)
    @JsonBackReference("user-coordinate")
    private User user;
}

और नियंत्रक:

@RequestMapping(value = "/user/{username}", method=RequestMethod.GET)
public @ResponseBody User getUser(@PathVariable String username) {

    User user = userService.getUser(username);

    return user;

}

जैक्सन को यह बताने का एक तरीका है कि अनफ़िट की गई वस्तुओं को अनुक्रमित न करें? मैं 3 साल पहले पोस्ट किए गए अन्य उत्तरों को देख रहा हूं जो जैकसन-हाइबरनेट-मॉड्यूल को लागू कर रहे हैं। लेकिन शायद इसे एक नए जैकसन फीचर के साथ हासिल किया जा सकता है।

मेरे संस्करण हैं:

वसंत 3.2.5
हाइबरनेट 4.1.7
जैक्सन 2.2

अग्रिम में धन्यवाद।

Question 2

मैं अंत में हल मिल गया! मुझे एक सुराग देने के लिए indybee का धन्यवाद।

ट्यूटोरियल स्प्रिंग 3.1, हाइबरनेट 4 और जैक्सन-मॉड्यूल-हाइबरनेट में स्प्रिंग 3.1 और पुराने संस्करणों का अच्छा समाधान है। लेकिन संस्करण 3.1.2 के बाद से वसंत का अपना MappingJackson2HttpMessageConverter ट्यूटोरियल में लगभग एक ही कार्यक्षमता के साथ है, इसलिए हमें इस कस्टम HTTPMessageConverter बनाने की आवश्यकता नहीं है।

Javaconfig के साथ हमें एक HibernateAwareObjectMapper भी बनाने की आवश्यकता नहीं है, हमें बस डिफ़ॉल्ट MappingJackson2HttpMessage.onverter के लिए Hibernate4Module को जोड़ने की आवश्यकता है जो कि स्प्रिंग के पास पहले से ही है और इसे HttpMessageConverters के अनुप्रयोग में शामिल करना है, इसलिए हमें इसकी आवश्यकता है

WebMvcConfigurerAdapter से हमारी स्प्रिंग कॉन्‍फ़िगरेशन क्लास बढ़ाएँ और विधि कॉन्‍फ़िगरेशन को हटाएं ।
उस पद्धति पर एक प्रीविअस विधि में पंजीकृत Hibernate4Module के साथ MappingJackson2HttpMessageConverter जोड़ें ।

हमारे विन्यास वर्ग को इस तरह दिखना चाहिए:

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

यदि आपके पास एक xml कॉन्फ़िगरेशन है, तो आपको अपना MappingJackson2HttpMessageConverter बनाने की आवश्यकता नहीं है, लेकिन आपको ट्यूटोरियल (HibernateAwareOjectMapper) में दिखाई देने वाले व्यक्तिगत मैपर बनाने की आवश्यकता है, इसलिए आपका xml कॉन्फ़िगरेशन इस तरह दिखना चाहिए:

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

आशा है कि यह उत्तर समझने योग्य होगा और किसी को इस समस्या का समाधान खोजने में मदद करेगा, कोई भी प्रश्न पूछने के लिए स्वतंत्र है!

Question 3

स्प्रिंग 4.2 के रूप में और स्प्रिंग बूट और javaconfig का उपयोग करते हुए, Hibernate4Module को पंजीकृत करना अब आपके कॉन्फ़िगरेशन में इसे जोड़ने के रूप में सरल है:

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

रेफरी: https://spring.io/blog/2014/12/02/latest-jackson-integration-improvements-in-spring

Question 4

यह @rick द्वारा स्वीकृत समाधान के समान है।

यदि आप मौजूदा संदेश कन्वर्टर्स कॉन्फ़िगरेशन को स्पर्श नहीं करना चाहते हैं, तो आप बस Jackson2ObjectMapperBuilderसेम की घोषणा कर सकते हैं:

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

अपनी ग्रेड फ़ाइल (या मावेन) के लिए निम्नलिखित निर्भरता जोड़ना न भूलें:

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

यदि आपके पास उपयोगी है वसंत-बूटआवेदन और आप application.propertiesफ़ाइल से जैक्सन सुविधाओं को संशोधित करने की क्षमता रखना चाहते हैं ।

Question 5

स्प्रिंग डेटा रेस्ट के मामले में, जब @ r1ckr द्वारा पोस्ट किया गया समाधान काम करता है, तो यह आवश्यक है कि आपके हाइबरनेट संस्करण के आधार पर निम्नलिखित निर्भरताओं में से एक को जोड़ा जाए:

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

या

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

स्प्रिंग डेटा रेस्ट के भीतर एक वर्ग है:

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

जो ऑटो स्टार्ट-अप का पता लगाएगा और आवेदन स्टार्ट-अप पर मॉड्यूल पंजीकृत करेगा।

हालांकि एक मुद्दा है:

अंक जारी करना आलसी @ManyToOne

Question 6

यदि आप XML कॉन्फिगरेशन का उपयोग करते हैं और उपयोग करते हैं <annotation-driven />, तो मैंने पाया कि आपको जैक्सन जीथब खाते पर अनुशंसित अनुसार <message-converters>अंदर घोंसला बनाना होगा<annotation-driven> ।

इस तरह:

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

`

Question 7

जो लोग अपाचे सीएक्सएफ-आधारित रैस्टफुल सेवा का समाधान खोजने के लिए यहां आए थे, उनके लिए इसे ठीक करने वाला कॉन्फ़िगरेशन निम्न है:

<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"/>

HibernateAwareObjectMapper को कहां परिभाषित किया गया है:

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

जून 2016 तक निम्नलिखित निर्भरता आवश्यक है (बशर्ते आप हाइबरनेट 5 का उपयोग कर रहे हों):

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

Question 8

निम्नलिखित समाधान स्प्रिंग 4.3, (गैर-बूट) और हाइबरनेट 5.1 के लिए है, जहां हमने प्रदर्शन कारणों के fetch=FetchType.LAZYमामलों से सभी भ्रूणों को संक्रमित किया fetch=FetchType.EAGERहै। तुरंत हमने देखाcom.fasterxml.jackson.databind.JsonMappingException: could not initialize proxy आलसी लोड मुद्दे के कारण अपवाद को ।

सबसे पहले, हम निम्नलिखित मावेन निर्भरता को जोड़ते हैं:

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

फिर निम्नलिखित हमारे जावा MVC कॉन्फ़िगरेशन फ़ाइल में जोड़ा जाता है:

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

टिप्पणियाँ:

इस मॉड्यूल के बिना जैक्सन के समान व्यवहार प्राप्त करने के लिए आपको Hibernate5Module बनाने और कॉन्फ़िगर करने की आवश्यकता है। डिफ़ॉल्ट असंगत धारणाएं बनाता है।
हमारे WebMvcConfigurerAdapterपास इसमें बहुत सारे अन्य कॉन्फ़िगरेशन हैं और हम एक और कॉन्फ़िगरेशन क्लास से बचना चाहते थे, यही वजह है कि हमने WebMvcConfigurationSupport#addDefaultHttpMessageConvertersअन्य पोस्ट पर संदर्भित फ़ंक्शन का उपयोग नहीं किया ।
WebMvcConfigurerAdapter#configureMessageConvertersसंदेश कन्वर्टर्स के सभी स्प्रिंग के आंतरिक कॉन्फ़िगरेशन को अक्षम करता है। हमने इसके आसपास के संभावित मुद्दों से बचने को प्राथमिकता दी।
extendMessageConvertersअन्य सभी संदेश कन्वर्टर्स के कॉन्फ़िगरेशन को खोए बिना सभी स्वचालित रूप से कॉन्फ़िगर किए गए जैक्सन वर्गों तक सक्षम पहुंच का उपयोग करना ।
उपयोग करके getObjectMapper#registerModuleहम Hibernate5Moduleमौजूदा कन्वर्टर्स को जोड़ने में सक्षम थे ।
मॉड्यूल JSON और XML प्रोसेसर दोनों के लिए जोड़ा गया था

इस जोड़ ने हाइबरनेट और आलसी लोडिंग के साथ समस्या को हल किया लेकिन जेनसन प्रारूप के साथ एक अवशिष्ट समस्या का कारण बना । जैसा कि इस गितुब मुद्दे में बताया गया है , हाइबरनेट-जैकसन आलसी लोड मॉड्यूल वर्तमान में @JsonUnwrapped एनोटेशन को अनदेखा करता है, जिससे संभावित डेटा त्रुटियां होती हैं। यह बल-लोडिंग सुविधा सेटिंग की परवाह किए बिना होता है। यह समस्या 2016 से है।

ध्यान दें

ऐसा प्रतीत होता है कि निम्न-वर्गों को जोड़कर जो आलसी-लोडेड हैं, बिल्ट-इन ऑब्जेक्टमैपर हाइबरनेट 5 मॉड्यूल को जोड़े बिना काम करता है:

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

Question 9

आप स्प्रिंग डेटा रेस्ट प्रोजेक्ट से निम्न सहायक का उपयोग कर सकते हैं:

Jackson2DatatypeHelper.configureObjectMapper(objectMapper);

Question 10

मैंने इस समस्या का बहुत ही सरल समाधान किया।

@JsonInclude(JsonInclude.Include.NON_EMPTY)
public Set<Pendency> getPendencies() {
    return Hibernate.isInitialized(this.pendencies) ? Collections.unmodifiableSet(this.pendencies) : new HashSet<>();
}

मेरे मामले में मैं त्रुटि दे रहा था क्योंकि जब भी मैं एक पेंडेंसी वापस कर रहा था, एक अच्छे अभ्यास के रूप में मैंने इसे एक सूची में बदल दिया जिसे संशोधित नहीं किया जा सकता है, लेकिन जिस तरह से मैं उदाहरण प्राप्त करता था, उसके आधार पर यह आलसी हो सकता है या नहीं। (भ्रूण के साथ या बिना), मैं हाइबरनेट द्वारा आरंभ करने से पहले एक परीक्षण करता हूं और एनोटेशन को जोड़ता हूं जो एक खाली संपत्ति को अनुक्रमित करने से रोकता है और इससे मेरी समस्या हल हो गई।

Question 11

मैंने उसी समस्या को हल करने के लिए पूरा दिन बिताया है। आप इसे मौजूदा संदेश कन्वर्टर्स कॉन्फ़िगरेशन को बदलने के बिना कर सकते हैं।

मेरी राय में इस समस्या को हल करने का सबसे आसान तरीका केवल 2 चरणों में जैकसन-डेटाटाइप-हाइबरनेट की मदद से है :

कोटलिन उदाहरण (जावा के समान):

इसमें जोड़ें build.gradle.kts:

implementation("com.fasterxml.jackson.datatype:jackson-datatype-hibernate5:$jacksonHibernate")

सृजन करना @Bean

   @Bean
   fun hibernate5Module(): Module = Hibernate5Module()

नोटिस जो Moduleहै com.fasterxml.jackson.databind.Module, नहींjava.util.Module
इसके अलावा अच्छा अभ्यास जोड़ने के लिए है @JsonBackReferenceऔर @JsonManagedReferenceकरने के लिए @OneToManyऔर @ManyToOneरिश्ते। @JsonBackReferenceकक्षा में केवल 1 हो सकता है।

Question 12

हालांकि यह सवाल इस एक से थोड़ा अलग है: अजीब जैक्सन अपवाद को फेंक दिया जा रहा है जब हाइबरनेट ऑब्जेक्ट को क्रमबद्ध करते हुए , अंतर्निहित समस्या को इस कोड के साथ उसी तरह से तय किया जा सकता है:

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

Question 13

मैंने यह कोशिश की, और काम किया:

// आलसी लोडिंग के लिए कस्टम कॉन्फ़िगरेशन

public static class HibernateLazyInitializerSerializer extends JsonSerializer<JavassistLazyInitializer> {

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

और मैपर कॉन्फ़िगर करें:

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

Question 14

वसंत बूट के लिए एक और समाधान: विन्यास: spring.jpa.open-in-view=true

Question 15

मैंने @ रिक के उपयोगी उत्तर की कोशिश की , लेकिन इस समस्या में भाग गया कि "जाने-माने मॉड्यूल" जैसे कि जैकसन-डेटाटाइप-जेएसआर 310 अपने आप को क्लासपाथ पर होने के बावजूद पंजीकृत नहीं किया गया था। (यह ब्लॉग पोस्ट ऑटो-पंजीकरण की व्याख्या करता है।)

@ रिक के जवाब पर विस्तार करते हुए, यहां स्प्रिंग की जैक्सन 2 एक्सबजेक्टमॅपरबर्ल का उपयोग करके भिन्नता बनाई गई है ObjectMapper। यह ऑटो "जाने-माने मॉड्यूल" को पंजीकृत करता है और स्थापित करने के अलावा कुछ खास सुविधाएं भी देता है 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()
                            .modulesToInstall(hibernate4Module());
        return new MappingJackson2HttpMessageConverter(builder.build());
  }

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