JPA中实现双向一对多的关联关系

场景

jpa入门简介与搭建helloworld(附代码下载)：

https://blog.csdn.net/badao_liumang_qizhi/article/details/103473937

jpa中实现单向多对一的关联关系：

https://blog.csdn.net/badao_liumang_qizhi/article/details/103511623

jpa中实现单向一对多的关联关系：

https://blog.csdn.net/badao_liumang_qizhi/article/details/103520083

在上面已经搭建好jpa的helloworld程序后，以及进行单向一对多和单向多对一的映射关系。

如果是双向的一对多的映射应该怎样处理。

注：

博客主页：

关注公众号
霸道的程序猿
获取编程相关电子书、教程推送与免费下载。

实现

在之前进行单向一对多映射时将order类的customer属性注释掉，现在重新放开。

package com.badao.jpa.helloworld;

import javax.persistence.column;
import javax.persistence.entity;
import javax.persistence.generatedvalue;
import javax.persistence.generationtype;
import javax.persistence.id;
import javax.persistence.joincolumn;
import javax.persistence.manytoone;
import javax.persistence.table;

@table(name="jpa_orders")
@entity
public class order {
 private integer id;
 private string ordername;

 private customer customer;

 @generatedvalue(strategy = generationtype.identity)
 @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
 public customer getcustomer() {
  return customer;
 }

 public void setcustomer(customer customer) {
  this.customer = customer;
 }
}

 

同样在customer实体类中也要进行映射

package com.badao.jpa.helloworld;

import java.util.hashset;
import java.util.set;

import javax.persistence.cascadetype;
import javax.persistence.column;
import javax.persistence.entity;
import javax.persistence.fetchtype;
import javax.persistence.generatedvalue;
import javax.persistence.generationtype;
import javax.persistence.id;
import javax.persistence.joincolumn;
import javax.persistence.onetomany;
import javax.persistence.table;

@entity
@table(name="jpa_customers")
public class customer {
 
 
 private integer id;
 
 
 private string lastname;

 private string email;
 
 private int age;
 
 private set<order> orders = new hashset<>();
 
 //映射单向 1-n 的关联关系
 //使用 @onetomany 来映射 1-n 的关联关系
 //使用 @joincolumn 来映射外键列的名称
 //可以使用 @onetomany 的 fetch 属性来修改默认的加载策略
 //可以通过 @onetomany 的 cascade 属性来修改默认的删除策略. 
 //注意: 若在 1 的一端的 @onetomany 中使用 mappedby 属性, 则 @onetomany 端就不能再使用 @joincolumn 属性了. 
 @onetomany(fetch=fetchtype.lazy,cascade={cascadetype.remove},mappedby="customer")
 //@joincolumn(name="customer_id")
 public set<order> getorders() {
  return orders;
 }
 public void setorders(set<order> orders) {
  this.orders = orders;
 }
 
 
 @generatedvalue(strategy = generationtype.identity)
    @id
 public integer getid() {
  return id;
 }
 public void setid(integer id) {
  this.id = id;
 }
 
 @column(name="last_name")
 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;
 }
 @override
 public string tostring() {
  return "customer [id=" + id + ", lastname=" + lastname + ", email=" + email + ", age=" + age + "]";
 }

}

 

注：

若是双向 1-n 的关联关系, 执行保存时，若先保存 n 的一端, 再保存 1 的一端, 默认情况下, 会多出 n 条 update 语句。

若先保存 1 的一端, 则会多出 n 条 update 语句。

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

若在 1 的一端的 @onetomany 中使用 mappedby 属性, 则 @onetomany 端就不能再使用 @joincolumn 属性了

编写单元测试方法

  

@test
  public void testonetomanypersist(){
   customer customer = new customer();
   customer.setage(18);
   
   customer.setemail("[e-mail]");
   customer.setlastname("bb");
   
   order order1 = new order();
   order1.setordername("o-bb-1");
   
   order order2 = new order();
   order2.setordername("o-bb-2");
   
   //建立关联关系
   customer.getorders().add(order1);
   customer.getorders().add(order2);
   
   
   order1.setcustomer(customer);
   order2.setcustomer(customer);
   
   //执行保存操作
   entitymanager.persist(customer);

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

 

执行单元测试结果

order表

 

 

customer表