JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

时间:2022-09-28 08:54:22

JPA中的映射关系

jpa中维护one to one ,one to many, many to one ,many to many 四种映射关系。

在每个关系中,双方中的一方在其表中拥有连接列。那么一方称为所有方(owning side) 或者关系的所有者。

不具有连接列的一方称之为非所有方(non-owning)或者反方

所有权对于映射很重要,因为用于定义映射到数据库序列的物理注解(例如,@JoinColumn总是在关系的所有方定义)。如果它们不存在,那么值的默认值将从所有方的特性的角度来考虑。

多对一映射总是在关系的所有方之上,所以如果在拥有多对一方的关系中发现一个@JoinColumn,那么这将是所有方的位置。

注解@JoinColumn,需要指定连接列的名称,可以使用name元素。

举个例子来说: 学生和课程的关系定为一对多,

外键维护在多的一方,此时课程表映射的实体就是owning-side,学生表就是inverse-side

课程表

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

学生表

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

关系映射的使用到的注解说明

@JoinColumn

标记一个列指定实体的关联关系的。可以和@OneToMany或者@ManyToOne搭配使用

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

@OneToMany

在一的一方定义一对多的关联关系,并且如果关联关系时双向的,mappedBy属性必须用来标注,在拥有关联关系的实体一方中表示关系的字段名,也就是使用mappedBy属性是不维护关联关系的一方,值是拥有关联关系一方中标识关系的字段名

使用了mappedBy属性后,不能在使用@JoinColumn注解,会抛异常

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

@ManyToOne 没有mappedBy属性.

@OneToOne /@ManyToMany

都是在实体的字段上表示对应的关联关系,在表示双向关联关系时候,都必须使用mappedBy属性

单向多对一映射

成员和班级是多对一映射,并且外键列定义在成员表中,那么创建成员实体的时候,需要使用@JoinColumn标注

成员是关系的拥有者。也就是关系为多的一方持有

@JoinColumn的值是数据库中的外键名称,@JoinColumn和@ManyToOne搭配维护了关联关系,此时是单向的关联

Partner实体类


  1. @Entity
  2. @Table(name="partner_info")
  3. public class Partner {
  4. private Integer partner_id;
  5. private String partner_name;
  6. private Grade grade;
  7. @Id
  8. @Column(name="partner_id")
  9. @GeneratedValue(strategy=GenerationType.IDENTITY)
  10. public Integer getPartner_id() {
  11. return partner_id;
  12. }
  13. public void setPartner_id(Integer partner_id) {
  14. this.partner_id = partner_id;
  15. }
  16. @Column(name="partner_name")
  17. public String getPartner_name() {
  18. return partner_name;
  19. }
  20. public void setPartner_name(String partner_name) {
  21. this.partner_name = partner_name;
  22. }
  23. @JoinColumn(name="team_id")
  24. @ManyToOne
  25. public Grade getGrade() {
  26. return grade;
  27. }
  28. public void setGrade(Grade grade) {
  29. this.grade = grade;
  30. }
  31. }

Grade实体类


  1. @Entity
  2. @Table(name="grade_info")
  3. public class Grade {
  4. private Integer teamId;
  5. private String teamName;
  6. @Id
  7. @Column(name="team_id")
  8. @GeneratedValue(strategy=GenerationType.IDENTITY)
  9. public Integer getTeamId() {
  10. return teamId;
  11. }
  12. public void setTeamId(Integer teamId) {
  13. this.teamId = teamId;
  14. }
  15. @Column(name="team_name",columnDefinition="varchar(50) not null ")
  16. public String getTeamName() {
  17. return teamName;
  18. }
  19. public void setTeamName(String teamName) {
  20. this.teamName = teamName;
  21. }
  22. }

测试下:


  1. public static void main(String[] args) {
  2. EntityManagerFactory factory = Persistence.createEntityManagerFactory("jpa");
  3. EntityManager entityManager = factory.createEntityManager();
  4. EntityTransaction transaction = entityManager.getTransaction();
  5. transaction.begin();
  6. //执行insert操作
  7. Grade grade = new Grade();
  8. grade.setTeamName("初中1班");
  9. Partner p1 = new Partner();
  10. p1.setPartner_name("张三风");
  11. Partner p2 = new Partner();
  12. p2.setPartner_name("李四关");
  13. p1.setGrade(grade);
  14. p2.setGrade(grade);
  15. entityManager.persist(grade);
  16. entityManager.persist(p1);
  17. entityManager.persist(p2);
  18. transaction.commit();
  19. entityManager.close();
  20. factory.close();
  21. }

