@Um para muitos

Relacionamento em nível de tabela

Vamos olhar para nossas duas tabelas novamente:

tabela de funcionários:

Esta tabela tem as seguintes colunas:

• id INT
• nome VARCHAR
• ocupação VARCHA
• salário INT
• idade INT
• data_de_entrada DATE

E é assim que fica a tabela de tarefas , que contém as tarefas para os funcionários:

Esta tabela tem apenas 4 colunas:

• id é o número exclusivo da tarefa (e linhas na tabela).
• employee_id - ID do funcionário da tabela de funcionários à qual a tarefa está atribuída.
• nome - o nome e a descrição da tarefa.
• deadline - o tempo em que a tarefa deve ser concluída.

Uma única entrada na tabela de funcionários pode ser referenciada por muitas linhas na tabela de tarefas. Esse relacionamento em nível de tabela é chamado de um para muitos.

Relação com o nível de classe Java

E nossas classes, a 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 a classe EmployeeTask em sua forma original:

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

Anotação @OneToMany

Podemos organizar a comunicação entre as classes Entity de uma maneira diferente.

Lembra da anotação @ElementCollection que usamos para criar uma coleção de objetos filho na classe pai? Algo semelhante pode ser feito com a anotação @OneToMany . Só que desta vez, a classe Employee será alterada :

@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 a anotação @OneToMany , indicamos que o objetofuncionáriopode armazenar muitos objetos EmployeeTask . Além disso, usando a anotação @JoinColumn , indicamos em qual coluna da tabela de tarefas o ID do objeto está armazenadofuncionário.

No entanto, a classe EmployeeTask geralmente não contém um campo que se refira à coluna employee_id. Exemplo:

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

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

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

O campo Employees_id é considerado um campo de serviço e seu valor é controlado pelo Hibernate.

Solicitar exemplos

Se você quiser adicionar alguma tarefa a algum trabalhador, precisará escrever um código como este:

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

Primeiro, criamos dois objetos EmployeeTask , salvamos no banco de dados e chamamos o método flush() para que a operação INSERT seja executada e os objetos tenham IDs.

Em seguida, encontramos o diretor no banco de dados, pegamos o campo de tarefas dele e adicionamos duas tarefas a ele. Em seguida, salvamos o diretor no banco de dados. Depois disso, o valor 4 aparecerá no banco de dados para novas tarefas na coluna employee_id - o id do diretor na tabela de funcionários.

Importante! As tabelas no banco de dados são as mesmas para as anotações @ManyToOne e @OneToMany . Mas as classes Java para essas tabelas são diferentes.