JPA的一对多映射(双向)

　　实体Company：公司。

　　实体Employee：雇员。

　　Company和Employee是一对多关系。那么在JPA中，如何表示一对多的双向关联呢？

　　JPA使用@OneToMany和@ManyToOne来标识一对多的双向关联。一端(Company)使用@OneToMany,多端(Employee)使用@ManyToOne。

　　在JPA规范中，一对多的双向关系由多端(Employee)来维护。就是说多端(Employee)为关系维护端，负责关系的增删改查。一端(Company)则为关系被维护端，不能维护关系。

　　一端(Company)使用@OneToMany注释的mappedBy="company"属性表明Company是关系被维护端。

　　多端(Employee)使用@ManyToOne和@JoinColumn来注释属性company,@ManyToOne表明Employee是多端，@JoinColumn设置在employee表中的关联字段(外键)。

　　Company.java如下：

 1 package com.cndatacom.jpa.entity;

 2 

 3 import java.util.HashSet;

 4 import java.util.Set;

 5 

 6 import javax.persistence.CascadeType;

 7 import javax.persistence.Column;

 8 import javax.persistence.Entity;

 9 import javax.persistence.FetchType;

10 import javax.persistence.GeneratedValue;

11 import javax.persistence.Id;

12 import javax.persistence.OneToMany;

13 import javax.persistence.Table;

14 

15 

16 /**

17  * 公司

18  * @author Luxh

19  */

20 @Entity

21 @Table(name="company")

22 public class Company {

23     

24     @Id

25     @GeneratedValue

26     private Long id;

27     

28     /**公司名称*/

29     @Column(name="name",length=32)

30     private String name;

31     

32     /**拥有的员工*/

33     @OneToMany(mappedBy="company",cascade=CascadeType.ALL,fetch=FetchType.LAZY)

34     //拥有mappedBy注解的实体类为关系被维护端

35     //mappedBy="company"中的company是Employee中的company属性

36     private Set<Employee> employees = new HashSet<Employee>();

37     

38 

39     public Long getId() {

40         return id;

41     }

42 

43     public void setId(Long id) {

44         this.id = id;

45     }

46 

47     public String getName() {

48         return name;

49     }

50 

51     public void setName(String name) {

52         this.name = name;

53     }

54 

55     public Set<Employee> getEmployees() {

56         return employees;

57     }

58 

59     public void setEmployees(Set<Employee> employees) {

60         this.employees = employees;

61     }

62      

63 }

　　Employee.java如下：

 1 package com.cndatacom.jpa.entity;

 2 

 3 import javax.persistence.CascadeType;

 4 import javax.persistence.Column;

 5 import javax.persistence.Entity;

 6 import javax.persistence.GeneratedValue;

 7 import javax.persistence.Id;

 8 import javax.persistence.JoinColumn;

 9 import javax.persistence.ManyToOne;

10 import javax.persistence.Table;

11 

12 

13 /**

14  * 雇员

15  * @author Luxh

16  */

17 @Entity

18 @Table(name="employee")

19 public class Employee {

20     

21     @Id

22     @GeneratedValue

23     private Long id;

24     

25     /**雇员姓名*/

26     @Column(name="name")

27     private String name;

28     

29     /**所属公司*/

30     @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)//可选属性optional=false,表示company不能为空

31     @JoinColumn(name="company_id")//设置在employee表中的关联字段(外键)

32     private Company company;

33 

34     public Company getCompany() {

35         return company;

36     }

37 

38     public void setCompany(Company company) {

39         this.company = company;

40     }

41 

42     public Long getId() {

43         return id;

44     }

45 

46     public void setId(Long id) {

47         this.id = id;

48     }

49 

50     public String getName() {

51         return name;

52     }

53 

54     public void setName(String name) {

55         this.name = name;

56     }

57 }

　　

　　简单的测试用例：

　　

 1 package com.cndatacom.jpa.test;

 2 

 3 import java.util.HashSet;

 4 import java.util.Set;

 5 

 6 import javax.persistence.EntityManager;

 7 import javax.persistence.EntityManagerFactory;

 8 import javax.persistence.Persistence;

 9 

10 import org.junit.After;

11 import org.junit.Before;

12 import org.junit.Test;

13 

14 import com.cndatacom.jpa.entity.Author;

15 import com.cndatacom.jpa.entity.Book;

16 import com.cndatacom.jpa.entity.Company;

17 import com.cndatacom.jpa.entity.Employee;

18 

19 

20 public class TestOneToMany {

21     

22 EntityManagerFactory emf = null;

23     

24     @Before

25     public void before() {

26         //根据在persistence.xml中配置的persistence-unit name 创建EntityManagerFactory

27         emf = Persistence.createEntityManagerFactory("myJPA");

28     }

29     

30     @After

31     public void after() {

32          //关闭EntityManagerFactory

33         if(null != emf) {

34             emf.close();

35         }

36     }

37     

38     

39     

40     @Test

41     public void testAddCompany() {

42         EntityManager em = emf.createEntityManager();

43         em.getTransaction().begin();

44         

45         //new 一个公司

46         Company c = new Company();

47         c.setName("Sun");

48         

49         //new 一个雇员

50         Employee e1 = new Employee();

51         e1.setName("陆小凤");

52         //设置所属的公司，必须要设置(实体属性注解使用了optional=false,雇员必须要属于公司，所以公司属性不能为空)

53         e1.setCompany(c);

54         

55         //new 一个雇员

56         Employee e2 = new Employee();

57         e2.setName("花满楼");

58         //设置所属的公司，必须要设置(实体属性注解使用了optional=false,雇员必须要属于公司，所以公司属性不能为空)

59         e2.setCompany(c);

60         

61         //把雇员放到集合中

62         Set<Employee> employees = new HashSet<Employee>();

63         employees.add(e1);

64         employees.add(e2);

65         

66         //设置公司拥有的雇员

67         c.setEmployees(employees);

68         

69         em.persist(c);

70         em.getTransaction().commit();

71         em.close();

72         

73     }

74     

75 

76 }

　　

　　Employee表的结构：

　　可以看到Employee表有一个外键字段company_id,就是@JoinColumn(name="company_id")指定的。