jpa--11.双向一多

最新推荐文章于 2022-05-22 03:30:00 发布
最新推荐文章于 2022-05-22 03:30:00 发布
阅读量194 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26553781/article/details/79775376
版权

1      双向一多

1.1  概念

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

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

 

1.2  配置

一个订单只有一个用户，一个用户多个订单

   使用 @ManyToOne 来映射多对一的关联关系， fetch 属性来修改默认的关联属性的加载策略

   使用 @JoinColumn 来映射外键.

   @JoinColumn(name="CUSTOMER_ID")

   @OneToMany

 

@JoinColumn(name="CUSTOMER_ID")

   @ManyToOne(fetch=FetchType.LAZY)

 

1.3  数据生成信息

Order表会产生外键

 

1.4  测试准备

1.4.1  Customer

@Table(name="JPA_CUTOMERS")
@Entity
public classCustomer {
 
   private Integer id;
   private String lastName;
 
   private String email;
   private int age;
 
   private Date createdTime;
   private Date birth;
 
   private Set<Order> orders = new HashSet<>();
 
   @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 的关联关系
   // 1.使用 @OneToMany 来映射 1-n 的关联关系;使用 @JoinColumn 来映射外键列的名称
   // 2.可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略
   // 3.可以通过 @OneToMany 的 cascade 属性来修改默认的删除策略.
// @JoinColumn(name="CUSTOMER_ID")
// @OneToMany
// @OneToMany(fetch=FetchType.EAGER)
// @OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE})
@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE},mappedBy="customer")
   public Set<Order>getOrders() {
      return orders;
   }
 
   public voidsetOrders(Set<Order> orders) {
      this.orders = orders;
   }
 
}

1.4.2  Order

@Table(name="JPA_ORDERS")
@Entity
public classOrder {
 
   private Integer id;
   private String orderName;
 
   @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;
   }
 
}

1.4.3  准备JPATest

public classJPATest {
 
   private EntityManagerFactory entityManagerFactory;
   private EntityManager entityManager;
   private EntityTransaction transaction;
  
   @Before
   public void init(){
      entityManagerFactory= Persistence.createEntityManagerFactory("jpa_test1");
      entityManager = entityManagerFactory.createEntityManager();
      transaction = entityManager.getTransaction();
      transaction.begin();
   }
  
   @After
   public void destroy(){
      transaction.commit();
      entityManager.close();
      entityManagerFactory.close();
   }
}

2      操作

2.1  保存（双向维护）

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

   //1.若先保存 n 的一端, 再保存 1 的一端, 默认情况下, 会多出 n 条 UPDATE 语句.

   //2.若先保存 1 的一端,再保存 n 的一端, 则会多出 n*2 条 UPDATE 语句

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

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

 

2.1.1  先一再n

//若是双向 1-n 的关联关系, 执行保存时
   //1.若先保存 n 的一端, 再保存 1 的一端, 默认情况下, 会多出 n 条 UPDATE 语句.
   // 1.1 先插入customer，得到id，此时customer_id有值，插入order
   // 1.2 只需要维护多方外键关联关系，
   @Test
   public voidtestOneToManyPersist1(){//先n再一
      Customercustomer= newCustomer();
      customer.setAge(18);
      customer.setBirth(new Date());
      customer.setCreatedTime(new Date());
      customer.setEmail("mm@163.com");
      customer.setLastName("MM");
 
      Orderorder1= newOrder();
      order1.setOrderName("O-MM-1");
 
      Orderorder2= newOrder();
      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);
   } 

22

2.1.2  先n再一

//2.若先保存 1 的一端,再保存 n 的一端, 则会多出 n方*2 条 UPDATE 语句
   // 2.1 先插入order，此时customer_id为空，再插入customer，得到id
   // 2.2先维护多方外键关联关系，
   // 2.3由于双向维护，再维护一方外键关系，实际是不需要的
   @Test
   public voidtestOneToManyPersist2(){//先n再一
      Customercustomer= newCustomer();
      customer.setAge(18);
      customer.setBirth(new Date());
      customer.setCreatedTime(new Date());
      customer.setEmail("mm@163.com");
      customer.setLastName("MM");
 
      Orderorder1= newOrder();
      order1.setOrderName("O-MM-1");
 
      Orderorder2= newOrder();
      order2.setOrderName("O-MM-2");
 
      //建立关联关系
      customer.getOrders().add(order1);
      customer.getOrders().add(order2);
 
      order1.setCustomer(customer);
      order2.setCustomer(customer);
 
      //执行保存操作
      entityManager.persist(order1);
      entityManager.persist(order2);
     
      entityManager.persist(customer);
   }