在实体创建中,字段的定义和数据库表的字段类型、长度、是否非空一致,不一致容易出问题。

如果出现问题,可以试着将数据库的表删除,交给JPA自己创建,持久化的过程会自动创建表。JPA会自动建表和外键关系.

每一个建立的实体都是javaBean风格的。

数据库中原来不存在表partner_info和grade_info,通过JPA将会在数据库中将生成对应的表,并且生成外键关系

JPA自动建表的策略需要配置: hibernate.ddl-auto 属性

hibernate.ddl-auto节点的值有几个create、create-drop、update、validate、none

create:每次加载hibernate会自动创建表,以后启动会覆盖之前的表,所以这个值基本不用,严重会导致的数据的丢失。

create-drop : 每次加载hibernate时根据model类生成表,但是sessionFactory一关闭,表就自动删除,下一次启动会重新创建。

update: 加载hibernate时根据实体类model创建数据库表,这是表名的依据是@Entity注解的值或者@Table注解的值,sessionFactory关闭表不会删除,且下一次启动会根据实体                   model更新结构或者有新的实体类会创建新的表。

validate:启动时验证表的结构,不会创建表

none:启动时不做任何操作

表的字段字段类型可以使用@Column注解的columnDefinition 指定。

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

如果表创建失败,是映射表没有定义正确

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

持久化顺序,是先持久化一的一方,再去持久化多的一方,这样不会多执行update语句

单向一对一映射

员工Employee到停车位ParkingSpace的关系是一对一关系,一对一映射在一个数据库表中存在一个连接列(外键列),需要在拥有外键列的一方实体中使用@JoinColumn注解中指定列名,并使用@OneToOne注解标识映射关系

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明


  1. @Entity
  2. @Table(name="employee")
  3. public class Employee {
  4. @Id
  5. @Column(name="id")
  6. @GeneratedValue(strategy=GenerationType.IDENTITY)
  7. private Integer id;
  8. @Column(name="name")
  9. private String name;
  10. @Column(name="salary",columnDefinition="DECIMAL(10,2)")
  11. private BigDecimal salary;
  12. @JoinColumn(name="pspace_id")
  13. @OneToOne
  14. private ParkingSpace ps;
  15. public Integer getId() {
  16. return id;
  17. }
  18. public void setId(Integer id) {
  19. this.id = id;
  20. }
  21. public String getName() {
  22. return name;
  23. }
  24. public void setName(String name) {
  25. this.name = name;
  26. }
  27. public BigDecimal getSalary() {
  28. return salary;
  29. }
  30. public void setSalary(BigDecimal salary) {
  31. this.salary = salary;
  32. }
  33. public ParkingSpace getPs() {
  34. return ps;
  35. }
  36. public void setPs(ParkingSpace ps) {
  37. this.ps = ps;
  38. }
  39. }

  1. @Entity
  2. @Table(name="parking_space")
  3. public class ParkingSpace{
  4. @Id
  5. @Column(name="id")
  6. @GeneratedValue(strategy=GenerationType.IDENTITY)
  7. private Integer id;
  8. @Column(name="lot")
  9. private Integer lot;
  10. @Column(name="location")
  11. private String location;
  12. public Integer getId() {
  13. return id;
  14. }
  15. public void setId(Integer id) {
  16. this.id = id;
  17. }
  18. public String getLocation() {
  19. return location;
  20. }
  21. public void setLocation(String location) {
  22. this.location = location;
  23. }
  24. public Integer getLot() {
  25. return lot;
  26. }
  27. public void setLot(Integer lot) {
  28. this.lot = lot;
  29. }
  30. }

双向一对一关系

现在员工已经指向停车位,只要停车位实体在指向员就构成双向的关系

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

首先,必须清楚包含连接列的一方,决定了是关系的所有者,可是在双向一对一关系中,两个映射均是一对一映射,两方

都可以是所有者,最后,关系的拥有者只能有一个,连接列只能在一方,另一方只能指向关系的拥有者

ParkingSpace实体,添加@OneToOne表示映射关系,并且添加mappBy元素表示关系的所有方是Employee。

