SpringBoot从入门到精通（二十八） JPA 的实体映射关系，轻松一对一，一对多，多对多关系映射！-阿里云开发者社区

前面讲了Spring Boot 使用 JPA，实现JPA 的增、删、改、查的功能，同时也介绍了JPA的一些查询，自定义SQL查询等使用。JPA使用非常简单，功能非常强大的ORM框架，无需任何数据访问层和sql语句即可实现完整的数据操作方法。但是，之前都是介绍的单表的增删改查等操作，多表多实体的数据操作怎么实现呢？接下来聊一聊 JPA 的一对一，一对多，多对一，多对多等实体映射关系。

一、常用注解详解

@JoinColumn指定该实体类对应的表中引用的表的外键，name属性指定外键名称，referencedColumnName指定应用表中的字段名称

@JoinColumn（name=”role_id”）: 标注在连接的属性上(一般多对1的1)，指定了本类用1的外键名叫什么。

@JoinTable(name="permission_role") ：标注在连接的属性上(一般多对多)，指定了多对多的中间表叫什么。

备注：Join的标注，和下面几个标注的mappedBy属性互斥！

@OneToOne 配置一对一关联，属性targetEntity指定关联的对象的类型。

@OneToMany注解“一对多”关系中‘一’方的实体类属性（该属性是一个集合对象），targetEntity注解关联的实体类类型，mappedBy注解另一方实体类中本实体类的属性名称

@ManyToOne注解“一对多”关系中‘多’方的实体类属性（该属性是单个对象），targetEntity注解关联的实体类类型

　　属性1： mappedBy="permissions" 表示，当前类不维护状态，属性值其实是本类在被标注的链接属性上的链接属性，此案例的本类时Permission，连接属性是roles,连接属性的类的连接属性是permissions

属性2： fetch = FetchType.LAZY 表示是不是懒加载，默认是，可以设置成FetchType.EAGER

属性3：cascade=CascadeType.ALL 表示当前类操作时，被标注的连接属性如何级联，比如班级和学生是1对多关系，cascade标注在班级类中，那么执行班级的save操作的时候(班级.学生s.add(学生))，能级联保存学生,否则报错，需要先save学生，变成持久化对象，在班级.学生s.add(学生)

注意:只有OneToOne，OneToMany，ManyToMany上才有mappedBy属性，ManyToOne不存在该属性；

二、一对一

首先，一对一的实体关系最常用的场景就是主表与从表，即主表存关键经常使用的字段，从表保存非关键字段，类似 User与UserDetail 的关系。主表和详细表通过外键一一映射。

一对一的映射关系通过@OneToOne 注解实现。通过 @JoinColumn 配置一对一关系。

其实，一对一有好几种，这里举例的是常用的一对一双向外键关联（改造成单向很简单，在对应的实体类去掉要关联其它实体的属性即可），并且配置了级联删除和添加，相关类如下：

1、User 实体类定义：

package com.weiz.pojo;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.*;
@Getter
@Setter
@Entity
@Table(name = "Users")
public class Users {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private String account;
    private String pwd;
    @OneToOne(cascade = {CascadeType.PERSIST,CascadeType.REMOVE})
    @JoinColumn(name="detailId",referencedColumnName = "id")
    private UsersDetail userDetail;
    @Override
    public String toString() {
        return String.format("Book [id=%s, name=%s, user detail=%s]", id, userDetail.getId());
    }
}

代码说明：注解@OneToMany

关联的实体的主键一般是用来做外键的。但如果此时不想主键作为外键，则需要设置referencedColumnName属性。当然这里关联实体(Address)的主键 id 是用来做主键，所以这里第20行的 referencedColumnName = "id" 实际可以省略。

2、从表 UserDetail 实体类定义

package com.weiz.pojo;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.*;
@Getter
@Setter
@Entity
@Table(name = "UsersDetail")
public class UsersDetail {
    @Id
    @GeneratedValue
    private Long id;
    @Column(name = "address")
    private String address;
    @Column(name = "age")
    private Integer age;
    @Override
    public String toString() {
        return String.format("UsersDetail [id=%s, address=%s, age=%s]", id,address,age);
    }
}

