@OneToMany

పట్టిక-స్థాయి సంబంధం

మన రెండు పట్టికలను మళ్ళీ చూద్దాం:

ఉద్యోగుల పట్టిక:

ఈ పట్టిక కింది నిలువు వరుసలను కలిగి ఉంది:

• id INT
• పేరు VARCHAR
• వృత్తి VARCHA
• జీతం INT
• వయస్సు INT
• చేరిన_తేదీ DATE

మరియు ఉద్యోగుల కోసం టాస్క్‌లను కలిగి ఉన్న టాస్క్ టేబుల్ ఇలా కనిపిస్తుంది:

ఈ పట్టికలో 4 నిలువు వరుసలు మాత్రమే ఉన్నాయి:

• id అనేది టాస్క్ యొక్క ప్రత్యేక సంఖ్య (మరియు పట్టికలోని అడ్డు వరుసలు).
• Employee_id - టాస్క్ కేటాయించిన ఉద్యోగి టేబుల్ నుండి ఉద్యోగి యొక్క ID.
• పేరు - పని పేరు మరియు వివరణ.
• గడువు - పనిని పూర్తి చేయవలసిన సమయం.

ఉద్యోగి పట్టికలోని ఒకే ఎంట్రీని టాస్క్ టేబుల్‌లోని అనేక వరుసల ద్వారా సూచించవచ్చు. అటువంటి పట్టిక-స్థాయి సంబంధాన్ని ఒకటి నుండి అనేకం అంటారు .

జావా తరగతి స్థాయికి సంబంధం

మరియు మా తరగతులు, ఉద్యోగుల తరగతి :

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

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

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

   @Column(name="salary")
   public Integer salary;

   @Column(name="join_date")
   public Date join;
}

మరియు EmployeeTask తరగతి దాని అసలు రూపంలో:

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

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

   @Column(name="employee_id")
   public Integer employeeId;

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

@OneToMany ఉల్లేఖన

మేము ఎంటిటీ తరగతుల మధ్య కమ్యూనికేషన్‌ని వేరే విధంగా ఏర్పాటు చేసుకోవచ్చు.

మాతృ తరగతిలోని పిల్లల వస్తువుల సేకరణను రూపొందించడానికి మేము ఉపయోగించిన @ElementCollection ఉల్లేఖనాన్ని గుర్తుంచుకోవాలా ? @OneToMany ఉల్లేఖనంతో ఇలాంటిదేదో చేయవచ్చు . ఈసారి మాత్రమే, ఉద్యోగుల తరగతి మార్చబడుతుంది :

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

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

@OneToMany ఉల్లేఖనాన్ని ఉపయోగించి , మేము ఆబ్జెక్ట్ అని సూచించాముఉద్యోగిఅనేక EmployeeTask వస్తువులను నిల్వ చేయవచ్చు . అలాగే, @JoinColumn ఉల్లేఖనాన్ని ఉపయోగించి , టాస్క్ టేబుల్‌లోని ఏ కాలమ్‌లో ఆబ్జెక్ట్ ఐడి నిల్వ చేయబడిందో మేము సూచించాముఉద్యోగి.

అయితే, EmployeeTask క్లాస్ సాధారణంగా ఉద్యోగి_id కాలమ్‌ని సూచించే ఫీల్డ్‌ని కలిగి ఉండదు. ఉదాహరణ:

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

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

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

Employee_id ఫీల్డ్ సేవా క్షేత్రంగా పరిగణించబడుతుంది మరియు దాని విలువ హైబర్నేట్ ద్వారా నియంత్రించబడుతుంది.

అభ్యర్థన ఉదాహరణలు

మీరు కొంతమంది వర్కర్‌కి కొంత పనిని జోడించాలనుకుంటే, మీరు ఇలా కోడ్‌ని వ్రాయాలి:

EmployeeTask task1 = new EmployeeTask();
task1.description = "Do Something Important";
session.persist(task1);

EmployeeTask task2 = new EmployeeTask();
task2.description = "Nothing to do";
session.persist(task2);
session.flush();

Employee director = session.find(Employee.class, 4);
director.tasks.add(task1);
director.tasks.add(task2);

session.update(director);
session.flush();

ముందుగా, మేము రెండు EmployeeTask ఆబ్జెక్ట్‌లను సృష్టించి , వాటిని డేటాబేస్‌లో సేవ్ చేసి, ఫ్లష్() పద్ధతికి కాల్ చేస్తాము , తద్వారా INSERT ఆపరేషన్ చేయబడుతుంది మరియు ఆబ్జెక్ట్‌లకు IDలు ఉంటాయి.

అప్పుడు మనం డేటాబేస్‌లో దర్శకుడిని కనుగొంటాము, అతని నుండి టాస్క్‌ల ఫీల్డ్‌ని తీసుకొని అతనికి రెండు టాస్క్‌లను జోడిస్తాము. అప్పుడు మేము దర్శకుడిని డేటాబేస్కు సేవ్ చేస్తాము. ఆ తర్వాత, ఎంప్లాయ్‌_ఐడి కాలమ్‌లోని కొత్త టాస్క్‌ల కోసం డేటాబేస్‌లో 4 విలువ కనిపిస్తుంది - ఎంప్లాయ్ టేబుల్‌లోని డైరెక్టర్ యొక్క ఐడి.

ముఖ్యమైనది! డేటాబేస్‌లోని పట్టికలు @ManyToOne మరియు @OneToMany ఉల్లేఖనాల కోసం ఒకే విధంగా ఉంటాయి . కానీ ఈ పట్టికల కోసం జావా తరగతులు భిన్నంగా ఉంటాయి.