Hibernate 许多奇怪的行为 我有两个实体“Person”和“Team”，它们通过使用注释的多对多关系进行映射，如下所示： 公共抽象类数据访问{ 私人实体经理； .... 公共无效更新（E对象）{ 试一试{ manager.getTransaction（）.begin（）； 合并（对象）； manager.getTransaction（）.commit（）； }捕获（例外e）{ .... } } .... }

这种结构确实有效，但我认为将团队对象添加到person对象的团队集合并更新团队对象是很奇怪的。 逻辑上是错的吗？我需要知道在这种关系中有一个主从特征或类似的东西

---

任何向导都将被视为

您的映射是错误的：您没有定义多对多双向关联，而是使用相同的联接表定义了两个多对多单向关联

双向关联始终具有所有者侧和反向侧。所有者端是不带

mappedBy

属性的端。反向侧必须具有

mappedBy

属性。想一想：为什么需要告诉Hibernate两次双向关联是如何映射的

映射应为：

@Entity
public class Person implements Serializable {
      ....
      private Collection<Team> teams;
      ....

     @ManyToMany(fetch = FetchType.LAZY)
     @Cascade({CascadeType.ALL})
     @JoinTable(name = "person_team",
            joinColumns = { @JoinColumn(name = "person_id")},
            inverseJoinColumns = {@JoinColumn(name = "team_id")})
     public Collection<Team> getTeams() {
        return advisers;
     }
}

@Entity
public class Team implements Serializable {
     ....
     private Collection<Person> persons;
     ....

     @ManyToMany(fetch = FetchType.LAZY, mappedBy = "teams")
     @Cascade({CascadeType.ALL})
     public Collection<Person> getPersons() {
        return advisers;
     }
}

@实体
公共类Person实现可序列化{
....
私人收集小组；
....
@ManyToMany（fetch=FetchType.LAZY）
@级联（{CascadeType.ALL}）
@JoinTable（name=“person\u team”，
joinColumns={@JoinColumn（name=“person_id”）}，
inverseJoinColumns={@JoinColumn（name=“team_id”）}）
公共集合getTeams（）{
返回顾问；
}
}
@实体
公共类团队实现了可序列化{
....
私人收藏者；
....
@ManyToMany（fetch=FetchType.LAZY，mappedBy=“teams”）
@级联（{CascadeType.ALL}）
公众人士（）{
返回顾问；
}
}

在这种情况下，所有者方是

个人

。这意味着要在人员和团队之间添加关联，需要将团队添加到人员的团队集合中。您可以选择以另一种方式映射，在这种情况下，您需要将人员添加到人员的团队集合中

---

另外，请注意，在多人关联上使用

CascadeType.ALL

确实令人怀疑：您真的想在删除团队时删除所有人员，并删除删除人员的所有团队，等等？

谢谢，请查看我以前的帖子：。

@Entity
public class Team implements Serializable {
      ....
      private Collection<Person> persons;
      ....

     @ManyToMany(fetch = FetchType.LAZY)
     @Cascade({CascadeType.ALL})
     @JoinTable(name = "person_team",
            joinColumns = { @JoinColumn(name = "team_id")},
            inverseJoinColumns = {@JoinColumn(name = "person_id")})
     public Collection<Person> getPersons() {
        return advisers;
     }
}

@Service("teamService")
public class TeamService extends DataAccess {
    ....
    public void addTeamToPerson(String teamId, String personId) {

        Team team= getTeam(teamId);
        Person person= personService.getPerson(personId);
        person.getTeams().add(team);
        super.update(team);
    }
    ....
}

public abstract class DataAccess<E> {

    private EntityManager manager;
    ....
    public void update(E object) {
        try {
            manager.getTransaction().begin();
            manager.merge(object);
            manager.getTransaction().commit();
        } catch (Exception e) {
            ....
        }
   }
   ....
}

@Entity
public class Person implements Serializable {
      ....
      private Collection<Team> teams;
      ....

     @ManyToMany(fetch = FetchType.LAZY)
     @Cascade({CascadeType.ALL})
     @JoinTable(name = "person_team",
            joinColumns = { @JoinColumn(name = "person_id")},
            inverseJoinColumns = {@JoinColumn(name = "team_id")})
     public Collection<Team> getTeams() {
        return advisers;
     }
}

@Entity
public class Team implements Serializable {
     ....
     private Collection<Person> persons;
     ....

     @ManyToMany(fetch = FetchType.LAZY, mappedBy = "teams")
     @Cascade({CascadeType.ALL})
     public Collection<Person> getPersons() {
        return advisers;
     }
}