@Een te veel

Relatie op tafelniveau

Laten we nog eens naar onze twee tabellen kijken:

werknemers tafel:

Deze tabel heeft de volgende kolommen:

• id INT
• naam VARCHAR
• bezetting VARCHA
• salaris INT
• leeftijd INT
• join_date DATUM

En zo ziet de takentabel , die taken voor medewerkers bevat, er uit:

Deze tabel heeft slechts 4 kolommen:

• id is het unieke nummer van de taak (en rijen in de tabel).
• employee_id - ID van de werknemer uit de werknemerstabel waaraan de taak is toegewezen.
• naam - de naam en beschrijving van de taak.
• deadline - de tijd waarop de taak moet zijn voltooid.

Er kan naar een enkel item in de werknemerstabel worden verwezen door vele rijen in de taaktabel. Een dergelijke relatie op tabelniveau wordt een-op- veel genoemd.

Relatie met het Java-klassenniveau

En onze klassen, de Werknemersklasse :

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

En de klasse EmployeeTask in zijn oorspronkelijke vorm:

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

We kunnen de communicatie tussen Entity-klassen op een andere manier regelen.

Weet je nog de @ElementCollection- annotatie die we gebruikten om een ​​verzameling onderliggende objecten in de bovenliggende klasse te maken? Iets soortgelijks kan worden gedaan met de annotatie @OneToMany . Alleen deze keer wordt de klasse Werknemer gewijzigd :

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

Met de annotatie @OneToMany hebben we aangegeven dat het objectmedewerkerkan veel EmployeeTask- objecten opslaan . Ook hebben we met behulp van de @JoinColumn annotatie aangegeven in welke kolom van de taaktabel de object-ID is opgeslagenmedewerker.

De klasse EmployeeTask bevat echter meestal geen veld dat verwijst naar de kolom employee_id. Voorbeeld:

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

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

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

Het veld employee_id wordt beschouwd als een serviceveld en de waarde ervan wordt beheerd door Hibernate.

Vraag voorbeelden aan

Als u een taak aan een werknemer wilt toevoegen, moet u de volgende code schrijven:

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

Eerst maken we twee EmployeeTask- objecten , slaan ze op in de database en roepen de methode flush() aan zodat de INSERT-bewerking wordt uitgevoerd en de objecten ID's hebben.

Vervolgens vinden we de directeur in de database, nemen het takenveld van hem over en voegen twee taken aan hem toe. Vervolgens slaan we de regisseur op in de database. Daarna verschijnt de waarde 4 in de database voor nieuwe taken in de kolom employee_id - de id van de directeur in de werknemerstabel.

Belangrijk! De tabellen in de database zijn dezelfde voor de annotaties @ManyToOne en @OneToMany . Maar de Java-klassen voor deze tabellen zijn anders.