SpringBoot——》关联映射

悠悠 2024-02-17 09:54 60阅读 0赞

> 推荐链接：  
> [总结——》【Java】][Java]  
> [总结——》【Mysql】][Mysql]  
> [总结——》【Redis】][Redis]  
> [总结——》【Kafka】][Kafka]  
> [总结——》【Spring】][Spring]  
> [总结——》【SpringBoot】][SpringBoot]  
> [总结——》【MyBatis、MyBatis-Plus】][MyBatis_MyBatis-Plus]  
> [总结——》【Linux】][Linux]  
> [总结——》【MongoDB】][MongoDB]  
> [总结——》【Elasticsearch】][Elasticsearch]

#### SpringBoot——》关联映射 ####

*  一、场景
 *  二、关联映射
 *   *  1、@OneToOne（一对一）
     *   *  实现一：@JoinColumn
         *  实现二：@PrimaryKeyJoinColumn
         *  实现三：不使用@JoinColumn和@PrimaryKeyJoinColumn
     *  2、@OneToMany（一对多）
     *   *  实现一：@JoinColumn
         *  实现二：@JoinTable
         *  实现三：不使用@JoinColumn
     *  3、@ManyToOne（多对一）
     *   *  实现一：@JoinColumn
     *  4、@ManyToMany（多对多）
     *   *  实现一：@JoinTable
 *  三、完整示例
 *   *  1、员工实体类：Employee.java
     *  2、地址实体类：Address.java
     *  3、部门实体类：Department.java
     *  4、角色实体类：Role.java

## 一、场景 ##

以员工、地址、部门、角色四者之间的关联关系为例：

1.  一个员工只能有一个地址，一个地址也只属于一个员工；
2.  一个员工只能属于一个部门，但是一个部门可以包含有多个员工；
3.  一个员工可以拥有多个角色，一个角色也可以属于多个员工。

<table> 
 <thead> 
  <tr> 
   <th><strong>表</strong></th> 
   <th><strong>实体类</strong></th> 
   <th><strong>描述</strong></th> 
   <th align="left"><strong>备注</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>tb_employee</td> 
   <td>Employee</td> 
   <td>员工</td> 
   <td align="left">一个员工只能有一个地址<br>一个员工只能属于一个部门<br>一个员工可以拥有多个角色</td> 
  </tr> 
  <tr> 
   <td>tb_address</td> 
   <td>Address</td> 
   <td>地址</td> 
   <td align="left">一个地址只属于一个员工</td> 
  </tr> 
  <tr> 
   <td>tb_department</td> 
   <td>Department</td> 
   <td>部门</td> 
   <td align="left">一个部门可以包含有多个员工</td> 
  </tr> 
  <tr> 
   <td>tb_role</td> 
   <td>Role</td> 
   <td>角色</td> 
   <td align="left">一个角色也可以属于多个员工</td> 
  </tr> 
 </tbody> 
</table>

## 二、关联映射 ##

> 由于 @OneToOne（一对一）、@OneToMany（一对多）、@ManyToOne（多对一）、@ManyToMany（多对多） 等注解只能确定实体之间几对几的关联关系，它们并不能指定与实体相对应的数据库表中的关联字段，因此，需要与 @JoinColumn 注解来配合使用。

### 1、@OneToOne（一对一） ###

#### 实现一：@JoinColumn ####

在员工表中会有一个指向地址表主键的字段address\_id

// 一个员工只能有一个地址，在员工实体类中添加如下注解：
    
    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @JoinColumn(name = "address_id")
    private Address address;

#### 实现二：@PrimaryKeyJoinColumn ####

如果员工表和地址表是以主键关联的：

*  员工表主键：employee\_id
 *  地址表主键：address\_id

// 一个员工只能有一个地址，在员工实体类中添加如下注解：
    
    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @PrimaryKeyJoinColumn(name = "employee_id", referencedColumnName = "address_id")
    private Address address;

#### 实现三：不使用@JoinColumn和@PrimaryKeyJoinColumn ####

Hibernate会自动在员工表生成关联字段，字段默认的命名规则：被控方类名\_被控方主键，如：address\_id

// 一个员工只能有一个地址，在员工实体类中添加如下注解：
    
    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    // Hibernate会自动在员工表生成关联字段，字段默认的命名规则：被控方类名_被控方主键，如：address_id
    private Address address;

### 2、@OneToMany（一对多） ###

> 一个员工只能属于一个部门，但是一个部门可以包含有多个员工，如果我们站在部门的角度来看，部门与员工之间就是一对多的关系。

#### 实现一：@JoinColumn ####

// 一个部门可以包含有多个员工，在部门实体类中添加如下注解：
    
    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name = "department_id")
    private List<Employee> employees;

#### 实现二：@JoinTable ####

// 一个部门可以包含有多个员工，在部门实体类中添加如下注解：
    
    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    /**
    * joinColumns 用来指定中间表中关联自己ID的字段 
    * inverseJoinColumns 用来指定中间表中关联对方ID的字段
    */
    @JoinTable(name = "tbl_employee_department", joinColumns = {
        
    @JoinColumn(name = "department_id") }, inverseJoinColumns = {
         @JoinColumn(name = "employee_id") })
    private List<Employee> employees;

#### 实现三：不使用@JoinColumn ####

Hibernate会自动生成一张中间表来对员工和部门进行绑定，表名默认的命名规则：一的表名\_一实体类中关联多的属性名，例如，部门表名为 tb\_department ，部门实体中关联的员工集合属性名为 employees ，则生成的中间表名为：tb\_department\_employees。  
通常并不推荐让Hibernate自动去自动生成中间表，而是使用@JoinTable注解来指定中间表。

