java - @ स्मार्ट या बेवकूफ का उपयोग करें?



hibernate postgresql (1)

  1. हां, @BatchSize का अर्थ आलसी संघों के साथ किया जाना है।
  2. हाइबरनेट वैसे भी अधिकांश सत्रों में कई कथनों को निष्पादित करेगा, भले ही अनइंस्टॉल किए गए परदे के पीछे / संग्रह की संख्या निर्दिष्ट बैच आकार से कम हो। अधिक विवरण के लिए यह उत्तर देखें। इसके अलावा, कम बड़े लोगों की तुलना में अधिक हल्के प्रश्न सकारात्मक रूप से सिस्टम के समग्र थ्रूपुट में योगदान कर सकते हैं।
  3. वर्ग स्तर पर @*ToOne बैच का मतलब है कि इकाई के लिए निर्दिष्ट बैच आकार उस इकाई के साथ सभी @*ToOne आलसी संघों के लिए लागू किया जाएगा। documentation में Person इकाई के साथ उदाहरण देखें।

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

एक और महत्वपूर्ण बात उत्सुक लोडिंग से संबंधित है जो लिंक किए गए उत्तरों में उल्लिखित है और जो बताता है कि यदि कोई संपत्ति हमेशा उपयोग की जाती है तो आप उत्सुक लोडिंग का उपयोग करके बेहतर प्रदर्शन प्राप्त कर सकते हैं। यह सामान्य रूप से संग्रह के लिए और कई स्थितियों में टू-वन संघों के लिए सही नहीं है

उदाहरण के लिए, मान लें कि आपके पास निम्न इकाई है जिसके लिए A और bs का उपयोग हमेशा किया जाता है जब A का उपयोग किया जाता है।

public class A {
  @OneToMany
  private Collection<B> bs;

  @OneToMany
  private Collection<C> cs;
}

यदि आप उन्हें एक ही क्वेरी में शामिल नहीं करते हैं, तो सामान्यतः लोड हो रहा है bs और cs स्पष्ट रूप से N + 1 समस्या से ग्रस्त हैं। लेकिन अगर आप उन्हें एक ही प्रश्न में शामिल करते हैं, उदाहरण के लिए:

select a from A
  left join fetch a.bs
  left join fetch a.cs

फिर आप bs और cs और रिटर्निंग count(a.bs) x count(a.cs) पंक्तियों के बीच पूर्ण कार्टेसियन उत्पाद बनाते हैं, जिसके परिणाम a एक करके पढ़े जाते हैं और A की संस्थाओं में इकट्ठे होते हैं और उनके संग्रह bs और cs

इस स्थिति में बैच लाचिंग बहुत ही इष्टतम होगी, क्योंकि आप पहले A , फिर bs और फिर cs पढ़ेंगे, जिसके परिणामस्वरूप अधिक प्रश्न होंगे, लेकिन डेटाबेस से स्थानांतरित किए गए डेटा की कुल कम मात्रा के साथ। इसके अलावा, अलग-अलग क्वेरीज़ जुड़ने वाले बड़े की तुलना में बहुत सरल हैं और डेटाबेस के निष्पादन और अनुकूलन के लिए आसान हैं।

पहले मैं समझाता हूं कि मैंने कैसे समझा और @BatchSize उपयोग @BatchSize : @BatchSize बैच बैच में ऑब्जेक्ट्स के संबंधों को लोड करने के लिए बनाया गया है, डेटाबेस के लिए कम SQL अनुरोध बना रहा है। यह विशेष रूप से LAZY @OneToMany संबंधों पर उपयोगी है।

हालाँकि यह LAZY @OneToOne संबंध और @OneToOne पर भी उपयोगी है: यदि आप डेटाबेस से संस्थाओं की एक सूची लोड करते हैं और एक आलसी @*ToOne इकाई को लोड करने के लिए कहते हैं, तो यह बैचों के लिए संस्थाओं को लोड करेगा भले ही मैं सिर्फ एक परीक्षण का उपयोग करता हूं जो लोड करता है सूची की पहली इकाई का संबंध।

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

एकमात्र दोष जो मुझे उस पद्धति पर दिखाई देता है यदि आप डेटाबेस से आइटम की सूची लोड करते हैं, लेकिन केवल इसका एक हिस्सा उपयोग करते हैं। यह एक पोस्ट-फिल्टरिंग ऑपरेशन है।

तो चलिए मुख्य बिंदु पर आते हैं।

