在双向 JPA OneTomany/ManyToOne 关联中，什么是“关联的反面”？

在 @OneToMany JPA 注释引用的示例部分:

示例1-59@OneTomany-具有泛型的客户类

@Entity
public class Customer implements Serializable {
...
@OneToMany(cascade=ALL, mappedBy="customer")
public Set<Order> getOrders() {
return orders;
}
...
}

例1-60@ManyToOne-Order Class With 泛型

@Entity
public class Order implements Serializable {
...
@ManyToOne
@JoinColumn(name="CUST_ID", nullable=false)
public Customer getCustomer() {
return customer;
}
...
}

在我看来，Customer实体是协会的所有者。但是，在同一文档中对 mappedBy属性的解释中写道:

如果关系是双向的, 然后将 mappedBy 元素设置为 反面(非拥有) 关联到字段的名称 或者拥有关系的财产 如例1-60所示。

但是，如果我没有错的话，在这个例子中，mappedBy实际上是在关联的拥有方指定的，而不是在非拥有方指定的。

所以我的问题基本上是:

  1. 在双向(一对多/多对一)关联中，哪个实体是所有者？我们如何指定一方为所有者？我们如何指定多方作为所有者？

  2. 什么是“关联的反面”？我们如何指定一边作为反面？我们如何指定多边作为反面？

125019 次浏览
小开
最佳答案

为了理解这一点，你必须后退一步。在 OO 中，客户拥有订单(订单是客户对象中的列表)。没有顾客就没有订单。因此，客户似乎是订单的所有者。

但在 SQL 世界中，一个项实际上包含指向另一个项的指针。因为 N 个订单只有1个客户，所以每个订单都包含它所属客户的外键。这是“连接”，这意味着订单“拥有”(或字面上包含)连接(信息)。这与面向对象/模型世界完全相反。

这可能有助于理解:

public class Customer {
// This field doesn't exist in the database
// It is simulated with a SQL query
// "OO speak": Customer owns the orders
private List<Order> orders;
}


public class Order {
// This field actually exists in the DB
// In a purely OO model, we could omit it
// "DB speak": Order contains a foreign key to customer
private Customer customer;
}

反面是对象的 OO“所有者”，在本例中是客户。客户在表中没有用于存储订单的列，因此必须告诉它可以在订单表中的哪个位置保存这些数据(通过 mappedBy进行)。

另一个常见的例子是带有节点的树，这些节点既可以是父节点，也可以是子节点。在这种情况下，这两个字段在一个类中使用:

public class Node {
// Again, this is managed by Hibernate.
// There is no matching column in the database.
@OneToMany(cascade = CascadeType.ALL) // mappedBy is only necessary when there are two fields with the type "Node"
private List<Node> children;


// This field exists in the database.
// For the OO model, it's not really necessary and in fact
// some XML implementations omit it to save memory.
// Of course, that limits your options to navigate the tree.
@ManyToOne
private Node parent;
}

这就解释了“外键”多对一的设计作品。还有第二种方法，它使用另一个表来维护关系。这意味着，对于我们的第一个示例，您有三个表: 一个是带有客户的表，一个是带有订单的表，还有一个包含两个主键对(customerPK，orderPK)的两列表。

这种方法比上面的方法更加灵活(它可以很容易地处理一对一、多对一、一对多甚至多对多)。代价就是

  • 它稍微慢一点(必须维护另一个表和连接使用三个表，而不是仅仅两个表) ,
  • 联接语法更加复杂(如果您必须手动编写许多查询，例如，当您尝试调试某些东西时，这可能会非常繁琐)
  • 它更容易出错，因为当管理连接表的代码出现错误时，可能会突然得到太多或太少的结果。

这就是为什么我很少推荐这种方法。

小开

在数据库中拥有外键表的实体是所有者实体，指向的另一个表是反向实体。

小开

令人难以置信的是，在3年的时间里，没有人用这两种方式的例子来回答你这个出色的问题。

正如其他人所提到的，“ owner”端包含数据库中的指针(外键)。您可以指定任何一方为所有者，但是，如果您指定一方为所有者，则关系将不是双向的(反过来也就是“许多”方将不知道它的“所有者”)。这对于封装/松散耦合是可取的:

// "One" Customer owns the associated orders by storing them in a customer_orders join table
public class Customer {
@OneToMany(cascade = CascadeType.ALL)
private List<Order> orders;
}


