जवाबों:
कहते हैं कि आपके पास एक माता-पिता हैं और उस माता-पिता के पास बच्चों का एक संग्रह है। हाइबरनेट अब बच्चों को "आलसी-लोड" कर सकते हैं, जिसका अर्थ है कि माता-पिता को लोड करते समय यह वास्तव में सभी बच्चों को लोड नहीं करता है। इसके बजाय, ऐसा करने का अनुरोध करने पर यह उन्हें लोड करता है। आप या तो यह स्पष्ट रूप से अनुरोध कर सकते हैं, या यह अधिक सामान्य है, हाइबरनेट स्वचालित रूप से उन्हें लोड करेगा जब आप एक बच्चे तक पहुंचने का प्रयास करेंगे।
आलसी-लोडिंग प्रदर्शन को बेहतर बनाने में मदद कर सकता है क्योंकि अक्सर आपको बच्चों की आवश्यकता नहीं होगी और इसलिए उन्हें लोड नहीं किया जाएगा।
इसके अलावा n + 1-समस्या से सावधान रहें। जब आप संग्रह तक पहुँचते हैं तो हाइबरनेट वास्तव में सभी बच्चों को लोड नहीं करेगा। इसके बजाय, यह प्रत्येक बच्चे को व्यक्तिगत रूप से लोड करेगा। संग्रह से अधिक पुनरावृति होने पर, यह प्रत्येक बच्चे के लिए एक प्रश्न का कारण बनता है। इससे बचने के लिए, आप हाइबरनेट को सभी बच्चों को एक साथ लोड करने के लिए ट्रिक कर सकते हैं, जैसे कि parent.getChrenren () साइज़ () कहकर।
"आलसी लोडिंग" का मतलब है कि एक इकाई केवल तभी लोड की जाएगी जब आप वास्तव में इसके लिए इकाई का उपयोग करेंगे पहली बार ।
पैटर्न इस तरह है:
public Entity getEntity() {
if (entity == null) {
entity = loadEntity();
}
return entity;
}यह पहले से ही एक बड़े डेटासेट में सभी संस्थाओं को पहले से लोड करने / प्री लोड करने की लागत को बचाता है जबकि आपको वास्तव में सभी की आवश्यकता नहीं है में इन की है।
हाइबरनेट में, आप आलसी को बाल संस्थाओं के संग्रह को लोड करने के लिए कॉन्फ़िगर कर सकते हैं। वास्तविक आलसी लोड हो रहा है तो के तरीकों के अंदर किया जाता है PersistentSet"फन के तहत" जो हाइबरनेट का उपयोग करता है के रूप में संस्थाओं के संग्रह आवंटित करने के लिए Set।
उदाहरण के लिए
public class Parent {
private Set<Child> children;
public Set<Child> getChildren() {
return children;
}
}।
public void doSomething() {
Set<Child> children = parent.getChildren(); // Still contains nothing.
// Whenever you call one of the following (indirectly),
// Hibernate will start to actually load and fill the set.
children.size();
children.iterator();
}मार्टिन फाउलर ने लाजर लोड पैटर्न को एंटरप्राइज एप्लीकेशन आर्किटेक्चर के पैटर्न में परिभाषित किया है :
एक ऑब्जेक्ट जिसमें आपके ज़रूरी सभी डेटा नहीं होते हैं, लेकिन इसे प्राप्त करना जानते हैं।
इसलिए, जब किसी दिए गए ऑब्जेक्ट को लोड किया जाता है, तो विचार संबंधित वस्तु को लोड करने के लिए उत्सुक नहीं है जिसे आप संबंधित प्रदर्शन लागत को बचाने के लिए तुरंत उपयोग नहीं कर सकते हैं। इसके बजाय, संबंधित वस्तु (ओं) को केवल उपयोग किए जाने पर लोड किया जाएगा।
यह डेटा एक्सेस और हाइबरनेट के लिए विशिष्ट पैटर्न नहीं है, लेकिन यह ऐसे क्षेत्रों में विशेष रूप से उपयोगी है और हाइबरनेट एक-से-कई संघों और एकल-बिंदु संघों (एक-से-एक और कई-से-एक-एक) के आलसी लोडिंग का समर्थन करता है खास शर्तों के अन्तर्गत। हाइबरनेट 3.0 संदर्भ दस्तावेज़ीकरण के अध्याय 19 में आलसी इंटरैक्शन पर अधिक विस्तार से चर्चा की गई है ।
बायडफॉल्ट आलसी लोडिंग सही है। शानदार लोडिंग का मतलब है जब चुनिंदा क्वेरी निष्पादित की जाती है तो यह डेटाबेस को हिट नहीं करेगा। यह गेटटर फ़ंक्शन के लिए प्रतीक्षा करेगा अर्थात जब हमें आवश्यकता होगी, तब यह डेटाबेस से प्राप्त होगा। उदाहरण के लिए: आप एक माता-पिता हैं जिनके पास बहुत सारे खिलौनों के साथ एक बच्चा है। लेकिन वर्तमान मुद्दा यह है कि जब भी आप उसे बुलाते हैं (हम मान लेते हैं कि आपका एक लड़का है), तो वह अपने सभी खिलौनों के साथ आपके पास आता है। अब यह एक मुद्दा है क्योंकि आप उसे हर समय अपने खिलौनों के आसपास नहीं ले जाना चाहते हैं। इसलिए औचित्यपूर्ण माता-पिता होने के नाते, आप आगे बढ़ते हैं और बच्चे के खिलौने को LAZY के रूप में परिभाषित करते हैं। अब जब भी आप उसे बुलाते हैं, वह सिर्फ आपके खिलौने के बिना आपके पास आता है।
आलसी लाने का निर्णय माता-पिता वस्तु को लोड करते समय बाल वस्तुओं को लोड करना है या नहीं। आपको मूल वर्ग की संबंधित हाइबरनेट मैपिंग फ़ाइल इस सेटिंग को करने की आवश्यकता है।
Lazy = true(मतलब बच्चे को लोड नहीं करना) डिफ़ॉल्ट रूप से बच्चे की वस्तुओं का आलसी लोडिंग सच है।
यह सुनिश्चित करें कि चाइल्ड ऑब्जेक्ट्स को तब तक लोड नहीं किया जाता है जब तक कि उन्हें अभिभावक getChild()को कॉल करने की विधि द्वारा आवेदन में स्पष्ट रूप से आमंत्रित नहीं किया जाता है। इस मामले में हाइबरनेट बच्चे को लोड करने के लिए एक ताज़ा डेटाबेस कॉल जारी करता है जब getChild()एक्टुल को पेरेंट ऑब्जेक्ट पर कॉल किया जाता है।
लेकिन कुछ मामलों में आपको माता-पिता के लोड होने पर बच्चे की वस्तुओं को लोड करने की आवश्यकता होती है। बस आलसी = झूठे और हाइबरनेट करें जब बच्चे को माता-पिता को डेटाबेस से लोड किया जाएगा।
उदाहरण: यदि आपके पास एक टेबल है? कर्मचारी ऑब्जेक्ट के लिए मैप किए गए और पता ऑब्जेक्ट्स का सेट है। अभिभावक वर्ग: कर्मचारी वर्ग, बाल वर्ग: पता वर्ग
public class Employee {
private Set address = new HashSet(); // contains set of child Address objects
public Set getAddress () {
return address;
}
public void setAddresss(Set address) {
this. address = address;
}
} Employee.hbm.xml फ़ाइल में
<set name="address" inverse="true" cascade="delete" lazy="false">
<key column="a_id" />
<one-to-many class="beans Address"/>
</set> उपरोक्त विन्यास में। यदि lazy="false": - जब आप कर्मचारी ऑब्जेक्ट लोड करते हैं तो उस समय चाइल्ड ऑब्जेक्ट एड्रेस भी लोड हो जाता है और सेटएड्रेस () विधि पर सेट हो जाता है। यदि आप कर्मचारी को कॉल करते हैं। Adress () तो डेटा लौटाया जाता है। ताजा डेटाबेस कॉल नहीं।
यदि lazy="true": - यह डिफ़ॉल्ट कॉन्फ़िगरेशन है। यदि आप उल्लेख नहीं करते हैं तो हाइबरनेट को आलसी = सत्य मानते हैं। जब आप कर्मचारी वस्तु को लोड करते हैं उस समय बच्चे की वस्तु एड्रेस लोड नहीं होती है। पता ऑब्जेक्ट प्राप्त करने के लिए आपको डेटा बेस पर अतिरिक्त कॉल की आवश्यकता है। यदि आप कॉल करते हैं employee.getAdress()तो उस समय डेटाबेस क्वेरी फायर करती है और परिणाम लौटाती है। ताजा डेटाबेस कॉल।
आम आदमी की भाषा में, यह ऐसा है जैसे आप एक केक बना रहे हैं और आपको फ्रिज से 5-10 सामग्री की आवश्यकता होगी। आपके पास दो विकल्प हैं, फ्रिज से सभी सामग्री प्राप्त करें और इसे अपने किचन प्लेटफॉर्म पर रखें, या अपनी ज़रूरत के अनुसार आइटम लाएँ।
इसी तरह, उत्सुकता से लोड होने पर, आप बीन और उससे संबंधित कक्षाओं के बारे में सभी जानकारी प्राप्त करते हैं (बच्चा नहीं है या एक रिश्ता है, लेकिन एक रिश्ता है, यानी केक में आटा है, दूध है, क्रीम आदि है), और आलसी लोडिंग के मामले में, पहले आप केवल उसी तालिका से आने वाले अपने पहचानकर्ता और मूल्यों को लाते हैं (आवश्यक सामग्री जो पहले आपको केक के मामले में अपने कटोरे में चाहिए होगी)। अन्य तालिकाओं से आने वाली सभी जानकारी को आवश्यकतानुसार / उपयोग में लाया जाएगा।
आलसी लोडिंग आपको एसोसिएशन की पुनर्प्राप्ति को स्थगित करने या भ्रूण की रणनीति पर बेहतर नियंत्रण रखने की अनुमति देता है।
जब आप ईएजीईआर लोडिंग का उपयोग करते हैं, तो आप एक वैश्विक लाने की योजना को परिभाषित करते हैं, जिसे क्वेरी समय में ओवरराइड नहीं किया जा सकता है, जिसका अर्थ है कि आप अपने इकाई मॉडल को डिजाइन करते समय आपके द्वारा लिए गए निर्णय तक सीमित हैं। उत्सुक प्राप्त कर रहा है एक कोड गंध है प्राप्त कर रहा है रणनीति एक प्रश्न समय नीति है और यह एक और करने के लिए एक व्यावसायिक उपयोग के मामले से अलग हो सकती है, क्योंकि।
प्राप्त कर रहा है रणनीति एक बहुत महत्वपूर्ण पहलू है, के रूप में बहुत ज्यादा उत्सुक प्राप्त कर रहा है गंभीर प्रदर्शन से संबंधित मुद्दों पैदा कर सकता है।
आलसी सेटिंग यह तय करती है कि पेरेंट ऑब्जेक्ट को लोड करते समय चाइल्ड ऑब्जेक्ट्स को लोड करना है या नहीं। आपको यह सेटिंग पेरेंट क्लास की संबंधित हाइबरनेट मैपिंग फ़ाइल को करने की आवश्यकता है। आलसी = सही (बच्चे को लोड नहीं करने का मतलब है) डिफ़ॉल्ट रूप से चाइल्ड ऑब्जेक्ट्स की आलसी लोडिंग सही है । यह सुनिश्चित करें कि चाइल्ड ऑब्जेक्ट्स को तब तक लोड नहीं किया जाता है जब तक कि उन्हें अभिभावक पर getChild () पद्धति से कॉल करके स्पष्ट रूप से इनवॉइस नहीं किया जाता है। इस मामले में हाइबरनेट बच्चे को लोड करने के लिए एक नए डेटाबेस कॉल को जारी करता है जब getChild () को मूल रूप से कॉल किया जाता है। ऑब्जेक्ट। लेकिन कुछ मामलों में आपको पेरेंट लोड होने पर बच्चे की वस्तुओं को लोड करने की आवश्यकता होती है। बस आलसी बनाओ = गलत और हाइबरनेट बच्चे को लोड करेगा जब माता-पिता को डेटाबेस से लोड किया जाता है। Exampleslazy = true (डिफ़ॉल्ट) उपयोगकर्ता वर्ग के पता बच्चे को आलसी बनाया जा सकता है यदि यह अक्सर आवश्यक नहीं है।
आलसी लोडिंग एक डिज़ाइन पैटर्न है जिसका उपयोग आमतौर पर कंप्यूटर प्रोग्रामिंग में किसी ऑब्जेक्ट के आरंभीकरण को रोकने के लिए किया जाता है, जब तक कि जिस बिंदु पर इसकी आवश्यकता होती है। यह कार्यक्रम के संचालन में दक्षता के लिए योगदान दे सकता है यदि उचित और उचित रूप से उपयोग किया जाता है
विकिपीडिया
Liber का लिंक hibernate.org से लोड हो रहा है
वैसे इसका सीधा सा मतलब है कि एक बार में पूरे डेटा को लोड करने के बजाए आपको वर्तमान में उपयोग किए जाने वाले डेटा को लोड करना, जिसका आप अब उपयोग नहीं करेंगे। जिससे एप्लिकेशन लोड समय सामान्य से अधिक तेजी से हो रहा है।
Hiberante दोनों संस्थाओं और संग्रह के लिए आलसी प्रारंभ की सुविधा का समर्थन करता है। हाइबरनेट इंजन केवल उन वस्तुओं को लोड करता है जिनके लिए हम क्वेरी कर रहे हैं अन्य एंटाइट्स या संग्रह नहीं करते हैं।
एकमात्र बच्चे के लिए डिफ़ॉल्ट लोडिंग आरंभीकरण का उल्लेख करके आलसी = "झूठा" आलसी है। माता-पिता लोड हो रहा है कि सच का मामला बच्चे का समर्थन नहीं करता है
आलसी सेटिंग यह तय करती है कि पैरेंट ऑब्जेक्ट को लोड करते समय चाइल्ड ऑब्जेक्ट्स को लोड करना है या नहीं। आपको यह सेटिंग पेरेंट क्लास की संबंधित हाइबरनेट मैपिंग फ़ाइल को करने की आवश्यकता है। आलसी = सच (बच्चे को लोड नहीं करने का मतलब है) डिफ़ॉल्ट रूप से चाइल्ड ऑब्जेक्ट्स की आलसी लोडिंग सही है ।
हैरानी की बात है कि कोई भी जवाब नहीं देता है कि यह स्क्रीन के पीछे हाइबरनेट द्वारा कैसे प्राप्त किया जाता है।
आलसी लोडिंग एक डिज़ाइन पैटर्न है जो प्रभावी रूप से प्रदर्शन कारणों के लिए हाइबरनेट में उपयोग किया जाता है जिसमें निम्नलिखित तकनीक शामिल हैं।
1. बाइट कोड इंस्ट्रूमेंटेशन :
हाइबरनेट हुक के साथ बेस क्लास की परिभाषा को उस इकाई ऑब्जेक्ट के लिए सभी कॉल को इंटरसेप्ट करता है।
या तो संकलन समय पर चला गया या [लोड] समय चला गया
१.१ संकलन समय
संकलित समय संचालन पोस्ट करें
ज्यादातर मावेन / चींटी प्लगइन्स द्वारा
1.2 समय चलाएं
इकाई ऑब्जेक्ट जो हाइबरनेट रिटर्न देता है वह वास्तविक प्रकार का प्रॉक्सी है।
इसे भी देखें: जवास्सिस्ट मुख्य विचार क्या है और वास्तविक उपयोग कहां है?