चलिए मान लेते हैं कि मैं कभी भी सबकुछ अच्छा नहीं कर सकता, जैसे कि पोस्ट-फ़िल्टरिंग जैसे ऑपरेशन करना, भले ही यह मुझे देशी एसक्यूएल प्रश्न करता हो या मल्टीसेप्ट मानदंड क्वेरी के लिए डीटीओ ऑब्जेक्ट का उपयोग करता हो।

  1. क्या मुझे यह विचार करने का अधिकार है कि मैं उत्सुक लोडिंग / जॉइन का उपयोग करने के बारे में सावधानी से सोचने के बाद हर आलसी संबंधों को @BatchSize कर सकता हूं और अंत में एक आलसी संबंध का चयन कर सकता हूं?
  2. क्या मेरे पास @BatchSize लिए पर्याप्त मूल्य की खोज करने के लिए कोई दिलचस्पी है या क्या मैं सोच सकता हूं कि "बड़ा बेहतर"? इसका मतलब होगा कि "इन" एसक्यूएल ऑपरेटर में संख्या की कोई सीमा है जो मेरे अनुरोध को पर्याप्त रूप से धीमा कर सकती है, जो अब लायक नहीं है? मैं पोस्टग्रैज का उपयोग करता हूं लेकिन अगर आपके पास दूसरों के लिए उत्तर हैं, तो मैं भी दिलचस्पी रखता हूं।
  3. वैकल्पिक प्रश्न: ऐसा लगता है कि एक वर्ग पर @BatchSize का उपयोग @BatchSize बहुत अधिक परिणाम नहीं दे रहा है। मुझे अभी भी हर आलसी रिश्तों की व्याख्या करनी है, क्या मुझे इसके बारे में कुछ याद आया या यह बेकार है?

संपादित करें: मेरी 3 की बात यह है कि मुझे एक अलग व्यवहार मिल रहा है।

मान लीजिए कि मैं "A" वर्ग की संस्थाओं की सूची लोड कर रहा हूं, जिसका B. से LAZY OneToMany संबंध है। अब मैं B. के सभी निर्माण को प्रिंट करना चाहता हूं। इसलिए मैं लूप के लिए एक क्लासिक 2 कर रहा हूं।

मैंने अब B को BSSize के साथ एनोटेट किया:

  • @OneToMany को बैचाइज़ के साथ एनोटेट नहीं किया गया है: बी के प्रत्येक सेट को प्रत्येक बैच पर स्वतंत्र रूप से बैचिंग के बिना लोड किया गया है। इसलिए बी वर्ग पर मेरी टिप्पणी को पूरी तरह से नजरअंदाज किया गया। यहां तक ​​कि अगर मैं "दो" के लिए एक मूल्य निर्धारित करता हूं और मेरे पास एक सेट में 6 प्रविष्टियां हैं, तो मेरे पास उस सेट के लिए एक क्वेरी है।
    • @OneToMany को एनोटेट किया गया है: मेरे पास उन बैचों की विशिष्ट क्वेरी है जो भरी हुई हैं। अगर मैं बैच आकार दो को ठीक करता हूं और मेरे पास कुल 10 बी accros है, तो मुझे केवल 5 अनुरोध मिलते हैं: मेरे पास जो भी ए की संख्या है। अगर मैं इसे 100 पर सेट करता हूं: मेरे पास B ऑब्जेक्ट के लिए 1 क्वेरी है।

PS: मैं B से संबंधित किसी भी प्रश्न पर विचार नहीं कर रहा हूं जो B फ़ील्ड को चुनिंदा / सबसेलेक्ट के साथ लोड करने के लिए आग लगा सकता है।

EDIT 2: मुझे अभी यह पोस्ट मिला है कि मैं क्यों हर आलसी लोडेड रिश्ते पर @BatchSize का उपयोग नहीं करूंगा? मुझे लगता है कि गुगली की गई और मेरे सवाल से पहले SO पर खोज की, मुझे लगता है कि मैंने सही शब्दों का उपयोग नहीं किया ...

हालाँकि, मैं कुछ अलग जोड़ रहा हूँ जिससे एक अलग उत्तर मिल सकता है: जब मैं हर संबंधों पर बैचैस का उपयोग करने के बारे में सोच रहा हूँ, तो यह चुनने के बाद है कि क्या मैं एक उत्सुक लोडिंग चाहता हूँ, जॉइन / सिलेक्ट भ्रूण के साथ या यदि मुझे आलसी लोडिंग चाहिए।





jpa