JPA多对多含额外角色映射问题：用户表异常列致保存失败

你遇到的问题核心是实体关联的映射配置错误，导致Hibernate错误地在users表中生成了指向中间表users_accounts的非空外键列。具体来说：

• 当使用多对多带额外字段的方案时，不能再用传统的@ManyToMany直接关联User和Account，而是需要把中间表UserAccount作为独立实体，分别和User、Account建立@OneToMany + @ManyToOne的双向关联。
• 如果你的User实体中错误地将UserAccount配置为非可选关联（比如未设置optional = true，或默认规则让Hibernate认为关联必须存在），就会触发Hibernate在users表生成非空的user_account_account_id和user_account_user_id外键列，这直接违背了“用户可无账户创建”的设计。

下面是修正后的完整实体代码，彻底解决你的问题：

1. 复合主键类 UserAccountId #

这个类需要包含userId和accountId，实现Serializable并重写equals和hashCode（JPA要求）：

@Embeddable
public class UserAccountId implements Serializable {
    @Column(name = "user_id")
    private Long userId;

    @Column(name = "account_id")
    private Long accountId;

    // 无参构造器（JPA强制要求）
    public UserAccountId() {}

    // 带参构造器
    public UserAccountId(Long userId, Long accountId) {
        this.userId = userId;
        this.accountId = accountId;
    }

    // getter、setter方法
    // 重写equals和hashCode，基于主键字段
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        UserAccountId that = (UserAccountId) o;
        return Objects.equals(userId, that.userId) && Objects.equals(accountId, that.accountId);
    }

    @Override
    public int hashCode() {
        return Objects.hash(userId, accountId);
    }
}

2. 中间实体 UserAccount #

承载User与Account的关联，以及用户在该账户下的角色集合：

@Entity
@Table(name = "users_accounts")
public class UserAccount implements Serializable {
    @EmbeddedId
    private UserAccountId id;

    @ManyToOne(fetch = FetchType.LAZY)
    @MapsId("userId") // 将主键中的userId映射到User实体
    @JoinColumn(name = "user_id")
    private User user;

    @ManyToOne(fetch = FetchType.LAZY)
    @MapsId("accountId") // 将主键中的accountId映射到Account实体
    @JoinColumn(name = "account_id")
    private Account account;

    // 用户在该账户下的角色集合（假设Role是独立实体）
    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(
        name = "user_account_roles",
        joinColumns = {
            @JoinColumn(name = "user_id", referencedColumnName = "user_id"),
            @JoinColumn(name = "account_id", referencedColumnName = "account_id")
        },
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles = new HashSet<>();

    // 无参构造器（JPA要求）
    public UserAccount() {}

    // 带参构造器，快速关联用户和账户
    public UserAccount(User user, Account account) {
        this.user = user;
        this.account = account;
        this.id = new UserAccountId(user.getId(), account.getId());
    }

    // getter、setter方法
    // 重写equals和hashCode，基于复合主键
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        UserAccount that = (UserAccount) o;
        return Objects.equals(id, that.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

3. User实体修正 #

与UserAccount建立一对多关联，明确关联维护端在UserAccount，且允许关联为空：

@Entity
@Table(name = "users")
public class User implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 其他业务字段：username、password等
    private String username;
    private String password;

    // 用户的账户关联集合，维护端在UserAccount的user属性
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
    private Set<UserAccount> userAccounts = new HashSet<>();

    // 无参构造器
    public User() {}

    // 辅助方法：添加账户关联（含角色）
    public void addAccount(Account account, Set<Role> roles) {
        UserAccount userAccount = new UserAccount(this, account);
        userAccount.setRoles(roles);
        userAccounts.add(userAccount);
        account.getUserAccounts().add(userAccount);
    }

    // 辅助方法：移除账户关联
    public void removeAccount(Account account) {
        userAccounts.removeIf(ua -> ua.getAccount().equals(account));
        account.getUserAccounts().removeIf(ua -> ua.getUser().equals(this));
    }

    // getter、setter方法
}

4. Account实体修正 #

与UserAccount建立一对多关联：

@Entity
@Table(name = "accounts")
public class Account implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 其他业务字段：accountName等
    private String accountName;

    @OneToMany(mappedBy = "account", cascade = CascadeType.ALL, orphanRemoval = true)
    private Set<UserAccount> userAccounts = new HashSet<>();

    // 无参构造器
    public Account() {}

    // getter、setter方法
}

5. Role实体示例 #

@Entity
@Table(name = "roles")
public class Role implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name; // 如"ADMIN"、"USER"

    // 可选：如果需要反向关联，可添加以下代码
    // @ManyToMany(mappedBy = "roles")
    // private Set<UserAccount> userAccounts = new HashSet<>();

    // 构造器、getter、setter方法
}

• 移除User与Account之间直接的@ManyToMany注解，改用中间实体UserAccount承载关联和额外的roles字段。
• User中的userAccounts集合使用mappedBy = "user"，表示关联维护端在UserAccount的user属性，Hibernate不会再在users表生成额外外键列，而是在中间表存储关联关系。
• UserAccount通过@MapsId将复合主键字段与User、Account的主键映射，确保关联的正确性。
• User的userAccounts集合默认是可选的（optional = true），创建无账户用户时集合为空，不会触发非空约束错误。

现在可以正常创建并保存无账户的用户：

User user = new User();
user.setUsername("testUser");
user.setPassword("123456");
userRepository.save(user); // 不再触发SQLException

内容的提问来源于stack exchange，提问作者forhas