JPA - 双向多对一映射

原创

程序员小默 2022-06-11 00:23:59 ©著作权

文章标签 jpa 双向多对一 hibernate 关联关系外键 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者程序员小默的原创作品，请联系作者获取转载授权，否则将追究法律责任

双向多对一关系中，必须存在一个关系维护端，在 JPA 规范中，要求 many 的一方作为关系的维护端(owner side), one 的一方作为被维护端(inverse side)。

可以在 one 方指定 @OneToMany 注释并设置 mappedBy 属性，以指定它是这一关联中的被维护端，many 为维护端。

在 many 方指定 @ManyToOne 注释，并使用 @JoinColumn 指定外键名称

【1】修改Order和Customer

Order：Customer = N:1。

Order如下：

@Table(name="JPA_ORDERS")
@Entity
public class Order {

  private Integer id;
  private String orderName;

  private Customer customer;

  @GeneratedValue
  @Id
  public Integer getId() {
    return id;
  }

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

  @Column(name="ORDER_NAME")
  public String getOrderName() {
    return orderName;
  }

  public void setOrderName(String orderName) {
    this.orderName = orderName;
  }

  //映射单向 n-1的关联关系
  //使用@ManyToOne来映射多对一的关联关系
  //使用@JoinColumn 来映射外键       
  //可使用 @ManyToOne 的fetch 属性来修改默认的关联属性的加载策略
  @JoinColumn(name="CUSTOMER_ID")
//  @ManyToOne(fetch=FetchType.LAZY)
  @ManyToOne(fetch=FetchType.EAGER)
  public Customer getCustomer() {
    return customer;
  }

  public void setCustomer(Customer customer) {
    this.customer = customer;
  }

}

Customer如下：

@NamedQuery(name="testNamedQuery", query="FROM Customer c WHERE c.id = ?")
@Cacheable(true)
@Table(name="JPA_CUTOMERS")
@Entity
public class Customer {

  private Integer id;
  private String lastName;

  private String email;
  private int age;
  
  private Date createdTime;
  private Date birth;
  
  public Customer() {
  }
  
  public Customer(String lastName, int age) {
    super();
    this.lastName = lastName;
    this.age = age;
  }



  private Set<Order> orders = new HashSet<>();

//  @TableGenerator(name="ID_GENERATOR",
//      table="jpa_id_generators",
//      pkColumnName="PK_NAME",
//      pkColumnValue="CUSTOMER_ID",
//      valueColumnName="PK_VALUE",
//      allocationSize=100)
//  @GeneratedValue(strategy=GenerationType.TABLE,generator="ID_GENERATOR")
  @GeneratedValue(strategy=GenerationType.AUTO)
  @Id
  public Integer getId() {
    return id;
  }

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

  @Column(name="LAST_NAME",length=50,nullable=false)
  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String getEmail() {
    return email;
  }

  public void setEmail(String email) {
    this.email = email;
  }

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }
  
  @Temporal(TemporalType.TIMESTAMP)
  public Date getCreatedTime() {
    return createdTime;
  }

  public void setCreatedTime(Date createdTime) {
    this.createdTime = createdTime;
  }

  @Temporal(TemporalType.DATE)
  public Date getBirth() {
    return birth;
  }

  public void setBirth(Date birth) {
    this.birth = birth;
  }
  
  //映射单向1-n的关联关系
  //使用@OneToMany 映射单向1-n的关联关系
  //使用@JoinColumn 来映射外键的名称
  //可以使用@OneToMany 的 fetch 属性来修改加载策略
  //可以使用@OneToMany 的 cascade 属性来修改默认的删除策略
  @JoinColumn(name="CUSTOMER_ID")
  @OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE})
  public Set<Order> getOrders() {
    return orders;
  }

  public void setOrders(Set<Order> orders) {
    this.orders = orders;
  }

  @Transient
  public String getInfo(){
    return "lastName: " + lastName + ", email: " + email;
  }

  @Override
  public String toString() {
    return "Customer [id=" + id + ", lastName=" + lastName + ", email="
        + email + ", age=" + age + ", createdTime=" + createdTime
        + ", birth=" + birth + "]";
  }

}

【2】双向多对一持久化操作

示例代码如下：

@Test
  public void testOneToManyPersist(){
    Customer customer = new Customer();
    customer.setAge(18);
    customer.setBirth(new Date());
    customer.setCreatedTime(new Date());
    customer.setEmail("mm@163.com");
    customer.setLastName("MM");
    
    Order order1 = new Order();
    order1.setOrderName("O-MM-1");
    
    Order order2 = new Order();
    order2.setOrderName("O-MM-2");
    
    //建立关联关系
    customer.getOrders().add(order1);
    customer.getOrders().add(order2);
    
    order1.setCustomer(customer);
    order2.setCustomer(customer);
    
    //执行保存操作
    entityManager.persist(customer);

    entityManager.persist(order1);
    entityManager.persist(order2);
  }

这里先保存了1的一端。

控制台输出如下：

Hibernate: 
    insert 
    into
        JPA_CUTOMERS
        (age, birth, createdTime, email, LAST_NAME) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=? 
    where
        id=?

如果先保存 n的一端呢，即先保存Order。

代码修改如下：

entityManager.persist(order1);
    entityManager.persist(order2);

    entityManager.persist(customer);

控制台输出如下：

Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_CUTOMERS
        (age, birth, createdTime, email, LAST_NAME) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=?,
        ORDER_NAME=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=?,
        ORDER_NAME=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=? 
    where
        id=?

综上可知：

若是双向 1-n 的关联关系, 执行保存时：

若先保存 n 的一端, 再保存 1 的一端, 默认情况下, 会多出2n 条 UPDATE 语句；
若先保存 1 的一端, 则会多出 n 条 UPDATE 语句。

故在进行双向 1-n 关联关系时, 建议使用 n 的一方来维护关联关系, 而 1 的一方不维护关联系, 这样会有效的减少 SQL 语句。

即，N的一端对应的表中使用外键关联1的一端，外键对应1的一端的表主键

【3】一的一端放弃维持关联关系

修改Customer实体类如下（放弃维持关联关系）：

//  @JoinColumn(name="CUSTOMER_ID")
  @OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE},mappedBy="customer")
  public Set<Order> getOrders() {
    return orders;
  }

注意: 若在 1 的一端的 @OneToMany 中使用 mappedBy 属性, 则 @OneToMany 端就不能再使用 @JoinColumn 属性了。

先保存N的一端时控制台输出如下：

Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_CUTOMERS
        (age, birth, createdTime, email, LAST_NAME) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=?,
        ORDER_NAME=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=?,
        ORDER_NAME=? 
    where
        id=?

先保存1 的一端时控制台输出如下：

Hibernate: 
    insert 
    into
        JPA_CUTOMERS
        (age, birth, createdTime, email, LAST_NAME) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)