@చాలామంది

సేవా పట్టిక

ఇప్పుడు మరొక సాధారణ కేసును చూద్దాం - అనేక నుండి అనేకం. పనులు మరియు ఉద్యోగుల మధ్య మనకు చాలా నుండి అనేక సంబంధాలు ఉన్నాయని ఊహించుకుందాం :

• ఉద్యోగి పట్టికలో ఒక ఉద్యోగి టాస్క్ టేబుల్ నుండి అనేక పనులు చేయగలడు.
• టాస్క్ టేబుల్‌లోని ఒక పనిని అనేక మంది ఉద్యోగులకు కేటాయించవచ్చు.

ఎంటిటీల మధ్య ఈ సంబంధాన్ని చాలా నుండి అనేకం అంటారు. మరియు దీన్ని SQL స్థాయిలో అమలు చేయడానికి, మాకు అదనపు సేవా పట్టిక అవసరం. ఉదాహరణకు, ఉద్యోగి_పని అని పిలుద్దాం.

Employee_task పట్టిక రెండు నిలువు వరుసలను మాత్రమే కలిగి ఉంటుంది:

• ఉద్యోగ గుర్తింపు
• టాస్క్_ఐడి

మేము నిర్దిష్ట వినియోగదారుకు నిర్దిష్ట పనిని కేటాయించిన ప్రతిసారీ, ఈ పట్టికకు కొత్త అడ్డు వరుస జోడించబడుతుంది. ఉదాహరణ:

సరే, టాస్క్ టేబుల్ దాని ఉద్యోగి_ఐడి నిలువు వరుసను కోల్పోతుంది . ఒక ఉద్యోగికి మాత్రమే పనిని కేటాయించగలిగితే అది అర్ధమే. అనేక మంది ఉద్యోగులకు విధిని కేటాయించగలిగితే, ఈ సమాచారం తప్పనిసరిగా ఉద్యోగి_టాస్క్ సేవా పట్టికలో నిల్వ చేయబడాలి .

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

మా కొత్త పట్టికలు ఎలా ఉంటాయో ఇక్కడ ఉంది:

ఉద్యోగుల పట్టిక ( మార్చబడలేదు ) :

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

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

మరియు టాస్క్ టేబుల్ ఇలా కనిపిస్తుంది , ఉద్యోగి_id నిలువు వరుసను కోల్పోయింది (ఎరుపు రంగులో గుర్తించబడింది):

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

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

మేము ఉద్యోగి_టాస్క్ సర్వీస్ టేబుల్‌ని కూడా కలిగి ఉన్నాము , ఇక్కడ టాస్క్ టేబుల్ నుండి ఉద్యోగి_ఐడి డేటా తరలించబడింది:

నేను ఉద్దేశపూర్వకంగా తొలగించిన కాలమ్‌ని టాస్క్ టేబుల్‌లో తాత్కాలికంగా సేవ్ చేసాను, దాని నుండి డేటా ఉద్యోగి_టాస్క్ టేబుల్‌కి తరలించబడిందని మీరు చూడవచ్చు.

మరో ముఖ్యమైన అంశం ఉద్యోగి_టాస్క్ టేబుల్‌లోని రెడ్ లైన్ "(NULL) 6" . ఉద్యోగి_టాస్క్ టేబుల్‌లో లేనందున నేను దానిని ఎరుపు రంగులో గుర్తు పెట్టాను .

వినియోగదారు 4కి టాస్క్ 7 కేటాయించబడితే, ఉద్యోగి_టాస్క్ టేబుల్‌లో అడ్డు వరుస (4, 7) ఉండాలి.

టాస్క్ 6 ఎవరికీ కేటాయించబడకపోతే, ఉద్యోగి_టాస్క్ టేబుల్‌లో దాని కోసం ఎటువంటి రికార్డ్ ఉండదు. ఈ పట్టికల యొక్క తుది సంస్కరణలు ఎలా ఉంటాయో ఇక్కడ ఉంది:

టాస్క్ టేబుల్ :

ఉద్యోగి_టాస్క్ టేబుల్:

జావా క్లాస్ స్థాయిలో కమ్యూనికేషన్

కానీ ఎంటిటీ-క్లాస్‌ల స్థాయిలో కమ్యూనికేషన్‌తో, మాకు పూర్తి ఆర్డర్ ఉంది. శుభవార్తతో ప్రారంభిద్దాం.

ముందుగా, హైబర్నేట్ ప్రత్యేక @ManyToMany ఉల్లేఖనాన్ని కలిగి ఉంది , ఇది అనేక నుండి అనేక పట్టికల సంబంధాన్ని బాగా వివరించడానికి మిమ్మల్ని అనుమతిస్తుంది.

రెండవది, రెండు ఎంటిటీ తరగతులు ఇప్పటికీ మాకు సరిపోతాయి. సర్వీస్ టేబుల్ కోసం మాకు క్లాస్ అవసరం లేదు.