2.1.3  一方放弃维护，只维护多方（推荐）

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

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

   //@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE},mappedBy="customer")

 

2.2  查询（oid）

2.2.1  默认懒加载


//默认对关联的多的一方使用懒加载的加载策略.
   //可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略
   @Test
   public void testOneToManyFind(){
      Customercustomer= entityManager.find(Customer.class, 3);
      System.out.println(customer.getLastName());
 
      System.out.println(customer.getOrders().size());
   }

 

2.2.2  正常加载（EAGER）


修改默认的加载策略



2.3  删除（一方）

2.3.1  外键置空，只删一方

//默认情况下, 若删除 1 的一端, 则会先把关联的 n 的一端的外键置空, 然后进行删除.
   //可以通过 @OneToMany 的 cascade 属性来修改默认的删除策略.
   @Test
   public void testOneToManyRemove(){
      Customercustomer= entityManager.find(Customer.class, 8);
      entityManager.remove(customer);
   }

2.3.2  外键置空，都删

//可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略
@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE})

2.4  更新

 

只要是针对一方，多方就直接单表了

@Test
   public void testUpdate(){
      Customercustomer= entityManager.find(Customer.class, 3);
     
      customer.getOrders().iterator().next().setOrderName("O-XXX-10");
   }


 

 源码：https://download.csdn.net/download/qq_26553781/10320460

 

//默认对关联的多的一方使用懒加载的加载策略.
   //可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略
   @Test
   public void testOneToManyFind(){
      Customercustomer= entityManager.find(Customer.class, 3);
      System.out.println(customer.getLastName());
 
      System.out.println(customer.getOrders().size());
   }

