一、 One to Many

可以理解成主表和子表的关系

#1. 实体类的关系

• ManyEntity 是 OneEntity 的子类。根据 @ManyToOne 和 @OneToMany 注解，它们之间建立了 多对一（Many-to-One） 和 一对多（One-to-Many） 的关系。

• ManyEntity 类：表示一方的实体（即 "多" 的一方）。

  public class ManyEntity {
      @ManyToOne(targetEntity = OneEntity.class)
      @JsonBackReference
      OneEntity user; // 多方关联到一方（OneEntity）
  }
  

  • @ManyToOne(targetEntity = OneEntity.class) 表示每个 ManyEntity 实体与一个 OneEntity 实体有多对一的关联，即每个 ManyEntity 都指向一个 OneEntity。
  • @JsonBackReference 用于避免 JSON 序列化时的循环引用。当你序列化 ManyEntity 对象时，user 属性不会被序列化，从而避免了 OneEntity 和 ManyEntity 之间的无限递归问题。

• OneEntity 类：表示一方（即 "一" 的一方）。

  public class OneEntity {
      @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
      @JoinColumn(name = "one_id")
      @MapKey(name = "name")
      @JsonManagedReference
      @Where(clause = "type = 1")
      Map<String, ManyEntity> type1; // 一方关联到多方（ManyEntity）
  }
  

  • @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true) 表示每个 OneEntity 实体可以关联多个 ManyEntity 实体（即“一对多”关系）。其中：
    • fetch = FetchType.LAZY 表示懒加载，即默认不会加载 ManyEntity 对象，只有在访问 type1 时才会加载。
    • cascade = CascadeType.ALL 表示对 OneEntity 的操作（如保存、删除）会级联到 ManyEntity。例如，删除 OneEntity 时，相关的 ManyEntity 也会被删除。
    • orphanRemoval = true 表示如果 ManyEntity 从 OneEntity 中删除了，该 ManyEntity 也会被删除。
  • @JoinColumn(name = "one_id") ，表示ManyEntity 表会有一个名为 one_id 的列。这个列用于存储 OneEntity 的主键值。
  • @MapKey(name = "name") 表示在 Map<String, ManyEntity> 中，name 是 ManyEntity 的键。也就是说，Map 中的 key 值是 ManyEntity 的 name 字段。
  • @JsonManagedReference 用于处理 JSON 序列化。这个注解与 @JsonBackReference 相对，它允许将 OneEntity 对象序列化，而不会在序列化时发生循环引用。
  • @Where(clause = "type = 1") 用于 指定查询条件。这意味着，type1 中的 ManyEntity 只会加载 type 为 1 的那些实体，起到类似 SQL WHERE 子句的作用。
    多说一句这里用map是为了方便查找避免重复，删除和新增也更方便。

#2. 使用

    @Query("SELECT new com.github.spring.boot.jpa.s08_one_to_many.UserS08VO(user.id,user.username) " +
            "FROM UserS08Entity AS user WHERE user.id IN " +
            "(SELECT DISTINCT image.userId FROM ImageS08Entity AS image WHERE image.id = 1)")
    List<UserS08VO> findByBannersByImages();

#3. 注意

• 插入操作：如果在 OneEntity 中配置了 @OneToMany 且使用了 cascade = CascadeType.ALL，那么在保存 OneEntity 时，关联的 ManyEntity 会自动插入。
• 删除操作：如果配置了 cascade = CascadeType.ALL 和 orphanRemoval = true，那么删除 OneEntity 或者从 OneEntity 中移除某个 ManyEntity 时，相关的 ManyEntity 会自动删除。
• Repository：如果你只需要操作 OneEntity，并且希望 ManyEntity 随之级联处理（插入、更新、删除），则只需要操作 OneEntity 的 Repository。如果有特殊需求，需要单独操作 ManyEntity，则需要单独定义 ManyEntity 的 Repository。

一、 Many to Many

可以理解成两个表是多对多的关系，就需要一个中间表来管理关系
这里以用户和角色为例：

#1. 实体类的关系

