@ముఖాముఖి

5.1 ఒకరి నుండి ఒకరు కమ్యూనికేషన్ యొక్క వివిధ రూపాలు

రెండు ఎంటిటీ తరగతుల మధ్య సంబంధానికి సంబంధించి మరొక ఆసక్తికరమైన మరియు నిర్దిష్టమైన సందర్భం ఉంది - ఒకరి నుండి ఒకరికి సంబంధం.

నేను ఈ కేసును చాలా నిర్దిష్టంగా పిలుస్తాను, ఎందుకంటే ఇది డేటాబేస్ కంటే జావా ఆబ్జెక్ట్‌ల గురించి ఎక్కువ. డేటాబేస్లో, పట్టికల మధ్య సంబంధానికి రెండు ఎంపికలు మాత్రమే ఉన్నాయి:

• పట్టిక అడ్డు వరుసలో మరొక పట్టిక యొక్క idకి లింక్ ఉంది.
• సేవా పట్టిక అనేక నుండి అనేక సంబంధాల కోసం ఉపయోగించబడుతుంది.

ఎంటిటీ తరగతుల విషయంలో, అనేక ఉల్లేఖనాల ద్వారా వివరించబడిన ఎంపికలు ఉండవచ్చు:

• @ఎంబెడెడ్
• ఏకపక్ష OneToOne
• ద్వైపాక్షిక OneToOne
• @MapsId

క్రింద మేము వాటిలో అత్యంత ప్రాచుర్యం పొందిన వాటిని పరిశీలిస్తాము.

5.2 పొందుపరచబడింది

మార్గం ద్వారా, మేము ఇప్పటికే సరళమైన వన్-టు-వన్@Embedded కమ్యూనికేషన్ ఎంపికను పరిగణించాము - ఇది ఒక ఉల్లేఖనం . ఈ సందర్భంలో, మేము డేటాబేస్లో ఒకే పట్టికలో రెండు తరగతులను నిల్వ చేస్తాము.

మేము వినియోగదారు చిరునామాను వినియోగదారు చిరునామా తరగతిలో నిల్వ చేయాలనుకుంటున్నాము :

@Embeddable
class UserAddress {
   @Column(name="user_address_country")
   public String country;
   @Column(name="user_address_city")
   public String city;
   @Column(name="user_address_street")
   public String street;
   @Column(name="user_address_home")
   public String home;
}

అప్పుడు మనం వినియోగదారు తరగతికి ఈ చిరునామాతో ఫీల్డ్‌ని జోడించాలి :

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

   @Embedded
   public UserAddress address;

   @Column(name="created_date")
   public Date createdDate;
}

హైబర్నేట్ మిగిలిన వాటిని చేస్తుంది: డేటా ఒక టేబుల్‌లో నిల్వ చేయబడుతుంది, కానీ HQL ప్రశ్నలను వ్రాసేటప్పుడు, మీరు క్లాస్ ఫీల్డ్‌లలో ఆపరేట్ చేయాల్సి ఉంటుంది.

HQL ప్రశ్న ఉదాహరణ:

select from User where address.city = 'Paris'

5.3 ఏకపక్ష OneToOne

ఇప్పుడు పరిస్థితిని ఊహించండి: మాకు సోర్స్ టేబుల్ ఉద్యోగి మరియు ఉద్యోగిని సూచించే పని ఉంది. కానీ ఒక వినియోగదారుకు గరిష్టంగా ఒక పనిని కేటాయించవచ్చని మాకు ఖచ్చితంగా తెలుసు. అప్పుడు మేము ఈ పరిస్థితిని వివరించడానికి ఉల్లేఖనాన్ని ఉపయోగించవచ్చు @OneToOne.

ఉదాహరణ:

@Entity
@Table(name="task")
class EmployeeTask {
   @Column(name="id")
   public Integer id;

   @Column(name="name")
   public String description;

   @OneToOne
   @JoinColumn(name = "employee_id")
   public Employee employee;

   @Column(name="deadline")
   public Date deadline;
}

హైబర్నేట్ ఒక పనికి ఒక వినియోగదారు మాత్రమే కాకుండా, ఒక వినియోగదారుకు ఒకే పని మాత్రమే ఉండేలా చేస్తుంది. లేకపోతే, ఈ కేసు ఆచరణాత్మకంగా భిన్నంగా లేదు @ManyToOne.

5.4 ద్వైపాక్షిక OneToOne

మునుపటి ఎంపిక కొద్దిగా అసౌకర్యంగా ఉంటుంది, ఎందుకంటే తరచుగా మీరు ఉద్యోగిని ఒక పనికి మాత్రమే కాకుండా, ఉద్యోగికి ఒక పనిని కూడా కేటాయించాలనుకుంటున్నారు.

దీన్ని చేయడానికి, మీరు EmployeeTask ఫీల్డ్‌ని ఉద్యోగి తరగతికి జోడించవచ్చు మరియు దానికి సరైన ఉల్లేఖనాలను ఇవ్వవచ్చు.

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

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

ముఖ్యమైనది!ఉద్యోగి పట్టికలో task_id ఫీల్డ్ లేదు , బదులుగా టాస్క్ టేబుల్‌లోని Employee_id ఫీల్డ్ టేబుల్‌ల మధ్య సంబంధాన్ని ఏర్పరచడానికి ఉపయోగించబడుతుంది .

వస్తువుల మధ్య కనెక్షన్‌ని ఏర్పాటు చేయడం ఇలా కనిపిస్తుంది:

Employee director = session.find(Employee.class, 4);
EmployeeTask task = session.find(EmployeeTask.class, 101);
task.employee = director;
director.task = task;

session.update(task);
session.flush();

లింక్‌ను తీసివేయడానికి, రెండు ఆబ్జెక్ట్‌ల నుండి కూడా లింక్‌లను తీసివేయాలి:

Employee director = session.find(Employee.class, 4);
EmployeeTask task = director.task;

task.employee = null;
session.update(task);

director.task = null;
session.update(director);

session.flush();