Java Hibernate在尝试删除多个关系中的实体时引发异常

Team

和

TeamMember

有很多关系。当我试图像这样删除团队时：

public void deleteTeam(int id) {
        Team team = (Team) getCurrentSession().get(Team.class, id);
        getCurrentSession().delete(team);
}

它给出了：

org.springframework.dao.InvalidDataAccessApiUsageException: deleted object would be re-saved by cascade (remove deleted object from associations): [com.sprhib.model.Team#1]; 
    nested exception is org.hibernate.ObjectDeletedException: deleted object would be re-saved by cascade (remove deleted object from associations): [com.sprhib.model.Team#1]

然后，我尝试从持有我需要删除的团队的团队成员实体中删除所有团队：

public void deleteTeam(int id) {
        Team team = getTeam(id);
        if(team != null){
            for(TeamMember tm: team.getTeamMembers()){
                for(Team t: tm.getTeams()){
                    if(t.getId() == team.getId()){
                        tm.getTeams().remove(t);
                    }
                }
            }
            getCurrentSession().delete(team);
        }
    }

但同样的错误依然存在。首先，我希望Hibernate能够相应地管理许多关系中的所有相关实体，因为它们都有注释。但它拒绝工作。WTF

团队

@Entity
@Table(name="teams")
public class Team {


    private int id;

    private String name;

    private int rating;

    private Set<TeamMember> teamMembers;

    private Organization organization;

    @Id
    @NotNull
    @GeneratedValue(strategy = GenerationType.AUTO)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Length(max = 45)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @NotNull
    @Range(min = 0,max = 10)
    public int getRating() {
        return rating;
    }
    public void setRating(int rating) {
        this.rating = rating;
    }

    @NotNull
    @ManyToOne(fetch = FetchType.EAGER, cascade = {CascadeType.MERGE})
    @JoinColumn(name = "FK_Organization_id", nullable = false)
    public Organization getOrganization() {
        return organization;
    }

    public void setOrganization(Organization organization) {
        this.organization = organization;
    }

    @ManyToMany(fetch = FetchType.EAGER, cascade = {CascadeType.ALL})
    @JoinTable(name = "team_member", joinColumns =
        @JoinColumn(name = "FK_Team_id", referencedColumnName= "id"),
            inverseJoinColumns = @JoinColumn(name = "FK_Member_id", referencedColumnName = "id")
    )
    public Set<TeamMember> getTeamMembers() {
        return teamMembers;
    }

    public void setTeamMembers(Set<TeamMember> teamMembers) {
        this.teamMembers = teamMembers;
    }
}

@实体
@表（name=“teams”）
公开课小组{
私有int-id；
私有字符串名称；
私人内部评级；
私人团队成员；
私人组织；
@身份证
@NotNull
@GeneratedValue（策略=GenerationType.AUTO）
公共int getId（）{
返回id；
}
公共无效集合id（内部id）{
this.id=id；
}
@长度（最大值=45）
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
@NotNull
@范围（最小值=0，最大值=10）
public int getRating（）{
回报率；
}
公共评级（内部评级）{
这个。评级=评级；
}
@NotNull
@manytone（fetch=FetchType.EAGER，cascade={CascadeType.MERGE}）
@JoinColumn（name=“FK\u Organization\u id”，null=false）
公共组织{
返回组织；
}
公共组织（组织）{
这个组织=组织；
}
@ManyToMany（fetch=FetchType.EAGER，cascade={CascadeType.ALL}）
@JoinTable（name=“团队成员”，JointColumns=
@JoinColumn（name=“FK\u Team\u id”，referencedColumnName=“id”），
inverseJoinColumns=@JoinColumn（name=“FK\u Member\u id”，referencedColumnName=“id”）
)
公共集getTeamMembers（）{
返回团队成员；
}
公共无效设置成员（设置团队成员）{
this.teamMembers=团队成员；
}
}

团队成员

@Entity
@Table(name="member")
public class TeamMember {

    private int id;

    private String name;

    private Set<Team> teams;

    @Id
    @NotNull
    @GeneratedValue(strategy = GenerationType.AUTO)
    public int getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
    @NotEmpty
    @Length(max=100)
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @NotNull
    @ManyToMany(fetch = FetchType.EAGER, mappedBy = "teamMembers", cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH, CascadeType.REMOVE}) // cascade!!!
    public Set<Team> getTeams(){
        return teams;
    }

    public void setTeams(Set<Team> teams) {
        this.teams = teams;
    }


}

@实体
@表（name=“member”）
公开课小组成员{
私有int-id；
私有字符串名称；
私人团队；
@身份证
@NotNull
@GeneratedValue（策略=GenerationType.AUTO）
公共int getId（）{
返回id；
}
公共无效集合id（整数id）{
this.id=id；
}
@空空如也
@长度（最大值=100）
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
@NotNull
@ManyToMany（fetch=FetchType.EAGER，mappedBy=“teamMembers”，cascade={CascadeType.MERGE，CascadeType.PERSIST，CascadeType.REFRESH，CascadeType.REMOVE}）//cascade！！！
公共集getTeams（）{
返回队；
}
公共队（集合队）{
这个。团队=团队；
}
}

删除不应与JPA 2.0规范中的@ManyToMany一起使用

关系建模注释限制cascade=REMOVE规范的使用。cascade=REMOVE规范应仅适用于指定为OneToOne或OneToMany的关联。将cascade=REMOVE应用于其他关联的应用程序是不可移植的

Hibernate中有供应商扩展@OnDelete：

---

@OnDelete（action=OnDeleteAction.CASCADE）

但是从团队中删除团队成员意味着什么？它应该解除TeamMemeber与团队的关联，还是确实要删除该团队成员？也许JPA/Hibernate对这种模糊性感到困惑