zoukankan      html  css  js  c++  java

  • JPA中映射关系详细说明(一对多，多对一，一对一、多对多）、@JoinColumn、mappedBy说明

    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

    课程表

    学生表

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

    @JoinColumn

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

    @OneToMany

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

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

    @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. 		
    10. 		Partner p1 = new Partner();
    11. 		p1.setPartner_name("张三风");
    12. 		
    13. 		Partner p2 = new Partner();
    14. 		p2.setPartner_name("李四关");
    15. 		
    16. 		p1.setGrade(grade);
    17. 		p2.setGrade(grade);
    18. 		
    19. 		entityManager.persist(grade);
    20. 		entityManager.persist(p1);
    21. 		entityManager.persist(p2);
    22. 		transaction.commit();
    23. 	    entityManager.close();
    24. 	    factory.close();
    25. 	}

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

    如果出现问题，可以试着将数据库的表删除，交给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 指定。

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

    ，

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

    单向一对一映射

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

    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. }

    双向一对一关系

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

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

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

    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的关系，如果使用一对多映射表示，本质上是双向的

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

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

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

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

    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指示指向的类的信息。

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

    多对多映射

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

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

    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元素时，就认为它存在目标实体的单向关系，此时，两个实体都不存在连接列，是单向的映射关系

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

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

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

    创建实体：

    目标实体中不会存在集合特性，源实体的@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
  • 相关阅读:
    BERT基础知识
    TorchText使用教程
    Pytorch-中文文本分类
    预处理算法_5_数据集划分
    预处理算法_4_表堆叠
    预处理算法_3_新增序列
    预处理算法_2_类型转换
    预处理算法_1_表连接
    爬取网站所有目录文件
    如何将Docker升级到最新版本
  • 原文地址：https://www.cnblogs.com/jpfss/p/10894071.html
Copyright © 2011-2022 走看看