// if the Customer owns the orders using the customer_orders table,
// Order has no knowledge of its Customer
public class Order {
// @ManyToOne annotation has no "mappedBy" attribute to link bidirectionally
}

唯一的双向映射解决方案是让“ many”端拥有指向“ one”的指针，并使用@OneTomany“ mappedBy”属性。如果没有“ mappedBy”属性，Hibernate 将需要一个双重映射(数据库将同时拥有连接列和连接表，这是多余的(通常是不需要的))。

// "One" Customer as the inverse side of the relationship
public class Customer {
@OneToMany(cascade = CascadeType.ALL, mappedBy = "customer")
private List<Order> orders;
}


// "many" orders each own their pointer to a Customer
public class Order {
@ManyToOne
private Customer customer;
}
小开

对于两个实体类 Customer 和 Order，hibernate 将创建两个表。

可能个案:

  1. 在 Customer.java 和 Order.java Class then-> 中不使用 mappedBy

    在客户端将创建一个新表[ name = CUSTOMER _ ORDER ] ，它将保持 CUSTOMER _ ID 和 ORDER _ ID 的映射。这些是 Customer 和 Order 表的主键。 在 Order 端需要一个额外的列来保存对应的 Customer _ ID 记录映射

  2. MappedBy 在 Customer.java 中使用[如问题语句所示] 现在没有创建额外的表[ CUSTOMER _ ORDER ] ，在 Order Table

    3. 中只有一列

  3. Mappedby 在 Order.java 中使用 现在，将通过 hibernate 创建其他表 订单表中没有用于映射的附加列[ Customer _ ID ]。

任何一方都可以成为关系的所有者，但是最好选择 xxxToOne 方。

编码效果-> 只有拥有实体才能改变关系状态。在下面的例子中，BoyFriend 类是关系的所有者。即使女朋友想分手，她也不能。

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;


@Entity
@Table(name = "BoyFriend21")
public class BoyFriend21 {


@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "Boy_ID")
@SequenceGenerator(name = "Boy_ID", sequenceName = "Boy_ID_SEQUENCER", initialValue = 10,allocationSize = 1)
private Integer id;


@Column(name = "BOY_NAME")
private String name;


@OneToOne(cascade = { CascadeType.ALL })
private GirlFriend21 girlFriend;


public BoyFriend21(String name) {
this.name = name;
}


public BoyFriend21() {
}


public Integer getId() {
return id;
}


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


public String getName() {
return name;
}


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


public BoyFriend21(String name, GirlFriend21 girlFriend) {
this.name = name;
this.girlFriend = girlFriend;
}


public GirlFriend21 getGirlFriend() {
return girlFriend;
}


public void setGirlFriend(GirlFriend21 girlFriend) {
this.girlFriend = girlFriend;
}
}


import org.hibernate.annotations.*;
import javax.persistence.*;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.util.ArrayList;
import java.util.List;


@Entity
@Table(name = "GirlFriend21")
public class GirlFriend21 {


@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "Girl_ID")
@SequenceGenerator(name = "Girl_ID", sequenceName = "Girl_ID_SEQUENCER", initialValue = 10,allocationSize = 1)
private Integer id;


@Column(name = "GIRL_NAME")
private String name;


@OneToOne(cascade = {CascadeType.ALL},mappedBy = "girlFriend")
private BoyFriend21 boyFriends = new BoyFriend21();


public GirlFriend21() {
}


public GirlFriend21(String name) {
this.name = name;
}




public Integer getId() {
return id;
}


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


public String getName() {
return name;
}


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


public GirlFriend21(String name, BoyFriend21 boyFriends) {
this.name = name;
this.boyFriends = boyFriends;
}


public BoyFriend21 getBoyFriends() {
return boyFriends;
}


public void setBoyFriends(BoyFriend21 boyFriends) {
this.boyFriends = boyFriends;
}
}




import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import java.util.Arrays;


public class Main578_DS {


public static void main(String[] args) {
final Configuration configuration = new Configuration();
try {
configuration.configure("hibernate.cfg.xml");
} catch (HibernateException e) {
throw new RuntimeException(e);
}
final SessionFactory sessionFactory = configuration.buildSessionFactory();
final Session session = sessionFactory.openSession();
session.beginTransaction();


final BoyFriend21 clinton = new BoyFriend21("Bill Clinton");
final GirlFriend21 monica = new GirlFriend21("monica lewinsky");


clinton.setGirlFriend(monica);
session.save(clinton);


session.getTransaction().commit();
session.close();
}
}


