双向JPA OneToMany / ManyToOne关联中的“关联的反面”是什么?


167

@OneToManyJPA注释参考的示例部分中:

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

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

示例1-60 @ManyToOne-具有泛型的Order类

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

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

如果关系是双向的,则将关联的反(非所有权)侧的maptedBy元素设置为拥有该关系的字段或属性的名称,如示例1-60所示。

但是,如果我没有记错的话,那么在示例中,mappedBy实际上是在关联的拥有方而不是非拥有方中指定的。

所以我的问题基本上是:

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

  2. “关联的反面”是什么意思?我们如何将一侧指定为逆?我们如何将“多面”指定为反面?


1
您提供的链接已过时。请更新。
MartinL 2012年

Answers:


306

要了解这一点,您必须退后一步。在OO中,客户拥有订单(订单是客户对象中的列表)。没有客户就无法下订单。因此,客户似乎是订单的所有者。

但是在SQL世界中,一项实际上将包含指向另一项的指针。由于N个订单有1个客户,因此每个订单都包含指向其所属客户的外键。这是“连接”,这意味着顺序“拥有”(或字面上包含)连接(信息)。这与OO /模型世界完全相反。

这可能有助于了解:

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)的两列表。

这种方法比上面的方法更灵活(它可以轻松处理一对一,多对一,一对多,甚至多对多)。价格是

  • 有点慢(必须维护另一个表,并且联接使用三个表而不是两个表),
  • 连接语法更加复杂(如果您必须手动编写许多查询(例如,当您尝试调试某些内容时)可能会很繁琐)
  • 它更容易出错,因为当管理连接表的代码出现问题时,您突然会获得太多或太少的结果。

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


36
需要澄清的是:多方是所有者;多方是所有者。一侧是相反的。您别无选择(实际上)。
约翰,2010年

11
不,Hibernate发明了这个。我不喜欢它,因为它将部分实现暴露给OO模型。我更喜欢用a @Parent@Child注解代替“ XtoY”来说明连接的含义(而不是如何实现
Aaron Digulla 2010年

4
@AaronDigulla每次我必须通过OneToMany映射时,我都会阅读此答案,这可能是关于SO主题的最佳选择。
尤金(Eugene)2012年

7
哇。如果只有ORM框架文档有这么好的解释-它将使整个工作更容易被吞噬!很好的答案!
NickJ 2013年

2
@klausch:Hibernate文档令人困惑。忽略它。查看代码,数据库中的SQL以及外键如何工作。如果您愿意,可以带点智慧:文档是谎言。使用消息来源卢克。
亚伦·迪古拉

41

令人难以置信的是,在过去三年中,没有人用两种方式来描述您的关系来回答您的出色问题。

就像其他人提到的那样,“所有者”端包含数据库中的指针(外键)。您可以将任一侧指定为所有者,但是,如果将一侧指定为所有者,则关系将不会是双向的(反称“许多”侧将不知道其“所有者”)。这对于封装/松散耦合可能是理想的:

// "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
}

唯一的双向映射解决方案是让“许多”一侧拥有其指向“一个”的指针,并使用@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;
}

2
在您的单向示例中,JPA希望存在一个额外的customer_orders表。使用JPA2时,可以在Customer的orders字段上使用@JoinColumn批注(我似乎经常使用),以表示应该使用的Order表中的数据库外键列。这样,您在Java中具有单向关系,同时在Order表中仍具有外键列。因此,在对象世界中,订单不了解客户,而在数据库世界中,客户不了解订单。
Henno Vermeulen

1
为了更全面,您可以显示双向情况,其中客户是关系的拥有方。
HDave

35

数据库中具有带有外键的表的实体是拥有实体,而所指向的另一个表是反向实体。


30
甚至更简单:所有者是带有FK列的表格
jacktrades 2012年

2
简单而良好的解释。任何一方都可以成为所有者。如果在Order.java中的Customer字段<从Customer.java中删除mapbyby>上使用mapledBy,则会创建一个新表,例如Order_Customer,该表将有2列。ORDER_ID和CUSTOMER_ID。
HakunaMatata

14

双向关系的简单规则:

1.对于多对一的双向关系,多方总是关系的拥有方。示例:1个房间有多个人(一个人仅属于一个房间)->拥有方是人

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

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

希望可以帮到您。


为什么我们需要一个所有者和一个逆函数呢?我们已经有了单边和多边的有意义的概念,在多对多情况下谁是所有者并不重要。决定的后果是什么?很难相信一个像数据库工程师这样干left的人决定创造这些多余的概念。
Dan Cancro

3

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

可能的情况:

  1. 在Customer.java和Order.java类中不使用mappedBy,然后->

    在客户方,将创建一个新表[name = CUSTOMER_ORDER],该表将保留CUSTOMER_ID和ORDER_ID的映射。这些是客户表和订单表的主键。在订单端,需要另外一列以保存相应的Customer_ID记录映射。

  2. Customer.java中使用了appedBy [问题说明中已给出]现在不创建其他表[CUSTOMER_ORDER]。订单表中只有一列

  3. Order.java中使用了appedby。现在,hibernate将创建附加表。[名称= CUSTOMER_ORDER]订单表将没有用于映射的附加列[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

表关系与实体关系

在关系数据库系统中,只能有三种类型的表关系:

  • 一对多(通过“外键”列)
  • 一对一(通过共享的主键)
  • 多对多(通过带有两个外键的链接表引用两个单独的父表)

因此,one-to-many表关系如下所示:

<code>一对多</ code>表关系

请注意,该关系基于post_id子表中的外键列(例如)。

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

现在,如果您采用映射到one-to-many表关系上的双向实体关系,那么我们之前会看到:

双向<code>一对多</ code>实体关联

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

Post实体中,您具有以下comments集合:

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

并且,在中PostCommentpost关联映射如下:

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

因此,您有两个方面可以更改实体关联:

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

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

MappedBy(又称反面)

mappedBy属性告诉该@ManyToOne方负责管理“外键”列,并且该集合仅用于获取子实体并将父实体状态更改级联给子实体(例如,删除父实体也应删除子实体)。

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

同步双向关联的两端

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

最好的方法是添加以下两个实用程序方法:

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

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

addCommentremoveComment方法确保双方是同步的。因此,如果我们添加子实体,则该子实体需要指向父实体,并且该父实体应在子集合中包含该子实体。

有关同步所有双向实体关联类型的最佳方法的更多详细信息,请参阅本文

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.