క్యాస్కేడింగ్ మార్పులు

6.1 డీప్ డిపెండెన్సీ మేనేజ్‌మెంట్

@OneToMany ఉల్లేఖనాలు మరియు ఇలాంటి వాటి గురించి మరికొన్ని ఉపయోగకరమైన మరియు ఆసక్తికరమైన విషయాలు . వీటన్నింటికీ సాధారణంగా ఉపయోగించే 4 ఎంపికలు ఉన్నాయి:

• cascade = CascadeType.ALL
• orphanRemoval = నిజం
• fetch = FetchType.LAZY

ఇప్పుడు మేము వాటిని మరింత వివరంగా విశ్లేషిస్తాము. మరియు మేము అత్యంత ఆసక్తికరమైన - CascadeType తో ప్రారంభిస్తాము . మేము ప్రధాన ఎంటిటీని మార్చినట్లయితే ఆధారిత ఎంటిటీలకు ఏమి జరుగుతుందో ఈ పరామితి నిర్ణయిస్తుంది.

ఈ పరామితి కోసం JPA స్పెసిఫికేషన్ క్రింది విలువలను కలిగి ఉంది:

• అన్ని
• పట్టుదల
• విలీనం
• తొలగించు
• రిఫ్రెష్ చేయండి
• విడదీయండి

అయితే, హైబర్నేట్ ఈ స్పెసిఫికేషన్‌ను మరో మూడు ఎంపికలుగా విస్తరిస్తుంది:

• ప్రతిరూపం
• SAVE_UPDATE
• లాక్ చేయండి

వాస్తవానికి, డేటాబేస్ మరియు వాటి 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();

మేము ఉద్యోగి రకం వస్తువును మాత్రమే సేవ్ చేస్తాము, దాని ఆధారిత వస్తువు EmployeeTask స్వయంచాలకంగా డేటాబేస్‌లో సేవ్ చేయబడుతుంది.

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

ఇది వివిధ ఆపదలతో కూడిన చాలా ఆసక్తికరమైన అంశం, కాబట్టి నేను దాని గురించి ప్రత్యేక ఉపన్యాసంలో మాట్లాడటం మంచిది.