Spring Boot复合主键与级联保存栈溢出问题求助

这个坑我之前踩过！你遇到的栈溢出问题，核心原因是复合主键类ChildID中直接引用了Parent实体，再加上Parent和Child的双向关联，导致Hibernate在处理主键校验、持久化时陷入了无限递归。

问题根源拆解 #

• 你的ChildID里持有Parent实体，而Parent又包含Child的集合，当Hibernate需要计算ChildID的hashCode/equals，或者解析主键时，会递归访问Parent → Child → Parent → Child...
• 批量保存时，Parent还处于未持久化的transient状态，Hibernate不断尝试解析Child的主键关联，触发双向关联的循环加载，最终栈被撑爆。

解决方案：切断主键中的实体关联（推荐方案） #

最稳妥的办法是把复合主键里的Parent实体换成它的主键类型（比如int），这样主键只包含简单值，不会触发递归引用。

步骤1：修改ChildID类

把Parent实体替换成对应主键类型，同时正确实现equals和hashCode（只依赖简单字段）：

import java.util.Objects;

class ChildID implements Serializable {
    // 用Parent的主键类型代替Parent实体
    private int parentId;
    private int id;

    // Serializable必须要有无参构造器
    public ChildID() {}

    // 方便创建的有参构造器
    public ChildID(int parentId, int id) {
        this.parentId = parentId;
        this.id = id;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ChildID childID = (ChildID) o;
        return parentId == childID.parentId && id == childID.id;
    }

    // 别忘了添加getter和setter
    public int getParentId() { return parentId; }
    public void setParentId(int parentId) { this.parentId = parentId; }
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
}

步骤2：调整Child实体

分离主键字段和关联字段，确保@ManyToOne关联不参与主键生成：

@IdClass(ChildID.class)
@Entity
@Table(name = "params3")
class Child {
    // 主键字段，对应ChildID里的parentId
    @Id
    @Column(name = "parent_id")
    private int parentId;

    @Id
    @Column(name = "id")
    private int id;

    // 双向关联字段，设置insertable/updatable=false，避免和主键字段冲突
    @ManyToOne
    @JoinColumn(name = "parent_id", insertable = false, updatable = false)
    private Parent parent;

    // 关联Parent的构造器，同时设置parentId
    public Child(Parent parent) {
        this.parent = parent;
        this.parentId = parent.getId();
    }

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

    // getter和setter
    public Parent getParent() { return parent; }
    public void setParent(Parent parent) {
        this.parent = parent;
        this.parentId = parent.getId(); // 同步更新parentId
    }
    // 其他getter/setter省略
}

步骤3：优化Parent实体的关联维护

添加专门的方法来维护双向关联，避免手动操作集合时出错：

@Entity
class Parent {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 假设用自增主键，根据实际情况调整
    private int id;

    @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Child> list = new ArrayList<>();

    // 维护双向关联的方法
    public void addChild(Child child) {
        list.add(child);
        child.setParent(this);
    }

    // getter和setter
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public List<Child> getList() { return list; }
    public void setList(List<Child> list) { this.list = list; }
}

正确的保存方式

如果Parent用的是自增主键，需要先保存Parent获取主键，再添加Child：

// 创建Parent
Parent p = new Parent();
// 先保存Parent，获取生成的id
parentRepository.save(p);
// 添加Child，关联已持久化的Parent
p.addChild(new Child(p));
// 因为cascade=ALL，保存Parent会自动保存Child
parentRepository.save(p);

备选方案：修复ChildID的equals/hashCode（不推荐） #

如果你坚持要在ChildID里保留Parent实体，必须确保equals和hashCode只使用Parent的主键字段，而不是整个对象：

class ChildID implements Serializable{
    private Parent parent;
    private int id;

    @Override
    public int hashCode() {
        // 只使用parent的id，避免递归访问Parent的其他属性（比如Child集合）
        return Objects.hash(parent != null ? parent.getId() : 0, id);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ChildID childID = (ChildID) o;
        // 同样只比较parent的id
        return id == childID.id && Objects.equals(parent != null ? parent.getId() : null, childID.parent != null ? childID.parent.getId() : null);
    }
}

不过这个方案有风险：如果Parent处于transient状态（还没主键），equals/hashCode会不稳定，可能导致Hibernate缓存或集合操作出错，所以还是推荐第一种方案。

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