场景

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

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

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

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

在上面搭建好jpa的helloworld程序后，以及实现单向多对一的关联关系后。

单向多对一是在order层添加customer信息，即在order实体类中添加

private customer customer;

这样多个order订单类就能映射到同一个用户，实现单向多对一。

如果要实现单向一对多的映射关系，就要在customer层中添加order的集合，进而实现单向一对多的映射。

注：

博客主页：

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

实现

将之前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类中添加order的集合

private set<order> orders = new hashset<>();

以及相应的set和get方法

public set<order> getorders() {
  return orders;
 }

public void setorders(set<order> orders) {
  this.orders = orders;
 }

 

然后在get方法中添加注解

@joincolumn(name="customer_id")
 @onetomany
 public set<order> getorders() {
  return orders;
 }
 public void setorders(set<order> orders) {
  this.orders = orders;
 }

 

注：

使用 @onetomany 来映射 1-n 的关联关系

使用 @joincolumn 来映射外键列的名称

编写单元测试类进行测试

  

@test
  public void testonetomanypersist(){
   customer customer = new customer();
   customer.setage(18);
   
   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);
   
   
   //执行保存操作
   entitymanager.persist(customer);

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

 

运行单元测试类效果

数据库中订单表

 

 

数据库中用户表

 

 

测试一对多find方法

编写单元测试方法

@test
  public void testonetomanyfind(){
   customer customer = entitymanager.find(customer.class, 6);
   system.out.println(customer.getlastname());
   
   system.out.println(customer.getorders().size());
  }

 

运行效果

注：

默认对关联的多的一方使用懒加载的加载策略。

可以使用 @onetomany 的 fetch 属性来修改默认的加载策略

比如：@onetomany(fetch=fetchtype.lazy)

测试一对多删除方法

新建单元测试方法

 @test
 public void testonetomanyremove(){
  customer customer = entitymanager.find(customer.class, 8);
  entitymanager.remove(customer);
 }

注：

默认情况下, 若删除 1 的一端, 则会先把关联的 n 的一端的外键置空,然后进行删除。

可以通过 @onetomany 的 cascade属性来修改默认的删除策略。

比如：@onetomany(fetch=fetchtype.lazy,cascade={cascadetype.remove})

测试一对多更新方法

新建单元测试方法

  @test
  public void testupdate(){
   customer customer = entitymanager.find(customer.class, 6);
   
   customer.getorders().iterator().next().setordername("o-xxx-10");
  }