Hibernate 不会删除 OneToMany 上的孤儿

Question

我有以下非常简单的一对多关系：

团队有一组球员：

@Entity(name = "TEAM")
@Access(AccessType.PROPERTY)
public class Team{
    private Integer id;
    private String name;
    private Set<Player> players ;

    @Id
    @Column(name = "id")
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "team_name")
    public String getName() {
        return name;
    }

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

    @OneToMany(cascade = {CascadeType.ALL},orphanRemoval=true)
    @JoinColumn(name = "TEAM_ID")
    public Set<Player> getPlayers() {
        return players;
    }

    public void setPlayers(Set<Player> players) {
        this.players = players;
    }       
}

每个玩家都有一个唯一的 id 和 name。

@Entity(name = "PLAYER")
@Access(AccessType.PROPERTY)
public class Player implements Serializable{

    private int id;
    private String name;

    @Id
    @Column(name = "id")
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    @Column(name = "player_name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public boolean equals(Object obj) {
    return id == ((Player)obj).id;
    }
    @Override
    public int hashCode() {
        return id;
    }
}

我运行了一个非常简单的代码：

Team team = createTeam(3) // creates team with 3 players ids={1,2,3}
session.saveOrUpdate(team);
...

private Team createTeam(int players) {
    Team team = new Team();
    team.setName("Bears");
    team.setId(1);
    for(int i=1 ; i<=players; ++ i){
        Player player = new Player();
        player.setId(i);
        player.setName("Player"+i);
        team.addPlayer(player);
    }
    return team;
}

我得到以下预期：

• 休眠：从 TEAM team_ 中选择 team_.id，team_.team_name 作为 team2_0_ where team_.id=?
• 休眠：选择 player_.id, player_.player_name as player2_1_ from PLAYER player_ where player_.id=?
• 休眠：选择 player_.id, player_.player_name as player2_1_ from PLAYER player_ where player_.id=?
• 休眠：选择 player_.id, player_.player_name as player2_1_ from PLAYER player_ where player_.id=?
• 休眠：插入 TEAM (team_name, id) 值 (?, ?)
• 休眠：插入 PLAYER (player_name, id) 值 (?, ?)
• 休眠：插入 PLAYER (player_name, id) 值 (?, ?)
• 休眠：插入 PLAYER (player_name, id) 值 (?, ?)
• 休眠：更新 PLAYER 设置 TEAM_ID=?哪里id=？ 休眠：更新 PLAYER 设置 TEAM_ID=?哪里id=？ 休眠：更新 PLAYER 设置 TEAM_ID=?哪里 id=?

然后我会这样做：

Team team = createTeam(2) // creates team with 2 player ids={1,2}
session.saveOrUpdate(team);

并且期望孤儿玩家被删除，但我得到：

• 休眠：从 TEAM team_ 中选择 team_.id，team_.team_name 作为 team2_0_ where team_.id=?
• 休眠：选择 player_.id, player_.player_name as player2_1_ from PLAYER player_ where player_.id=?
• 休眠：选择 player_.id, player_.player_name as player2_1_ from PLAYER player_ where player_.id=?
• 休眠：更新 PLAYER 设置 TEAM_ID=null where TEAM_ID=?
• 休眠：更新 PLAYER 设置 TEAM_ID=?哪里 id=?
• 休眠：更新 PLAYER 设置 TEAM_ID=?哪里 id=?

这会使孤儿播放器 (id=3) 断开连接但未删除... 任何想法我做错了什么？

Answer 1

如果您希望将球员作为删除孤儿删除，则需要球员失去对球队的引用并保存球队。

你正在做的事情如下：

• 创建一个新的对象团队。
• 为团队提供 3 名球员
• 坚持

之后，每个玩家行将包含一个 FK 到团队 (id=1)。

然后代码创建一个具有相同 id 的新团队，并养活 2 个玩家并坚持下去。

到那时，数据库中仍然会有一名球员引用球队 1。

从我的 POV 来看，每个不同的业务对象都应该有自己的业务密钥。如果要覆盖第1队的球员，则应先检索id = 1的球队，然后再喂球员。

private Team createTeam(int players) {
    Team team = session.get(Team.class, 1);
    if (team == null) {
       team = new Team();
       team.setName("Bears");
       team.setId(1);
    }
    team.clearPlayers();

    for(int i=1 ; i<=players; ++ i){
        Player player = new Player();
        player.setId(i);
        player.setName("Player"+i);
        team.addPlayer(player);
    }
    return team;
}

// Team.java
private void clearPlayers() {
   players.clear();
}

顺便说一句，另一个建议。不允许直接修改您的播放器，这可能会导致 HibernateErrors，例如 “不要更改对集合的引用...”。代替 setPlayers()，添加 addPlayer() 和 removePlayer() 的方法

private void adddPlayer(Player player) {
   player.setTeam(this);
   players.add(player);
}

private void removePlayer(Player player) {
   player.setTeam(null);
   players.remove(player);
}

另外，集合是可变的，所以让 getPlayers() 返回一个不可修改的集合：

private Set<Player> getPlayers() {
   return Collections.unmodifiableSet(players);
}

希望这能有所启发:)

Answer 2

你可以使用这个标签： @org.hibernate.annotations.Cascade（值 = org.hibernate.annotations.CascadeType.DELETE_ORPHAN）。所以你得到：

@OneToMany(cascade = {CascadeType.ALL},orphanRemoval=true) @org.hibernate.annotations.Cascade（值 = org.hibernate.annotations.CascadeType.DELETE_ORPHAN） @JoinColumn(name = "TEAM_ID")

Answer 3

在两个实体的关系中添加 mappedBy 属性。

在播放器中添加团队。

// in Player.java
@ManyToOne(mappedBy="players")
private Team team;

播放器中的 MappeedBy。

//In Team.java
@OneToMany(cascade = {CascadeType.ALL},orphanRemoval=true,mappedBy="team")
    @JoinColumn(name = "TEAM_ID")
    public Set<Player> getPlayers() {
        return players;
    }

当您有 1-TO-M 关系时，孩子应该有其父母的参考。然后hibernate在内部使用父ID作为子表中的外来词。

您的子表将包含以下 3 列：

id , player_name,team_id