@OneToMany

Beziehung auf Tabellenebene

Schauen wir uns noch einmal unsere beiden Tabellen an:

Mitarbeitertabelle:

Diese Tabelle hat die folgenden Spalten:

• id INT
• Namen VARCHAR
• Beruf VARCHA
• Gehalt INT
• Alter INT
• join_date DATUM

Und so sieht die Aufgabentabelle aus, die Aufgaben für Mitarbeiter enthält:

Diese Tabelle hat nur 4 Spalten:

• id ist die eindeutige Nummer der Aufgabe (und der Zeilen in der Tabelle).
• Employee_id – ID des Mitarbeiters aus der Mitarbeitertabelle, dem die Aufgabe zugewiesen ist.
• Name – der Name und die Beschreibung der Aufgabe.
• Frist – die Zeit, bis zu der die Aufgabe abgeschlossen sein muss.

Auf einen einzelnen Eintrag in der Mitarbeitertabelle kann von vielen Zeilen in der Aufgabentabelle verwiesen werden. Eine solche Beziehung auf Tabellenebene wird als Eins-zu -Viele-Beziehung bezeichnet.

Beziehung zur Java-Klassenebene

Und unsere Klassen, die Employee- Klasse :

@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;
}

Und die EmployeeTask- Klasse in ihrer ursprünglichen Form:

@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-Anmerkung

Wir können die Kommunikation zwischen Entitätsklassen auf andere Weise arrangieren.

Erinnern Sie sich an die Annotation @ElementCollection , mit der wir eine Sammlung untergeordneter Objekte in der übergeordneten Klasse erstellt haben? Ähnliches kann mit der Annotation @OneToMany erfolgen . Nur dieses Mal wird die Employee- Klasse geändert :

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

Mithilfe der Annotation @OneToMany haben wir angegeben, dass das ObjektMitarbeiterkann viele EmployeeTask- Objekte speichern . Mithilfe der Annotation @JoinColumn haben wir außerdem angegeben, in welcher Spalte der Aufgabentabelle die Objekt-ID gespeichert istMitarbeiter.

Die EmployeeTask- Klasse enthält jedoch normalerweise kein Feld, das auf die Spalte „employee_id“ verweist. Beispiel:

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

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

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

Das Feld „employee_id“ gilt als Dienstfeld und sein Wert wird von Hibernate gesteuert.

Fordern Sie Beispiele an

Wenn Sie einem Worker eine Aufgabe hinzufügen möchten, müssen Sie Code wie diesen schreiben:

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

Zuerst erstellen wir zwei EmployeeTask- Objekte , speichern sie in der Datenbank und rufen die Methode „flush()“ auf , damit die INSERT-Operation ausgeführt wird und die Objekte IDs haben.

Dann suchen wir den Direktor in der Datenbank, nehmen ihm das Aufgabenfeld ab und fügen ihm zwei Aufgaben hinzu. Dann speichern wir den Regisseur in der Datenbank. Danach erscheint in der Datenbank für neue Aufgaben in der Spalte „employee_id“ der Wert 4 – die ID des Direktors in der Tabelle „employee“.

Wichtig! Die Tabellen in der Datenbank sind für die Annotationen @ManyToOne und @OneToMany identisch . Die Java-Klassen für diese Tabellen sind jedoch unterschiedlich.