import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import java.util.List;


public class Main578_Modify {


public static void main(String[] args) {
final Configuration configuration = new Configuration();
try {
configuration.configure("hibernate.cfg.xml");
} catch (HibernateException e) {
throw new RuntimeException(e);
}
final SessionFactory sessionFactory = configuration.buildSessionFactory();
final Session session1 = sessionFactory.openSession();
session1.beginTransaction();


GirlFriend21 monica = (GirlFriend21)session1.load(GirlFriend21.class,10);  // Monica lewinsky record has id  10.
BoyFriend21 boyfriend = monica.getBoyFriends();
System.out.println(boyfriend.getName()); // It will print  Clinton Name
monica.setBoyFriends(null); // It will not impact relationship


session1.getTransaction().commit();
session1.close();


final Session session2 = sessionFactory.openSession();
session2.beginTransaction();


BoyFriend21 clinton = (BoyFriend21)session2.load(BoyFriend21.class,10);  // Bill clinton record


GirlFriend21 girlfriend = clinton.getGirlFriend();
System.out.println(girlfriend.getName()); // It will print Monica name.
//But if Clinton[Who owns the relationship as per "mappedby" rule can break this]
clinton.setGirlFriend(null);
// Now if Monica tries to check BoyFriend Details, she will find Clinton is no more her boyFriend
session2.getTransaction().commit();
session2.close();


final Session session3 = sessionFactory.openSession();
session1.beginTransaction();


monica = (GirlFriend21)session3.load(GirlFriend21.class,10);  // Monica lewinsky record has id  10.
boyfriend = monica.getBoyFriends();


System.out.println(boyfriend.getName()); // Does not print Clinton Name


session3.getTransaction().commit();
session3.close();
}
}
小开

双向关系的简单规则:

1.对于多对一的双向关系来说，多方始终是关系的拥有方。例如: 1房间有许多人(一个人只属于一个房间)-> 拥有方是人

2. 对于一对一的双向关系，拥有方对应于包含相应外键的一方。

3. 对于多对多的双向关系，任何一方都可能是拥有方。

Hope 可以帮你。

小开

表关系与实体关系

在关系数据库系统中，只能有三种表关系:

  • 一对多(通过外键列)
  • 一对一(通过共享主密钥)
  • Many-to-many (通过两个外键引用两个独立父表的链接表)

因此，one-to-many表关系如下:

one-to-many table relationship

注意，关系基于子表中的 Foreign Key 列(例如，post_id)。

因此，在管理 one-to-many表关系时，只有一个真理来源。

现在，如果有一个映射到 one-to-many表关系上的双向实体关系，我们在前面看到过:

Bidirectional One-To-Many entity association

如果您看一下上面的图表，您会发现有两种方法来管理这种关系。

在 Post实体中，有 comments集合:

@OneToMany(
mappedBy = "post",
cascade = CascadeType.ALL,
orphanRemoval = true
)
private List<PostComment> comments = new ArrayList<>();

在 PostComment中，post关联映射如下:

@ManyToOne(
fetch = FetchType.LAZY
)
@JoinColumn(name = "post_id")
private Post post;

因此，有两个方面可以改变实体关联:

  • 通过在 comments子集合中添加一个条目，新的 post_comment行应该通过其 post_id列与父 post实体关联。
  • 通过设置 PostComment实体的 post属性，也应该更新 post_id列。

因为有两种表示外键列的方法，所以在将关联状态更改转换为等效的 Foreign Key 列值修改时，必须定义哪个是真值的来源。

MappedBy (也就是反面)

mappedBy属性告诉 @ManyToOne端负责管理 Foreign Key 列，集合仅用于获取子实体和将父实体状态更改级联到子实体(例如，删除父实体也应该删除子实体)。

之所以称为 反面，是因为它引用了管理此表关系的子实体属性。

同步双向关联的两端

现在，即使您定义了 mappedBy属性，并且子端 @ManyToOne关联管理外键列，您仍然需要同步双向关联的两端。

最好的方法是添加这两个实用方法:

public void addComment(PostComment comment) {
comments.add(comment);
comment.setPost(this);
}


public void removeComment(PostComment comment) {
comments.remove(comment);
comment.setPost(null);
}

addComment和 removeComment方法确保双方同步。因此，如果我们添加一个子实体，子实体需要指向父实体，而父实体应该将子实体包含在子集合中。


提交答案