3、如何调用

@RequestMapping("/save")
    public JSONResult save(){
        //用户
        Users user = new Users();
        user.setName("springbootjpa");
        user.setAccount("admin");
        user.setPwd("123456");
        //详情
        UsersDetail usersDetail = new UsersDetail();
        usersDetail.setAge(19);
        usersDetail.setAddress("beijing,haidian,");
        //保存用户和详情
        user.setUserDetail(usersDetail);
        userRespository.save(user);
        return JSONResult.ok("保存成功");
    }

二、一对多和对多对一

一对多和多对一的关系映射，最常见的场景就是：人员角色关系。实体Users：人员。实体 Roles：角色。人员和角色是一对多关系(双向)。那么在JPA中，如何表示一对多的双向关联呢？

JPA使用@OneToMany和@ManyToOne来标识一对多的双向关联。一端(Roles)使用@OneToMany,多端(Users)使用@ManyToOne。在JPA规范中，一对多的双向关系由多端(Users)来维护。也就是说多端(Users)为关系维护端，负责关系的增删改查。

一端(Roles)则为关系被维护端，不能维护关系。一端(Roles)使用@OneToMany注释的mappedBy="role"属性表明Author是关系被维护端。

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

1、原先的User 实体类修改如下：

package com.weiz.pojo;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.*;
@Getter
@Setter
@Entity
@Table(name = "Users")
public class Users {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private String account;
    private String pwd;
    @OneToOne(cascade = {CascadeType.PERSIST,CascadeType.REMOVE})
    @JoinColumn(name="detailId",referencedColumnName = "id")
    private UsersDetail userDetail;
    /**一对多，多的一方必须维护关系，即不能指定mapped=""**/
    @ManyToOne(fetch = FetchType.LAZY,cascade=CascadeType.MERGE)
    @JoinColumn(name="role_id")
    private Roles role;
    @Override
    public String toString() {
        return String.format("Book [id=%s, name=%s, user detail=%s]", id, userDetail.getId());
    }
}

2、角色实体类

package com.weiz.pojo;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Getter
@Setter
@Entity
@Table(name = "Roles")
public class Roles {
    @Id
    @GeneratedValue()
    private Long id;
    private String name;
   @OneToMany(mappedBy="role",fetch=FetchType.LAZY,cascade=CascadeType.ALL)
    private Set<Users> users = new HashSet<Users>();
}

最终生成的表结构 Users 表中会增加role_id 字段。

3、测试

@RequestMapping("/updateRole/{id}")
    public JSONResult updateRole(@PathVariable Long id) {
        Users user = userRespository.findById(id).orElse(null);
        Long roleId = Long.valueOf(25);
        Roles role = roleRespository.findById(roleId).orElse(null);
        if (user!=null){
            user.setRole(role);
        }
        userRespository.save(user);
        return JSONResult.ok("修改成功");
    }

特别注意的是更新和删除的级联操作：其中 @OneToMany 和 @ManyToOne 用得最多，这里再补充一下关于级联，一定要注意，要在关系的维护端，即 One 端。

比如人员和角色，角色是One，人员是Many；cascade = CascadeType.ALL 只能写在 One 端，只有One端改变Many端，不准Many端改变One端。特别是删除，因为 ALL 里包括更新，删除。

如果删除一条评论，就把文章删了，那算谁的。所以，在使用的时候要小心。一定要在 One 端使用。

三、多对多

多对多的映射关系最常见的场景就是：权限和角色关系。角色和权限是多对多的关系。一个角色可以有多个权限，一个权限也可以被很多角色拥有。 JPA中使用@ManyToMany来注解多对多的关系，由一个关联表来维护。这个关联表的表名默认是：主表名+下划线+从表名。(主表是指关系维护端对应的表,从表指关系被维护端对应的表)。这个关联表只有两个外键字段，分别指向主表ID和从表ID。字段的名称默认为：主表名+下划线+主表中的主键列名，从表名+下划线+从表中的主键列名。