qq_26553781
关注
JPA知识详解
weixin_41005188的博客
08-17 799
JPA知识详解JPA简介使用JPA持久化对象的步骤JPA 基本注解JPA API映射关联关系使用二级缓存JPQLSpring 整合 JPAJ2EE的概念以及容器概念总结 JPA简介 JPA定义： Java Persistence API：用于对象持久化的 API Java EE 5.0 平台标准的 ORM 规范，使得应用程序以统一的方式访问持久层 JPA 是 hibernate 的一个抽象（就像JDBC和JDBC驱动的关系） JPA 是规范：JPA 本质上就是一种 ORM 规范，不是ORM 框架 ——
JPA OneToOne双向关系
Jc0803kevin的专栏
05-01 1603
1：1(双向) 关系被维护端 关系维护端（负责外键字段的更新） 主表 从表 public class IDCard{ public class Person{ private Person person;
双向一对多中的删除操作
I'm Sure
12-10 138
背景：双向一对多，比如是dad-sons，cascade为all 目的：想删除“多”的这边 做法： [code="java"]dad.setSons(null); 循环Sons{ son.setDad(null); delete(son); }[/code]另外： 也可以在dad这边设置cascade属性设为"all-delete-orphan"，那么 [code...
JPA双向一对多和多对一
曾今拼命的想，现在却拼命的忘
11-05 1599
JPA中一对多和多对一双向关系中，多的一方为关系维护端 。mappedBy的一方为关系被维护端。 关系维护端负责外键纪录的更新 ，关系被维护端是没有权力更新外键纪录的。 只能通过关系维护端设置与关系被维护端的关系。 １、一对多： @OneToMany( cascade = { CascadeType.PERSIST, C
Entity Bean (3) : 一对多关系[转]
Tomson Xu
07-23 2631
 知识点：双向一对多关系，一是关系维护端（owner side），多是关系被维护端（inverse side）。在关系被维护端需要通过@JoinColumn建立外键列指向关系维护端的主键列。  publicclass Order implements Serializable {    privateSet orderItems = new HashSet();      
jpa--12.双向一一
村西头的俏寡妇
04-01 160
1      双向一一 1.1  概念 基于外键的 1-1 关联关系：在双向的一对一关联中，需要在关系被维护端(inverse side)中的 @OneToOne 注释中指定mappedBy，以指定是这一关联中的被维护端。同时需要在关系维护端(owner side)建立外键列指向关系被维护端的主键列。   1.2  配置（建议单向维护） 一个经理只有一个部门，一个部门只有一个经理，部门（
JPA - 双向多对一映射
小小默：进无止境
12-10 842
【1】修改Order和CustomerOrder：Customer = N:1。Order如下：@Table(name="JPA_ORDERS") @Entity public class Order { private Integer id; private String orderName; private Customer customer; @GeneratedVa
JPA - 双向多对多映射
小小默：进无止境
12-11 4058
在双向多对多关系中，我们必须指定一个关系维护端(owner side),可以通过 @ManyToMany 注释中指定 mappedBy 属性来标识其为关系维护端。【1】item与Categoryitem:category = N:N 。item类如下：@Table(name=&quot;JPA_ITEMS&quot;) @Entity public class Item { private Integer id;
Spring Data JPA ---多表关联
guoguo0717的博客
05-22 659
多表关联操作 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.22</version> </dependency> 一对一 客户表 —> 老婆表 客户表 —> 账户表 … 实现: @OneToOne
官方完整包 spring-framework-5.3.8.RELEASE-dist.zip
06-11
Spring Framework 5.3.8 RELEASE 是一个重要的Java应用程序开发框架，它由Pivotal Software公司维护，并被广泛用于构建企业级的Java应用。这个官方完整包“spring-framework-5.3.8.RELEASE-dist.zip”包含了Spring...
spring-5.3.3-dist.zip
02-03
5. **Spring Data**：这是一个模块，用于简化数据库访问，支持JPA、JDBC、MongoDB等多种数据存储方式，提供了一致的API来操作数据。 6. **Spring Security**：它是Spring框架的安全模块，提供了一套全面的安全管理...
jpa--10.单向一对多
03-31
在Java Persistence API (JPA) 中，"单向一对多"是一种常见的关系映射类型，它代表了数据库中两个实体间的一种关联。这种关联意味着一个实体（“一方”）可以与多个其他实体（“多方”）相关联，而反过来，多方并不...
1727008980062_36899042-cccb-455e-a366-ade300382e2a.mp3
最新发布
09-22
1727008980062_36899042-cccb-455e-a366-ade300382e2a.mp3
基于Java和Lua的美食社交APP设计源码
09-22
本项目是基于Java和Lua开发的美食社交APP，包含92个文件，其中包括80个Java源代码文件、4个XML配置文件、2个PNG图像文件、2个Lua脚本文件、1个LICENSE文件、1个Markdown文档文件和1个YAML配置文件。此外，还有1个SQL文件。该项目旨在为用户提供一个便捷、高效的美食社交平台，支持美食分享、社交互动、活动组织等功能，以提升用户体验和社区活跃度。
模数转换器(ADC)技术解析及应用指南
09-22
内容概要：本文全面介绍了模数转换器(ADC)的相关知识和技术，包括ADC的基本原理、关键技术参数、不同类型ADC的工作方式及其应用领域。并通过生动的比喻解释ADC的概念，强调其在日常生活中的实际应用，并提供了选型指南以及对未来发展方向进行了预测。 适用人群：具备一定模拟电子基础知识的研发人员及电子工程专业师生。 使用场景及目标：指导相关人员正确理解和选用ADC，并提升对最新发展的认知。适用于工业、消费电子、汽车电子、通讯和医疗器械等行业。 阅读建议：读者应重点学习ADC的关键指标及各参数间的关联性，并尝试联系具体的应用场景来加深理解。此外还推荐读者扩展学习相关设计实例和技术文章，以更好地吸收和运用知识内容。
基于微信小程序的碎片化驾考论文.docx
09-22
基于微信小程序的碎片化驾考论文
JavaEE 实验报告：使用JPA实现双向多对一关联映射
"JavaEE 第8次实验报告，涵盖了JPA的使用和双向多对一关联映射的实现" 实验报告详细介绍了Java Enterprise Edition (JavaEE) 的一部分——使用Java Persistence API (JPA)来实现双向多对一关联映射。JPA是Java平台...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值