### 3、@ManyToOne（多对一） ###

#### 实现一：@JoinColumn ####

// 一个部门可以包含有多个员工，但一个员工只能属于一个部门，在员工实体类中添加如下注解：
    
    @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name = "department_id")
    private Department department;

### 4、@ManyToMany（多对多） ###

> 一个员工可以拥有多个角色，一个角色也可以属于多个员工，员工与角色之间就是多对多的关系。通常这种多对多关系都是通过创建中间表来进行关联处理，并使用@JoinTable注解来指定。

#### 实现一：@JoinTable ####

// 一个员工可以拥有多个角色，在员工实体类中添加如下注解：
    
    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @JoinTable(name = "tb_employee_role", joinColumns = {
         @JoinColumn(name = "employee_id") }, inverseJoinColumns = {
        
    @JoinColumn(name = "role_id") })
    private List<Role> roles;

// 一个角色可以属于多个员工，在角色实体类中添加如下注解：
    
    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @JoinTable(name = "tb_employee_role", joinColumns = {
         @JoinColumn(name = "role_id") }, inverseJoinColumns = {
        
        @JoinColumn(name = "employee_id") })
    private List<Employee> employees;

## 三、完整示例 ##

### 1、员工实体类：Employee.java ###

@Entity
    @Table(name = "tb_employee")
    @Comment("员工")
    @Data
    public class Employee {
        
    
        @Id
        @GeneratedValue(generator = "seq_employee_id")
        @SequenceGenerator(name = "seq_employee_id", sequenceName = "seq_employee_id")
        private Long id;
    
        @Column(name = "name", columnDefinition = "varchar(64) COMMENT '名称'", nullable = false)
        private String name;
    
        @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
        @JoinColumn(name = "address_id", columnDefinition = "bigint(20) COMMENT '地址ID'", nullable = false)
        // @PrimaryKeyJoinColumn(name = "employee_id", referencedColumnName = "address_id")
        private Address address;
    
        @Getter
        @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
        @JoinColumn(name = "department_id")
        private Department department;
    
        @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
        @JoinTable(name = "tb_employee_role",
                joinColumns = {
        @JoinColumn(name = "employee_id")},
                inverseJoinColumns = {
        @JoinColumn(name = "role_id")})
        private List<Role> roles; // 角色
    }

### 2、地址实体类：Address.java ###

@Entity
    @Table(name = "tb_address")
    @Comment("地址")
    @Data
    public class Address {
        
        @Id
        @GeneratedValue(generator = "seq_address_id")
        @SequenceGenerator(name = "seq_address_id", sequenceName = "seq_address_id")
        private Long id;
    
        @Column(name = "address", columnDefinition = "varchar(64) COMMENT '地址'", nullable = false)
        private String address;
    }

### 3、部门实体类：Department.java ###

@Entity
    @Table(name = "tb_department")
    @Comment("部门")
    @Data
    public class Department {
        
    
        @Id
        @GeneratedValue(generator = "seq_department_id")
        @SequenceGenerator(name = "seq_department_id", sequenceName = "seq_department_id")
        private Long id;
    
        @Getter
        @Column(name = "name", columnDefinition = "varchar(64) COMMENT '名称'", nullable = false)
        private String name;
    
        @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
        @JoinColumn(name = "department_id")
    
        /**
         * joinColumns 用来指定中间表中关联自己ID的字段
         * inverseJoinColumns 用来指定中间表中关联对方ID的字段
         */
    //    @JoinTable(name = "tb_employee_department",
    //            joinColumns = {@JoinColumn(name = "department_id", referencedColumnName = "id")},
    //            inverseJoinColumns = {@JoinColumn(name = "employee_id", referencedColumnName = "id")})
        private List<Employee> employees;
    }

### 4、角色实体类：Role.java ###

@Entity
    @Table(name = "tb_role")
    @Comment("角色")
    @Data
    public class Role {
        
    
        @Id
        @GeneratedValue(generator = "seq_role_id")
        @SequenceGenerator(name = "seq_role_id", sequenceName = "seq_role_id")
        private Long id;
    
        @Column(name = "name", columnDefinition = "varchar(64) COMMENT '名称'", nullable = false)
        private String name;
    
        @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
        @JoinTable(name = "tb_employee_role",
                joinColumns = {
        @JoinColumn(name = "role_id")},
                inverseJoinColumns = {
        @JoinColumn(name = "employee_id")})
        private List<Employee> employees; // 拥有角色的员工
    }

[Java]: https://blog.csdn.net/weixin_43453386/article/details/84788317
[Mysql]: https://blog.csdn.net/weixin_43453386/article/details/88667709
[Redis]: https://blog.csdn.net/weixin_43453386/article/details/127966762
[Kafka]: https://blog.csdn.net/weixin_43453386/article/details/128189472
[Spring]: https://blog.csdn.net/weixin_43453386/article/details/124900806
[SpringBoot]: https://blog.csdn.net/weixin_43453386/article/details/84788714
[MyBatis_MyBatis-Plus]: https://blog.csdn.net/weixin_43453386/article/details/84788053
[Linux]: https://blog.csdn.net/weixin_43453386/article/details/89241912
[MongoDB]: https://blog.csdn.net/weixin_43453386/article/details/84788450
[Elasticsearch]: https://blog.csdn.net/weixin_43453386/article/details/108583782