需要注意的：

1、多对多关系中一般不设置级联保存、级联删除、级联更新等操作。

2、可以随意指定一方为关系维护端，在这个例子中，我指定 User 为关系维护端，所以生成的关联表名称为： role_permission，关联表的字段为：role_id 和 permission_id。

3、多对多关系的绑定由关系维护端来完成，即由 role1.setPermissions(ps);来绑定多对多的关系。关系被维护端不能绑定关系，即permission不能绑定关系。

4、多对多关系的解除由关系维护端来完成，即由 role1.getPermissions().remove(permission);来解除多对多的关系。关系被维护端不能解除关系，即permission不能解除关系。

5、如果Role和Permission已经绑定了多对多的关系，那么不能直接删除Permission，需要由Role解除关系后，才能删除Permission。但是可以直接删除Role，因为Role是关系维护端，删除Role时，会先解除Role和Permission的关系，再删除Role。

下面，看看角色Roles 和权限 Permissions 的多对多的映射关系实现，具体代码如下：

1、角色Roles 实体类定义：

package com.weiz.pojo;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Getter
@Setter
@Entity
@Table(name = "Roles")
public class Roles {
    @Id
    @GeneratedValue()
    private Long id;
    private String name;
    @ManyToMany(cascade = CascadeType.MERGE,fetch = FetchType.LAZY)
    @JoinTable(name="permission_role")
    private Set<Permissions> permissions = new HashSet<Permissions>();
    @OneToMany(mappedBy="role",fetch=FetchType.LAZY,cascade=CascadeType.ALL)
    private Set<Users> users = new HashSet<Users>();
}

代码说明：

cascade表示级联操作，all是全部，一般用MERGE 更新,persist表示持久化即新增

此类是维护关系的类，删除它，可以删除对应的外键,但是如果需要删除对应的权限就需要CascadeType.all

cascade:作用在本放，对于删除或其他操作本方时，对标注连接方的影响！和数据库一样！！

2、权限Permissions 实体类定义：

package com.weiz.pojo;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.*;
import java.util.Set;
/**
 * 权限表
*/
@Getter
@Setter
@Entity
@Table(name="Permissions")
public class Permissions {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private String type;
    private String url;
    @Column(name="perm_code")
    private String permCode;
    @ManyToMany(mappedBy="permissions",fetch = FetchType.LAZY)
    private Set<Roles> roles;
}

注意：不能两边用mappedBy:这个属性就是维护关系的意思！谁主类有此属性谁不维护关系。

* 比如两个多对多的关系是由role中的permissions维护的，那么，只有操作role实体对象时，指定permissions，才可建立外键的关系。

* 只有OneToOne，OneToMany，ManyToMany上才有mappedBy属性，ManyToOne不存在该属性；并且mappedBy一直和joinXX互斥。

注解中属性的汉语解释：权限不维护关系，关系表是permission_role，全部懒加载，角色的级联是更新 (多对多关系不适合用all，不然删除一个角色，那么所有此角色对应的权限都被删了，级联删除一般用于部分一对多时业务需求上是可删的，比如品牌类型就不适合删除一个类型就级联删除所有的品牌，一般是把此品牌的类型设置为null(解除关系)，然后执行删除，就不会报错了！)

3、验证测试

@RequestMapping("/save")
    public JSONResult save(){
        // 角色
        Roles role1 = new Roles();
        role1.setName("admin role");
        // 角色赋权限
        Set<Permissions> ps = new HashSet<Permissions>();
        for (int i = 0; i < 3; i++) {
            Permissions pm = new Permissions();
            pm.setName("permission"+i);
            permissionRespository.save(pm);  /**由于我的Role类没有设置级联持久化，所以这里需要先持久化pm,否则报错！*/
            ps.add(pm);
        }
        role1.setPermissions(ps);
        // 保存
        roleRespository.save(role1);
        return JSONResult.ok("保存成功");
    }