మా తరగతులు ఎలా ఉంటాయో ఇక్కడ ఉంది. ఉద్యోగి తరగతి దాని అసలు రూపంలో:

@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="deadline")
   public Date deadline;
}

@ManyToMany ఉల్లేఖన

నేను ఉదాహరణలలో ఇప్పటికే ఉన్న ఫీల్డ్‌లను తొలగిస్తాను, కానీ నేను కొత్త వాటిని జోడిస్తాను. వారు ఎలా కనిపిస్తారో ఇక్కడ ఉంది. ఉద్యోగి తరగతి :

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

   @ManyToMany(cascade = CascadeType.ALL)
   @JoinTable(name="employee_task",
	       joinColumns=  @JoinColumn(name="employee_id", referencedColumnName="id"),
           inverseJoinColumns= @JoinColumn(name="task_id", referencedColumnName="id") )
   private Set<EmployeeTask> tasks = new HashSet<EmployeeTask>();

}

మరియు ఎంప్లాయీ టాస్క్ క్లాస్ :

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

   @ManyToMany(cascade = CascadeType.ALL)
   @JoinTable(name="employee_task",
       	joinColumns=  @JoinColumn(name="task_id", referencedColumnName="id"),
       	inverseJoinColumns= @JoinColumn(name=" employee_id", referencedColumnName="id") )
   private Set<Employee> employees = new HashSet<Employee>();

}

ప్రతిదీ సంక్లిష్టంగా ఉన్నట్లు అనిపిస్తుంది, కానీ వాస్తవానికి ప్రతిదీ చాలా సులభం.

ముందుగా, ఇది ఉద్యోగి_టాస్క్ సేవా పట్టికను వివరించే @JoinTable ఉల్లేఖనాన్ని ఉపయోగిస్తుంది (@JoinColumnతో గందరగోళం చెందకూడదు).

రెండవది, ఉద్యోగి_టాస్క్ టేబుల్ యొక్క టాస్క్_ఐడి కాలమ్ టాస్క్ టేబుల్ యొక్క ఐడి కాలమ్‌ను సూచిస్తుందని ఇది వివరిస్తుంది.

మూడవది, ఉద్యోగి_టాస్క్ టేబుల్‌లోని ఉద్యోగి_ఐడి కాలమ్ ఉద్యోగి పట్టికలోని ఐడి కాలమ్‌ని సూచిస్తుందని చెబుతుంది.

వాస్తవానికి, ఉల్లేఖనాల సహాయంతో, ఉద్యోగి_టాస్క్ పట్టికలో ఏ డేటా ఉందో మరియు హైబర్నేట్ దానిని ఎలా అర్థం చేసుకోవాలో వివరించాము.

కానీ ఇప్పుడు మనం ఏ ఉద్యోగికైనా చాలా సులభంగా ఒక పనిని జోడించవచ్చు (మరియు తొలగించవచ్చు). మరియు ఏదైనా పనికి ఏదైనా ప్రదర్శకుడిని కూడా జోడించండి.

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

ఈ ManyToMany ఫీల్డ్‌లు ఎలా పని చేస్తాయో బాగా అర్థం చేసుకోవడానికి కొన్ని ఆసక్తికరమైన ప్రశ్నలను వ్రాస్దాం. మరియు వారు ఖచ్చితంగా ఊహించిన విధంగా పని చేస్తారు.

ముందుగా, దర్శకుడికి ఇంతకు ముందు టాస్క్‌ల ఫీల్డ్ ఉన్నందున, మా పాత కోడ్ మార్పులు లేకుండా పని చేస్తుంది:

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();

రెండవది, మేము ఏదైనా పనికి మరొక ప్రదర్శనకారుడిని కేటాయించాలనుకుంటే, దీన్ని చేయడం మరింత సులభం:

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

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

ముఖ్యమైనది! ఈ అభ్యర్థనను అమలు చేయడం వలన, టాస్క్‌కు కార్యనిర్వాహకుడు-దర్శకుడు మాత్రమే కాకుండా, డైరెక్టర్‌కు టాస్క్ నంబర్ 101 కూడా ఉంటుంది.

ముందుగా, ఉద్యోగి_టాస్క్ పట్టికలో డైరెక్టర్ మరియు టాస్క్ మధ్య సంబంధం గురించి వాస్తవం స్ట్రింగ్‌గా నిల్వ చేయబడుతుంది: (4,101).

రెండవది, @ManyToMany ఉల్లేఖనాలతో గుర్తించబడిన ఫీల్డ్‌లు ప్రాక్సీ వస్తువులు మరియు వాటిని యాక్సెస్ చేసినప్పుడు, డేటాబేస్ ప్రశ్న ఎల్లప్పుడూ అమలు చేయబడుతుంది.

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