Jak korzystać z adnotacji Hibernate @ManyToOne i @OneToMany dla stowarzyszeń

Question

Uczę się Spring, Hibernate, Maven, korzystając z tego samouczka: Chad Lung: A project using Netbeans 7, JUnit, Maven, HSQLDB, Spring and Hibernate. Działa dobrze, ale muszę utworzyć relację jeden-do-wielu (jeden pracownik ma wiele zadań). Próbowałem wiele przykładów, ale nadal nie można uzyskać pomysł jak zrobić swoją pracę kodu:

Employee.java:

package com.giantflyingsaucer.simplespringhibernate.entity; 

import javax.persistence.*; 
import java.io.Serializable; 
import java.util.List; 

@Entity 
@Table(name = "Employees") 
public class Employee implements Serializable { 

    private Integer employeeId; 
    private List<Task> tasks; 

    @Id 
    @Column(name = "idEmployees", nullable=false) 
    public Integer getEmployeeId() { 
     return this.employeeId; 
    } 

    public void setEmployeeId(Integer employeeId) { 
     this.employeeId = employeeId; 
    } 

    @OneToMany(fetch = FetchType.LAZY) 
    @JoinColumn(name="idEmployees") 
    public List<Task> getTasks() { 
     return tasks; 
    } 
} 

Task.java:

package com.giantflyingsaucer.simplespringhibernate.entity; 

import javax.persistence.*; 
import java.io.Serializable; 

@Entity 
@Table(name = "Tasks") 
public class Task implements Serializable { 

    private Integer taskId; 
    private Employee employee; 


    @Id 
    @Column(name = "idTasks", nullable=false) 
    public Integer getTaskId() { 
     return this.taskId; 
    } 

    public void setTaskId(Integer taskId) { 
     this.taskId = taskId; 
    } 

    @ManyToOne(fetch = FetchType.LAZY) 
    @JoinColumn(name = "TasksIdEmployees") 
    public Employee getEmployee() {return employee;} 

} 

db-config.xml:

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" 
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd 
"> 
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" 
    destroy-method="close"> 

    <property name="driverClass"> 
     <value>${jdbc.driver.className}</value> 
    </property> 
    <property name="jdbcUrl"> 
     <value>${jdbc.url}</value> 
    </property> 
    <property name="user"> 
     <value>${jdbc.username}</value> 
    </property> 
    <property name="password"> 
     <value>${jdbc.password}</value> 
    </property> 
</bean> 
<bean id="sessionFactory" 
    class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"> 
    <property name="dataSource"> 
     <ref bean="dataSource" /> 
    </property> 
    <property name="packagesToScan" value="com.giantflyingsaucer.simplespringhibernate.entity" /> 
    <property name="hibernateProperties"> 
     <props> 
      <prop key="hibernate.dialect">${jdbc.hibernate.dialect}</prop> 
      <prop key="hibernate.hbm2ddl.auto">update</prop> 
      <prop key="hibernate.show_sql">false</prop> 
     </props> 
    </property> 
</bean> 
<bean id="transactionManager" 
    class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
    <property name="sessionFactory"> 
     <ref bean="sessionFactory" /> 
    </property> 
</bean> 
<tx:annotation-driven /> 

tabel MySQL:

CREATE TABLE employees (
`idEmployees` int(11) NOT NULL, 
PRIMARY KEY (`idEmployees`) 
); 

CREATE TABLE tasks (
`idTasks` int(11) NOT NULL, 
`TasksIdEmployees` int(11) DEFAULT NULL, 
PRIMARY KEY (`idTasks`), 
KEY `FkTasksEmployees_idx` (`TasksIdEmployees`), 
CONSTRAINT `FkTasksEmployees` FOREIGN KEY (`TasksIdEmployees`) REFERENCES `employees` (`idEmployees`) ON DELETE NO ACTION ON UPDATE NO ACTION 
); 

Dzięki dużo!

znalazłem odpowiedzi przez automatycznego generowania off pliki mapowania i POJOs w NetBeans:

// Employee.java: 
    @OneToMany(fetch = FetchType.LAZY, mappedBy = "employees") 
    public List<Task> getTasks() { 
     return this.tasks; 
    } 

    public void setTasks(List<Task> tasks) { 
     this.tasks = tasks; 
    } 

// Task.java: 
@ManyToOne(fetch = FetchType.LAZY) 
@JoinColumn(name = "TasksIdEmployees") 
public Employee getEmployees() { 
    return this.employee; 
} 

public void setEmployees(Employee employee) { 
    this.employee = employee; 
} 

Answer 1

Co złego jest następujący:

@OneToMany(fetch = FetchType.LAZY) 
@JoinColumn(name="idEmployees") 
public List<Task> getTasks() { 
    return tasks; 
} 

I to jest złe z dwóch powodów.

1. @JoinColumn(name="idEmployees") oznacza to OneToMany jest zmapowany przy użyciu kolumny przyłączenia (to znaczy klucz obcy) o nazwie idEmployees. Ale kolumna łączenia nie ma nazwy idEmployees. idEmployees jest kluczem podstawowym tabeli Employee. Nazwa kolumny łączenia to TasksIdEmployees. Ustawienie odpowiedniej nazwy sprawi, że mapowanie będzie poprawne dla jednokierunkowego skojarzenia OneToMany. Ale powiązanie jest dwukierunkowe, co prowadzi do drugiego powodu ...

2. W powiązaniu dwukierunkowym nie ma potrzeby (i jest to błąd) powtarzania informacji mapowania po obu stronach skojarzenia. Jedna strona (wiele stron) musi być właścicielem powiązania i zdefiniować odwzorowanie. Druga strona musi być odwrotną stroną, mówiąc po prostu: patrz po drugiej stronie, jak to powiązanie jest odwzorowane. Odbywa się to za pomocą atrybutu mappedBy, który mówi hibernacji nazwę pola lub właściwości po drugiej stronie, która jest właścicielem stowarzyszenia:

   @OneToMany(mappedBy = "employee") 
   public List<Task> getTasks() { 
       return tasks; 
   } 
   

Zauważ, że LAZY jest domyślnym dla stowarzyszeń toMany, więc nie trzeba go określać.