कैस्केडिंग परिवर्तन

6.1 गहन निर्भरता प्रबंधन

और @OneToMany एनोटेशन और पसंद के बारे में कुछ और उपयोगी और दिलचस्प बातें। उन सभी के पास 4 सामान्य रूप से उपयोग किए जाने वाले विकल्प हैं:

• कैस्केड = कैस्केड टाइप। सभी
• अनाथ निष्कासन = सत्य
• लाने = FetchType.LAZY

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

जेपीए विनिर्देश में इस पैरामीटर के लिए निम्नलिखित मान हैं:

• सभी
• दृढ़ रहना
• मर्ज
• निकालना
• रीफ़्रेश करें
• अलग करना

हालाँकि, हाइबरनेट इस विनिर्देश को तीन और विकल्पों में विस्तारित करता है:

• दोहराने
• सेव_अपडेट करें
• ताला

बेशक, डेटाबेस और उनके CONSTRANIS के साथ एक मजबूत समानता है। हालाँकि, मतभेद भी हैं। हाइबरनेट जितना संभव हो सके डेटाबेस के साथ वास्तविक कार्य को छिपाने की कोशिश करता है, इसलिए ये हाइबरनेट कैस्केड बिल्कुल एंटिटी ऑब्जेक्ट्स के बारे में हैं।

6.2 कैस्केड प्रकार

कैस्केड पैरामीटर वर्णन करता है कि आश्रित वस्तुओं का क्या होना चाहिए यदि हम उनके माता-पिता (मास्टर ऑब्जेक्ट) को बदलते हैं। सबसे अधिक बार, इस पैरामीटर का उपयोग एनोटेशन के साथ किया जाता है जो ऑब्जेक्ट निर्भरता का वर्णन करता है:

उदाहरण:

OneToOne(cascade = CascadeType.ALL)

या इस तरह:

@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})

इसे एक अलग एनोटेशन के रूप में भी लिखा जा सकता है:

@Cascade({ org.hibernate.annotations.CascadeType.ALL })

आइए अब बात करते हैं कि इन एनोटेशन का क्या अर्थ है।

6.3 सभी, बने रहना, विलय करना

CascadeType.ALLइसका मतलब है कि हम जो भी क्रियाएं मूल वस्तु के साथ करते हैं, उन्हें उसकी आश्रित वस्तुओं के लिए दोहराया जाना चाहिए।

CascadeType.PERSISTइसका अर्थ है कि यदि हम मूल वस्तु को डेटाबेस में सहेजते हैं, तो उसके आश्रित वस्तुओं के साथ भी ऐसा ही किया जाना चाहिए। उदाहरण:

@Entity
@Table(name="employee")
class Employee {
   @Column(name="id")
   public Integer id;

   @OneToOne(cascade = CascadeType.PERSIST, mappedBy="task")
   private EmployeeTask task;
}

इस वर्ग के साथ काम करने का एक उदाहरण:

Employee director = new Employee();
EmployeeTask task = new EmployeeTask();
director.task = task;

session.persist(director);
session.flush();

हम केवल कर्मचारी प्रकार की वस्तु को सहेजते हैं, इसकी आश्रित वस्तु कर्मचारी कार्य स्वचालित रूप से डेटाबेस में सहेजी जाएगी।

CascadeType.MERGEइसका अर्थ है कि यदि हम डेटाबेस में मूल वस्तु को अद्यतन करते हैं, तो उसके आश्रित वस्तुओं के साथ भी ऐसा ही किया जाना चाहिए।

6.4 हटाएं, हटाएं, अलग करें

CascadeType.REMOVEइसका मतलब यह है कि यदि हम डेटाबेस में एक मूल वस्तु को हटाते हैं, तो उसके आश्रित वस्तुओं के साथ भी ऐसा ही किया जाना चाहिए।

CascadeType.DELETEमतलब वही। ये पर्यायवाची हैं। बस अलग विशिष्टताओं से।

CascadeType.DETACHइसका अर्थ है कि यदि हम मूल वस्तु को सत्र से हटाते हैं, तो उसके आश्रित वस्तुओं के साथ भी ऐसा ही किया जाना चाहिए। उदाहरण:

@Entity
@Table(name="employee")
class Employee {
   @Column(name="id")
   public Integer id;

   @OneToOne(cascade = CascadeType.DETACH, mappedBy="task")
   private EmployeeTask task;
}

इस वर्ग के साथ काम करने का एक उदाहरण:

Employee director = new Employee();
EmployeeTask task = new EmployeeTask();
director.task = task;
director.task = task;
session.flush();
 
assertThat(session.contains(director)).isTrue();
assertThat(session.contains(task)).isTrue();
 
session.detach(director);
 
assertThat(session.contains(director)).isFalse();
assertThat(session.contains(task)).isFalse();

CascadeType.REFRESHऔर CascadeType.SAVE_UPDATEउसी तरह से काम करते हैं जैसा हम उम्मीद करते हैं - वे उन क्रियाओं की नकल करते हैं जो मूल वस्तु के साथ उसके आश्रित वस्तु पर की जाती हैं।

6.5 अनाथ हटाने का विकल्प

साथ ही कभी-कभी आप पैरामीटर के पार आ सकते हैं orphan। यह अनाथ हटाने के लिए छोटा है। इसका उपयोग यह सुनिश्चित करने के लिए किया जाता है कि मूल संस्थाओं के बिना कोई चाइल्ड संस्था नहीं है।

OneToOne(orphan = true)

यदि यह पैरामीटर सत्य पर सेट है, तो चाइल्ड इकाई गायब होने पर हटा दी जाएगीसभी लिंक. यह ठीक वैसा ही नहीं है जैसा है Cascade.REMOVE।

आपके पास ऐसी स्थिति हो सकती है जहां कई मूल संस्थाएं एक बच्चे को संदर्भित करती हैं। तब यह फायदेमंद होता है कि मूल इकाई को हटाने के साथ इसे हटाया नहीं जाता है, लेकिन केवल तभी जब इसके सभी संदर्भ रद्द हो जाते हैं।

मान लें कि आपके पास कक्षा है:

@Entity
@Table(name="user")
class Employee {
   @Column(name="id")
   public Integer id;

   @OneToMany(cascade = CascadeType.ALL, orphan = true)
   @JoinColumn(name = "employee_id")
   private Set<EmployeeTask> tasks = new HashSet<EmployeeTask>();
}

Employee director = session.find(Employee.class, 4);
EmployeeTask task = director.tasks.get(0);
director.tasks.remove(task)
session.persist(director);
session.flush();

EmployeeTask ऑब्जेक्ट हटा दिया जाएगा क्योंकि इसमें कोई संदर्भ नहीं बचा है। वहीं, किसी ने पैरेंट ऑब्जेक्ट को डिलीट नहीं किया।

6.6 लाने का विकल्प

लाने का विकल्प आपको यह नियंत्रित करने की अनुमति देता है कि निर्भर वस्तुओं को कैसे लोड किया जाता है। यह आमतौर पर दो मानों में से एक लेता है:

• FetchType.LAZY
• FetchType.EAGER

यह एक बहुत ही दिलचस्प विषय है जिसमें विभिन्न नुकसान हैं, इसलिए मैं इसके बारे में एक अलग व्याख्यान में बात करूंगा।