为什么要区分orm中双向关系的一方为拥有方？

Question

在一对多关系中，通常使用@ManyToOne注释的字段是所有者-另一方具有“mappedBy”属性。但是，如果我跳过“mappedBy”并用@JoinColumn（同一列）注释两侧，我可以更新两侧-更改将传播到db。

我没有两个单向关系而不是一个双向关系-只有一个连接列。

没有选择一方作为关系所有者会遇到什么问题？

我的实体看起来类似于以下内容：

@Entity
public class B {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;


   @ManyToOne
   @JoinColumn(name = "parent_id")
   @Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE})
   private B parent;

   @OneToMany()
   @JoinColumn(name = "parent_id")
   @Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE})
   private List<B> children = new ArrayList<B>();
...
}

它似乎对性能没有任何影响（至少看起来不错），下面是一个简单的测试和日志输出：

Session session = HibernateUtil.getSessionFactory().openSession();
    session.beginTransaction();
    B a = new B("a");
    B b = new B("b");
    B c = new B("c");
    B d = new B("d");
    B e = new B("e");
    session.save(a);
    session.save(b);
    session.save(c);
    session.save(d);
    session.save(e);
    session.getTransaction().commit();
    System.out.println("all objects saved");
    session.beginTransaction();
    a.getChildren().add(b);
    a.getChildren().add(c);
    session.save(a);
    session.getTransaction().commit();
    System.out.println("b and c added as children");
    session.beginTransaction();
    a.getChildren().add(d);
    a.getChildren().add(e);
    session.getTransaction().commit();
    System.out.println("e and f added as children");
    session.close();

Hibernate: insert into B (fieldInB, parent_id) values (?, ?)
Hibernate: insert into B (fieldInB, parent_id) values (?, ?)
Hibernate: insert into B (fieldInB, parent_id) values (?, ?)
Hibernate: insert into B (fieldInB, parent_id) values (?, ?)
Hibernate: insert into B (fieldInB, parent_id) values (?, ?)
all objects saved
Hibernate: update B set parent_id=? where id=?
Hibernate: update B set parent_id=? where id=?
b and c added as children
Hibernate: update B set parent_id=? where id=?
Hibernate: update B set parent_id=? where id=?
e and f added as children

Answer 1

这将是低效的，因为保存B将导致

• 更新对象B
• 将所有子对象的父引用更新到对象B
• 级联到更新其父引用的对象B的所有子对象

而不是

• 更新对象B
• 级联到对象B的所有子类，它们更新其父引用

Answer 2

我认为这篇文章可能会有所帮助，特别是我在下面提到的内容：

什么是使单向不等于双向的“东西”？当我们有单向关系时，只有Customer类引用User类；您只能按客户获取用户。getUser（）您不能用另一种方法。当我们编辑我们的用户类时，我们允许用户获取客户用户。getCustomer（）。

你也可以检查一下这个问题。

这个问题看起来也很有帮助。

主要的区别是双向关系在两个方向上提供导航访问，这样您就可以在没有显式查询的情况下访问另一方。它还允许您将级联选项应用于两个方向。

关于这个话题还有很多问题。这些将对您非常有帮助：）

Answer 3

您看不到额外的SQL语句，因为您没有正确设置关联的双方。例如，你说：

a.getChildren().add( b );

并假设a和b现在是关联的。但是当您在这里调用b.getParent（）时会发生什么？假设此代码“将b作为子级添加到a”，然后返回此新子级b，调用方希望导航b.getParent（）？

相反，你应该做的是：

a.getChildren().add( b );
b.setParent( a );

现在，您的惯用Java代码继续工作（b.get父母（）行为正常）。现在，您将在这里看到多个SQL语句。这就是为什么你需要选择一方作为“主人”。

此外，尽管完全是无稽之谈，但请考虑：

a.getChildren().add( b );
b.setParent( c );

这里写入数据库的是什么？双方实际上为b指定了不同的父级。那么我们相信什么呢？