实体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")指定的。
[/size]
分享到:
相关推荐
在Java Persistence API (JPA) 中,多对多(ManyToMany)关系是表示两个实体之间复杂关联的一种方式。这种关联允许一个实体实例可以与多个其他实体实例相关联,反之亦然。例如,一个学生可以选修多门课程,一门课程...
4. **注解细节**:`@JoinColumn`用于单向一对一或一对多关系,而在多对多关系中,通常使用`@JoinTable`来指定中间表的信息,包括表名、连接列等。 5. **操作关联**:在JPA中,可以通过添加或移除对象到集合属性来...
双向一对多关系中,一方实体可以拥有多个另一方实体,而另一方实体也知晓这个关系。双方都需要使用`@OneToMany`和`@ManyToOne`注解来定义关系,且`mappedBy`应设置在`@OneToMany`的一侧。 5. **双向多对一**: 相...
**JPA 2 一对多双向关联关系** Java Persistence API(JPA)是Java平台上的一个标准,用于处理对象关系映射(ORM),使得开发者可以使用面向对象的方式操作数据库。在JPA中,一对多关联关系是常见的实体间关系类型...
在Java Persistence API (JPA) 中,一对多关联是一种常见的关系映射,它表示一个实体可以与多个其他实体相关联。这种关联在数据库层面通常通过外键实现,而在JPA中,我们通过注解来配置这种关系。这篇博客将深入探讨...
在本主题中,我们将深入探讨使用Hibernate注解来实现JPA的一对多、多对多和多对一的关系映射。 1. **一对多关系**: 在现实世界中,一个老师可以教多个学生,或者一个班级可以包含多个学生,这就是典型的一对多...
在JPA中,多对多(Many-to-Many)关联是一种常见的关系类型,适用于描述两个实体之间复杂的关系。本教程将深入探讨JPA中多对多双向关联的各个方面及其操作。 在数据库中,多对多关联意味着一个实体可以与多个其他...
本示例中的“JPA多对多Demo”是一个具体的实践案例,展示了如何在JPA中实现多对多关联关系,以及对应的增删改查方法。 多对多关联是现实世界中常见的一种关系类型,例如教师和学生之间的关系,一个教师可以教多个...
JPA 提供了多种方式来处理不同类型的关联关系,包括单向多对一、单向一对多、双向一对一、双向多对一和双向多对多。下面我们将详细探讨这些关联关系的实现方法。 1. **单向多对一关联关系(SingleManyToOne)** 在...
本篇文章将深入探讨双向一对多的关系映射及其配置。 1. **双向一对多关系的概念** 双向一对多关系意味着两个实体类之间存在一个从属关系,其中一方实体可以拥有多个另一方实体的实例,同时另一方实体也能够引用返回...
本教程将深入探讨JPA中的一对多双向关联及级联操作,这对于理解和使用JPA进行复杂数据模型管理至关重要。 首先,我们来理解一下一对多关联。在数据库设计中,一对多关联是指一个实体(表)可以与多个其他实体相关联...
JPA视频_映射双向一对多的关联关系 · 15. JPA视频_映射双向一对一的关联关系 · 16. JPA视频_映射双向多对多的关联关系 · 17. JPA视频_二级缓存 · 18. JPA视频_JPQL_HelloWorld · 19. JPA视频_JPQL_查询...
2. **一对多(OneToMany)映射**:一个实体对象可以对应多个子对象。使用`@OneToMany`注解,可以设置`mappedBy`属性,表示关联的反向引用。还可以设置`fetch`策略(EAGER或LAZY),控制关联数据是否在加载主体对象时...
本文将深入探讨在JPA中如何实现双向多对多的关联关系,并提供相关的示例代码。 首先,我们需要了解多对多关联关系的基本概念。在关系型数据库中,两个实体之间可能存在多对多的关系,意味着每个实例可以从一个实体...
在Java世界中,Java Persistence API(JPA)是用于管理和持久化对象的规范,它使得开发者可以方便地在...在实际项目中,结合其他关联类型,如一对多、多对一、多对多,可以构建出更加灵活、符合业务逻辑的数据模型。
一对多映射指一个实体引用多个其他实体,如部门和员工之间的关系;多对一映射是与一对多相对的,指多个实体引用同一个实体;多对多关系在JPA中通过关联表来实现。 双向关系映射是指在两个实体间建立关系时,每个...
本文将深入探讨 JPA 中的一对一 (One-to-One)、一对多 (One-to-Many)、多对一 (Many-to-One) 和多对多 (Many-to-Many) 的关联映射。 #### 二、实体关系映射概述 在领域模型中,实体间的关系可以是: - **一对一 ...
总结来说,JPA中的多对多双向关联提供了一种灵活的方式来处理实体间的复杂关系。正确理解和使用这些关系操作,可以帮助开发者构建出高效且易于维护的Java应用程序。在实际开发中,应根据需求选择合适的关联类型和...