public class UserS09Entity {
  @JsonManagedReference
  @ManyToMany(targetEntity = RoleS09Entity.class, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
  @JoinTable(
          name = "s09_role_user",
          joinColumns = @JoinColumn(name = "user_id", referencedColumnName = "id", foreignKey = @ForeignKey(name = "none", value = ConstraintMode.NO_CONSTRAINT)),
          inverseJoinColumns = @JoinColumn(name = "role_id", referencedColumnName = "id", foreignKey = @ForeignKey(name = "none", value = ConstraintMode.NO_CONSTRAINT)),
          foreignKey = @ForeignKey(name = "none", value = ConstraintMode.NO_CONSTRAINT),
          inverseForeignKey = @ForeignKey(name = "none", value = ConstraintMode.NO_CONSTRAINT)
  )
  private List<RoleS09Entity> roles;}

@JoinTable 注解

@JoinTable 用于指定多对多关系里的中间表。在 UserS09Entity 代码里，它定义了 UserS09Entity 与 RoleS09Entity 之间多对多关系的中间表 s09_role_user。

• 表名：name = "s09_role_user"，表明关联表名为 s09_role_user，用于存储用户和角色的关联信息。
• 关联字段：
  • joinColumns：通过 @JoinColumn 定义了 UserS09Entity 和中间表的关联。name = "user_id" 表示中间表中关联 UserS09Entity 的字段是 user_id，它引用 UserS09Entity 的 id 字段。
  • inverseJoinColumns：同理，定义了 RoleS09Entity 和中间表的关联。name = "role_id" 表示中间表中关联 RoleS09Entity 的字段是 role_id，引用 RoleS09Entity 的 id 字段。
• 外键约束：foreignKey 和 inverseForeignKey 都设置为不强制应用外键约束（ConstraintMode.NO_CONSTRAINT），意味着中间表不会对这些关联字段进行严格的外键检查。

public class RoleS09Entity {

    @JsonBackReference
    @ManyToMany(fetch = FetchType.LAZY, cascade = {CascadeType.REFRESH, CascadeType.DETACH}, mappedBy = "roles")
    private List<UserS09Entity> users;
}

其中：mappedBy = "roles" 表明 UserS09Entity 类中的 roles 属性是这个多对多关系的拥有方，当前使用 mappedBy 的实体类是被拥有方

2. 使用场景

a. 新增用户，绑定角色

说明

• 创建新用户 并 绑定多个角色，保存后 JPA 会自动维护 s09_role_user 中间表。
• 由于 CascadeType.ALL，如果角色不存在，会自动创建。

示例代码

public void addUserWithRoles(String userName, List<Long> roleIds) {
    UserS09Entity user = new UserS09Entity();
    user.setName(userName);

    List<RoleS09Entity> roles = roleRepository.findAllById(roleIds); // 查找角色
    user.setRoles(roles); // 绑定角色

    userRepository.save(user); // 保存用户，自动维护中间表
}

b. 给指定用户解绑角色

说明

• 解绑用户的指定角色，但不删除角色和用户。
• 只需要从 UserS09Entity.roles 列表中移除角色并保存即可。

示例代码

public void unbindRoleFromUser(Long userId, Long roleId) {
    Optional<UserS09Entity> optionalUser = userRepository.findById(userId);
    optionalUser.ifPresent(user -> {
        user.getRoles().removeIf(role -> role.getId().equals(roleId)); // 移除指定角色
        userRepository.save(user); // 保存用户，JPA 会自动更新中间表
    });
}

c. 删除用户

说明

• 删除用户 时，JPA 级联删除会自动清理 s09_role_user 中的关联关系，但不会影响 role_s09_entity（角色仍然存在）。
• 由于 CascadeType.ALL，会自动删除中间表数据，避免数据污染。

示例代码

public void deleteUser(Long userId) {
    userRepository.deleteById(userId); // 级联删除会移除用户和角色的关联数据
}

d. 删除角色，保留用户

说明

• 删除角色时，必须先解除所有用户的该角色关系，否则会导致外键错误（如果数据库强制外键约束）。
• JPA 不会自动更新 UserS09Entity.roles，需要手动解除。

示例代码

public void deleteRole(Long roleId) {
    Optional<RoleS09Entity> optionalRole = roleRepository.findById(roleId);
    optionalRole.ifPresent(role -> {
        // 解除所有用户的该角色
        for (UserS09Entity user : role.getUsers()) {
            user.getRoles().remove(role);
        }
        userRepository.saveAll(role.getUsers()); // 更新用户表，解除关联
        // 删除角色
        roleRepository.delete(role);
    });
}

总结

这样就能保证 数据一致性，不会出现孤立数据或外键约束问题。