ParkingSpace修改如下;


  1. @Entity
  2. @Table(name="parking_space")
  3. public class ParkingSpace{
  4. @Id
  5. @Column(name="id")
  6. @GeneratedValue(strategy=GenerationType.IDENTITY)
  7. private Integer id;
  8. @Column(name="lot")
  9. private Integer lot;
  10. @Column(name="location")
  11. private String location;
  12. @OneToOne(mappedBy="ps")
  13. private Employee el;
  14. public Employee getEl() {
  15. return el;
  16. }
  17. public void setEl(Employee el) {
  18. this.el = el;
  19. }
  20. ...........

双向一对一关联的规则;

1. @JoinColumn注解只能放置在映射到包含连接列的表的实体上。

2. mappedBy元素应该在没有定义连接列的实体的@OneToOne注解中指定,就是没有持有关系的一方使用

3. 双向一对一映射关系中只能有一方使用mappedBy属性

集合值关联

当源实体引用一个或者多个目标实体实例时候,将使用一个多值关联(many-value association)或者关联集合。体现在一对多和多对多关联关系中

1. 一对多映射

员工Employee和部门Department的关系,如果使用一对多映射表示,本质上是双向的

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

一个关系是双向的,意味着存在两个映射关系。双向的一对多映射意味着一个回源的多对一映射。

当一个源实体中有任意数量的目标实体存储在它的集合属性中,没有可以扩展的方式可以用于在数据库表中存储这些

它所映射到的引用。如何在单行中存储任意数量的外键?这是行不通的,因此,必须让集合中的实体表能够指向会

源实体表的外键。因而一对多是双向的。


  1. @Entity
  2. @Table(name="department_info")
  3. public class DepartmentInfo {
  4. @Id
  5. @Column(name="id")
  6. @GeneratedValue(strategy=GenerationType.AUTO)
  7. private Integer id;
  8. @Column(name="name")
  9. private String name;
  10. @OneToMany(mappedBy="department")
  11. private List<Employee> list = new ArrayList<Employee>();
  12. public Integer getId() {
  13. return id;
  14. }
  15. public void setId(Integer id) {
  16. this.id = id;
  17. }
  18. public String getName() {
  19. return name;
  20. }
  21. public void setName(String name) {
  22. this.name = name;
  23. }
  24. public List<Employee> getList() {
  25. return list;
  26. }
  27. public void setList(List<Employee> list) {
  28. this.list = list;
  29. }
  30. }

  1. @Entity
  2. @Table(name="employee")
  3. public class Employee {
  4. @Id
  5. @Column(name="id")
  6. @GeneratedValue(strategy=GenerationType.IDENTITY)
  7. private Integer id;
  8. @Column(name="name")
  9. private String name;
  10. @Column(name="salary",columnDefinition="DECIMAL(10,2)")
  11. private BigDecimal salary;
  12. @JoinColumn(name="department_id")
  13. @ManyToOne
  14. private DepartmentInfo department;
  15. public Integer getId() {
  16. return id;
  17. }
  18. public void setId(Integer id) {
  19. this.id = id;
  20. }
  21. public String getName() {
  22. return name;
  23. }
  24. public void setName(String name) {
  25. this.name = name;
  26. }
  27. public BigDecimal getSalary() {
  28. return salary;
  29. }
  30. public void setSalary(BigDecimal salary) {
  31. this.salary = salary;
  32. }
  33. public DepartmentInfo getDepartment() {
  34. return department;
  35. }
  36. public void setDepartment(DepartmentInfo department) {
  37. this.department = department;
  38. }
  39. }

持久化先持久化一的一方,并且从持有关系的一方设值。


  1. DepartmentInfo di = new DepartmentInfo();
  2. di.setName("java开发部2");
  3. Employee e1 = new Employee();
  4. e1.setName("张三1");
  5. e1.setSalary(new BigDecimal(110));
  6. Employee e2 = new Employee();
  7. e2.setName("李四1");
  8. e2.setSalary(new BigDecimal(200));
  9. e1.setDepartment(di);
  10. e2.setDepartment(di);
  11. //di.getList().add(e1); 持久化,只能从拥有关系的一方设值
  12. //di.getList().add(e2);
  13. entityManager.persist(di);
  14. entityManager.persist(e1);
  15. entityManager.persist(e2);

关于部门实体,有几点需要注意

1. 使用明确类型的集合类来存储,如果并不指定存储的类型,就必须使用targetEntity指示指向的类的信息。

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

2. 定义双向一对多关系时候,必须记住多的一方是关系的所有方,必须在那一方定义连接列,一对多的映射是反方,必须使用mappedBy元素

多对多映射

多对多是双向的关系映射,关系双方都是多对多关系,并且双方均没有连接列,需要借助中间表。因为每一个双向关系都必须具有所有方和反方,必须两个实体中挑选一个作为关系的持有者,反方使用mappedBy属性指向持有关系的一方。

使用@ManyToMany在实体的集合属性上表示映射关系。

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明


  1. @Entity
  2. @Table(name="employee")
  3. public class Employee {
  4. @Id
  5. @Column(name="id")
  6. @GeneratedValue(strategy=GenerationType.IDENTITY)
  7. private Integer id;
  8. @Column(name="name")
  9. private String name;
  10. @Column(name="salary",columnDefinition="DECIMAL(10,2)")
  11. private BigDecimal salary;
  12. @JoinTable(name="employee_project_inner",
  13. //中间表product_id字段
  14. joinColumns={@JoinColumn(name="employee_id",referencedColumnName="id")},
  15. inverseJoinColumns={@JoinColumn(name="project_id",referencedColumnName="id")}
  16. )
  17. @ManyToMany
  18. private List<ProjectInfo> projects = new ArrayList<ProjectInfo>();
  19. public Integer getId() {
  20. return id;
  21. }
  22. public void setId(Integer id) {
  23. this.id = id;
  24. }
  25. public String getName() {
  26. return name;
  27. }
  28. public void setName(String name) {
  29. this.name = name;
  30. }
  31. public BigDecimal getSalary() {
  32. return salary;
  33. }
  34. public void setSalary(BigDecimal salary) {
  35. this.salary = salary;
  36. }
  37. public List<ProjectInfo> getProjects() {
  38. return projects;
  39. }
  40. public void setProjects(List<ProjectInfo> projects) {
  41. this.projects = projects;
  42. }
  43. }

@JoinTable说明;

joinColumns元素描述关系所有方在中间表的连接列,inverseJoinColumns元素指定了反方在中间表的连接列。

反方,使用mappedBy属性指向关系拥有的一方。


  1. @Entity
  2. @Table(name="project_info")
  3. public class ProjectInfo {
  4. @Id
  5. @Column(name="id")
  6. @GeneratedValue(strategy=GenerationType.IDENTITY)
  7. private Integer id;
  8. @Column(name="name")
  9. private String name;
  10. @ManyToMany(mappedBy="projects")
  11. private List<Employee> employees = new ArrayList<Employee>();
  12. public Integer getId() {
  13. return id;
  14. }
  15. public void setId(Integer id) {
  16. this.id = id;
  17. }
  18. public String getName() {
  19. return name;
  20. }
  21. public void setName(String name) {
  22. this.name = name;
  23. }
  24. }

单向集合映射

当一个实体到目标实体存在一对多映射,但是@OneToMany注解不包括mappedBy元素时,就认为它存在目标实体的单向关系,此时,两个实体都不存在连接列,是单向的映射关系

需要借助中间表,存储映射关系

JPA中映射关系详细说明(一对多,多对一,一对一、多对多)、@JoinColumn、mappedBy说明

,同样的当多对多关系中,一方没有映射到另一方时候,就是一个单向的关系,也要借助连接表。

唯一的区别是,只有两个实体类型中的一个会使用该表来加载器相关的实体,或者更新它已存储新增的实体关联

创建实体:

目标实体中不会存在集合特性,源实体的@OneToMany注解中不存在mappedBy属性,

就是phone中没有集合属性,employee中@OneToMany注解不用mappedBy属性


  1. @Entity
  2. @Table(name="employee")
  3. public class Employee {
  4. @Id
  5. @Column(name="id")
  6. @GeneratedValue(strategy=GenerationType.IDENTITY)
  7. private Integer id;
  8. @Column(name="name")
  9. private String name;
  10. @Column(name="salary",columnDefinition="DECIMAL(10,2)")
  11. private BigDecimal salary;
  12. @JoinTable(name="employee_phone_inner",
  13. //中间表product_id字段
  14. joinColumns={@JoinColumn(name="employee_id",referencedColumnName="id")},
  15. inverseJoinColumns={@JoinColumn(name="phone_id",referencedColumnName="id")}
  16. )
  17. @OneToMany
  18. private List<Phone> phones = new ArrayList<Phone>(); //.. 省略get/set方法

  1. @Entity
  2. @Table(name="phone")
  3. public class Phone {
  4. @Id
  5. @Column(name="id")
  6. @GeneratedValue(strategy=GenerationType.IDENTITY)
  7. private Integer id;
  8. @Column(name="name")
  9. private String num;
  10. public Integer getId() {
  11. return id;
  12. }
  13. public void setId(Integer id) {
  14. this.id = id;
  15. }
  16. public String getNum() {
  17. return num;
  18. }
  19. public void setNum(String num) {
  20. this.num = num;
  21. }
  22. }

原文地址:https://blog.csdn.net/Ditto_zhou/article/details/80770926