@OneToMany

Relazione a livello di tabella

Diamo un'occhiata di nuovo alle nostre due tabelle:

tabella dei dipendenti:

Questa tabella ha le seguenti colonne:

• id INT
• nome VARCHAR
• occupazione VARCHA
• stipendio INT
• età INT
• join_date DATE

Ed ecco come appare la tabella delle attività , che contiene le attività per i dipendenti:

Questa tabella ha solo 4 colonne:

• id è il numero univoco dell'attività (e le righe nella tabella).
• employee_id - ID del dipendente dalla tabella dei dipendenti a cui è assegnata l'attività.
• name - il nome e la descrizione dell'attività.
• scadenza - il tempo entro il quale l'attività deve essere completata.

Una singola voce nella tabella dei dipendenti può essere referenziata da molte righe nella tabella delle attività. Tale relazione a livello di tabella è chiamata uno-a -molti.

Relazione con il livello di classe Java

E le nostre classi, la classe Employee :

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

E la classe EmployeeTask nella sua forma originale:

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

Possiamo organizzare la comunicazione tra le classi Entity in un modo diverso.

Ricordi l' annotazione @ElementCollection che abbiamo usato per creare una raccolta di oggetti figlio nella classe genitore? Qualcosa di simile può essere fatto con l' annotazione @OneToMany . Solo che questa volta la classe Employee verrà modificata :

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

Usando l' annotazione @OneToMany , abbiamo indicato che l'oggettodipendentepuò memorizzare molti oggetti EmployeeTask . Inoltre, utilizzando l' annotazione @JoinColumn , abbiamo indicato in quale colonna della tabella delle attività è memorizzato l'id dell'oggettodipendente.

Tuttavia, la classe EmployeeTask in genere non contiene un campo che fa riferimento alla colonna employee_id. Esempio:

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

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

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

Il campo employee_id è considerato un campo di servizio e il suo valore è controllato da Hibernate.

Richiedi esempi

Se vuoi aggiungere un'attività a un lavoratore, devi scrivere un codice come questo:

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

Innanzitutto, creiamo due oggetti EmployeeTask , li salviamo nel database e chiamiamo il metodo flush() in modo che venga eseguita l'operazione INSERT e gli oggetti abbiano ID.

Quindi troviamo il direttore nel database, gli prendiamo il campo delle attività e gli aggiungiamo due attività. Quindi salviamo il direttore nel database. Dopodiché, il valore 4 apparirà nel database per le nuove attività nella colonna employee_id - l'id del direttore nella tabella dei dipendenti.

Importante! Le tabelle nel database sono le stesse per le annotazioni @ManyToOne e @OneToMany . Ma le classi Java per queste tabelle sono diverse.