@Eins zu eins

5.1 Verschiedene Formen der Eins-zu-eins-Kommunikation

Es gibt einen weiteren interessanten und ziemlich spezifischen Fall einer Beziehung zwischen zwei Entitätsklassen – eine Eins-zu-Eins-Beziehung.

Ich nenne diesen Fall sehr spezifisch, da es mehr um Java-Objekte als um eine Datenbank geht. In der Datenbank gibt es nur zwei Möglichkeiten für die Beziehung zwischen Tabellen:

• Die Tabellenzeile enthält einen Link zur ID einer anderen Tabelle.
• Die Servicetabelle wird für Viele-zu-Viele-Beziehungen verwendet.

Im Fall von Entity-Klassen kann es Optionen geben, die durch mehrere Annotationen beschrieben werden:

• @Eingebettet
• Einseitiges OneToOne
• Bilaterales OneToOne
• @MapsId

Im Folgenden betrachten wir die beliebtesten davon.

5.2 Eingebettet

Die einfachste Eins-zu-eins- Kommunikationsmöglichkeit haben wir übrigens bereits in Betracht gezogen – das ist eine Annotation @Embedded. In diesem Fall haben wir zwei Klassen in derselben Tabelle in der Datenbank gespeichert.

Nehmen wir an, wir möchten die Adresse des Benutzers in der UserAddress- Klasse speichern :

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

Dann müssen wir nur noch ein Feld mit dieser Adresse zur Benutzerklasse hinzufügen :

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

   @Embedded
   public UserAddress address;

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

Den Rest erledigt Hibernate: Die Daten werden in einer Tabelle gespeichert, aber beim Schreiben von HQL-Abfragen müssen Sie mit Klassenfeldern operieren.

Beispiel für eine HQL-Abfrage:

select from User where address.city = 'Paris'

5.3 Einseitiges OneToOne

Stellen Sie sich nun die Situation vor: Wir haben eine Quelltabelle „mitarbeiter“ und eine Aufgabe, die sich auf „mitarbeiter“ bezieht. Wir wissen jedoch mit Sicherheit, dass einem Benutzer maximal eine Aufgabe zugewiesen werden kann. Dann können wir die Annotation verwenden, um diese Situation zu beschreiben @OneToOne.

Beispiel:

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

Hibernate stellt sicher, dass nicht nur eine Aufgabe einen Benutzer hat, sondern auch, dass ein Benutzer nur eine Aufgabe hat. Ansonsten unterscheidet sich dieser Fall praktisch nicht von @ManyToOne.

5.4 Bilaterales OneToOne

Die vorherige Option kann etwas umständlich sein, da Sie häufig einem Mitarbeiter nicht nur eine Aufgabe zuweisen möchten, sondern auch einem Mitarbeiter eine Aufgabe zuweisen möchten.

Dazu können Sie das Feld „EmployeeTask“ zur Klasse „Employee“ hinzufügen und ihm die richtigen Anmerkungen geben.

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

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

Wichtig!Die Mitarbeitertabelle hat kein task_id- Feld , stattdessen wird das Employee_id- Feld der Aufgabentabelle verwendet, um eine Beziehung zwischen Tabellen herzustellen .

Das Herstellen einer Verbindung zwischen Objekten sieht folgendermaßen aus:

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

Um den Link zu entfernen, müssen auch die Links von beiden Objekten entfernt werden:

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