如何在Hibernate中实现基于非主键的单向多对多关联映射（解决外键字段值错误问题）

我明白你遇到的这个问题——当尝试用单向多对多关联，并且关联字段不是关联实体的主键时，Hibernate很容易自作主张用主键填充，导致外键约束报错，确实挺闹心的。咱们先拆解下问题根源，再给出两种可行的解决办法。

问题根源分析 #

你当前的代码有两个关键问题：

• 重复映射冲突：你同时用了@ManyToMany让Hibernate自动管理中间表client_member，又手动创建了ClientMember实体映射这个中间表，这会让Hibernate的映射规则混乱，不知道该遵循哪种逻辑。
• Hibernate默认行为：即使去掉ClientMember实体，Hibernate默认也会优先使用关联实体的主键（也就是Member的id）来填充关联表的外键字段，哪怕你指定了referencedColumnName="key"，它也可能忽略这个配置，除非明确告诉它要用NaturalId。

解决方案一：使用中间表实体（推荐，可控性更强） #

这种方式完全手动映射中间表，避免Hibernate的默认行为干扰，同时保持单向关联（不需要在Member中添加反向关联）。

1. 修改Client类的映射

把原来的@ManyToMany替换为@OneToMany关联到ClientMember实体：

@Entity
@Table(name = "client")
class Client(
    @Id
    @Access(AccessType.PROPERTY)
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", unique = true, nullable = false, updatable = false)
    var id: Long?,

    @Column(name = "name", nullable = false)
    var name: String,

    // 替换@ManyToMany为@OneToMany，级联操作确保保存Client时自动保存关联的ClientMember
    @OneToMany(mappedBy = "id.client", cascade = [CascadeType.ALL], orphanRemoval = true)
    var clientMembers: MutableSet<ClientMember> = mutableSetOf(),
)

2. 完善ClientMember和复合主键的映射

确保复合主键中的Member关联正确指向key字段，同时重写equals和hashCode（复合主键必须实现这两个方法）：

@Entity
@Table(name = "client_member")
class ClientMember(
    @EmbeddedId
    var id: ClientMemberCompositeKey
) {
    @Embeddable
    class ClientMemberCompositeKey(
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(
            name = "client_id",
            referencedColumnName = "id",
            nullable = false
        )
        var client: Client,

        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(
            name = "member_key",
            referencedColumnName = "key",
            nullable = false
        )
        var member: Member,
    ) {
        override fun equals(other: Any?): Boolean {
            if (this === other) return true
            if (javaClass != other?.javaClass) return false

            other as ClientMemberCompositeKey

            if (client != other.client) return false
            if (member != other.member) return false

            return true
        }

        override fun hashCode(): Int {
            var result = client.hashCode()
            result = 31 * result + member.hashCode()
            return result
        }
    }
}

3. 保存数据的正确方式

先保存Member，再关联到ClientMember后保存Client：

// 1. 先保存Member
val member = Member(null, "c90bcfd6-86be-4ec4-8e16-2a541ce87317", "测试成员")
memberRepository.save(member)

// 2. 创建Client
val client = Client(null, "测试客户", mutableSetOf())

// 3. 创建关联并添加到Client集合
val clientMember = ClientMember(ClientMember.ClientMemberCompositeKey(client, member))
client.clientMembers.add(clientMember)

// 4. 保存Client（级联操作会自动保存ClientMember）
clientRepository.save(client)

解决方案二：继续使用@ManyToMany（需Hibernate 6+支持） #

如果你不想引入中间表实体，可以通过@NaturalIdReference明确告诉Hibernate使用Member的key字段（即NaturalId）来关联：

1. 确保Member的key字段标注@NaturalId（你已经完成这一步）

@Entity
@Table(name = "member")
class Member(
    // 其他字段
    @NaturalId
    @Column(name = "key", unique = true, nullable = false, updatable = false)
    var key: String,
)

2. 修改Client的@ManyToMany映射

添加@NaturalIdReference注解，指定使用NaturalId而非主键关联：

@Entity
@Table(name = "client")
class Client(
    // 其他字段
    @ManyToMany
    @JoinTable(
        name = "client_member",
        joinColumns =  [JoinColumn(
            name = "client_id",
            referencedColumnName = "id",
            nullable = false
        )],
        inverseJoinColumns = [JoinColumn(
            name = "member_key",
            referencedColumnName = "key",
            nullable = false
        )]
    )
    @NaturalIdReference // 关键：强制使用NaturalId关联
    var clientMembers: MutableSet<Member>,
)

注意：这个方案需要Hibernate 6及以上版本支持，如果你用的是旧版本，可能需要添加配置hibernate.use_natural_id_always=true到你的Hibernate配置文件中。

总结 #

推荐使用第一种方案（中间表实体），因为它的逻辑更清晰，完全可控，不会受到Hibernate默认行为的影响，而且完美保持了单向关联的需求，不需要修改Member实体的任何内容。

备注：内容来源于stack exchange，提问作者dconard