实体Customer:用户。

  实体Order:订单。

  Customer和Order是一对多关系。那么在JPA中,如何表示一对多的双向关联呢?

  JPA使用@OneToMany和@ManyToOne来标识一对多的双向关联。一的一端(Customer)使用@OneToMany,多端(Order)使用@ManyToOne。

  在JPA规范中,一对多的双向关系由多端(Order)来维护。就是说多端(Order)为关系维护端,负责关系的增删改查。一端(Customer)则为关系被维护端,不能维护关系。

  一端(Customer)@OneToMany注释的mappedBy="customer"属性表明Customer是关系被维护端。

  多端(Order)使用@ManyToOne和@JoinColumn来注释属性CUSTOMER_ID,@ManyToOne表明Order是多端,@JoinColumn设置在Order表中的关联字段(外键)。

Customer实体类如下:

/**
*数据库持久化类
* @author z
*
*/
@Table(name="JPA_CUSTOMERS")//主要是映射表名对应的数据库表名JPA_CUSTOMER默认情况下可以不写表名与持久化类名相同
@Entity //表明这是一个持久化类
public class Customer { private Integer id;
private String lastName;
private String email;
private int age ; private Date createdTime;
private Date birth; /**
* 单向一对多关系映射
* 1、添加多的一方的集合属性
*/
private Set<Order> orders=new HashSet<>(); /**
* 定义各数据列必须加在get方法上
* @return
*/
//定义主键,生成主键的策略AUTO自动的根据数据的类型生成主键
@GeneratedValue(strategy=GenerationType.AUTO)
@Id //定义数据列
// @Column(name="ID")//定义数据库的列名如果与字段名一样可以省略 //使用table生成主键
// @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")
// @Id
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
} @Column(name="LAST_NAME",length=,nullable=false) //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;
} //映射单向一对多的关联关系
//使用@OneToMany 来映射一对多的关联关系
//使用@JoinColumn 来映射外键列的名称
//可以使用@OneToMany的fetch 属性来修改默认的加载策略
//可以通过@OneToMany的cascade 属性来修改默认的删除策略
//cascade={CascadeType.REMOVE} 会把主表和从表的数据都删除
//mappedBy表明放弃关联关系维护并且不能在使用
//注意:若在一的一端@oneToMany 中使用mapperBy属性,则@oneToMany端就不能在使用@JoinColumn(name="CUSTOMER_ID")属性
// @JoinColumn(name="CUSTOMER_ID")
@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE},mappedBy="customer")
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 + "]";
} }

 

多的一端实体类Order如下:

/**
* 单向多对一
* 一个订单可以有多个用户
* 一个用户可以有多个订单
* @author z
*
*/
@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)
public Customer getCustomer() {
return customer;
} public void setCustomer(Customer customer) {
this.customer = customer;
} @Override
public String toString() {
return "Order [id=" + id + ", orderName=" + orderName + ", customer=" + customer+ "]";
} }

简单的测试类

public class JPATest {
private EntityManagerFactory entityManagerFactory;
private EntityManager entityManager;
private EntityTransaction transaction;
@Before
public void init(){
entityManagerFactory= Persistence.createEntityManagerFactory("jpa-1");
entityManager=entityManagerFactory.createEntityManager();
transaction=entityManager.getTransaction();
transaction.begin();//开启事务 }
@After
public void destroy(){
transaction.commit();
entityManager.close();
entityManagerFactory.close();
} //修改
@Test
public void testUpdate(){
Customer customer=entityManager.find(Customer.class, );
customer.getOrders().iterator().next().setOrderName("O-XXX-10"); } //删除
//默认情况下,若删除1的一端,则会先把关联的多的一段的外键置空,然后删除一的一端
////可以通过@OneToMany的cascade 属性来修改默认的删除策略
@Test
public void testOneToManyRemove(){
Customer customer=entityManager.find(Customer.class, );
entityManager.remove(customer); } //默认对关联多的一方使用懒加载的加载策略(延迟加载)
//可以使用@OneToMany的fetch 属性来修改默认的加载策略
//查询
@Test
public void testOneToManyFind(){
Customer customer=entityManager.find(Customer.class,);
System.out.println(customer.getLastName()); System.out.println(customer.getOrders().size()); } //双向一对多的关联关系在执行保存时
//若先保存多的一端,在保存一的一端,默认情况下,会多出四条update语句
//若先保存一的一端则会多出2(n)条update语句
//在进行双向一对多的关联关系时,建议使用多的一方来维护关联关系,而1的一方不维护关联关系,这样会有效的减少sql语句
//注意:若在一的一端@oneToMany 中使用mapperBy属性,则@oneToMany端就不能在使用@JoinColumn(name="CUSTOMER_ID")属性//保存
@Test
public void testOneToManyPersist(){
Customer customer=new Customer();
customer.setAge();
customer.setBirth(new Date());
customer.setCreatedTime(new Date());
customer.setEmail("CC@163.com");
customer.setLastName("AA"); Order order1=new Order();
order1.setOrderName("o-CC-1"); Order order2=new Order();
order2.setOrderName("o-CC-2"); //建立关联关系
customer.getOrders().add(order1);
customer.getOrders().add(order2);
//执行保存操作
entityManager.persist(customer);
entityManager.persist(order1);
entityManager.persist(order2); }
}

源码地址:https://github.com/wuhongpu/JPA.git

JPA的一对多映射(双向)关联的更多相关文章

  1. JPA学习---第九节:JPA中的一对多双向关联与级联操作

    一.一对多双向关联与级联操作 1.创建项目,配置文件代码如下: <?xml version="1.0" encoding="UTF-8"?> < ...

  2. 【Hibernate步步为营】--(一对多映射)之双向关联

    上篇文章讨论了单向关联的一对多映射,在一的一端维护双向的关系这样的做法尽管能实现可是存在非常多缺陷,首先生成非常多多余的SQL语句,由于多的一端不维护关系,仅仅有一的一端维护,在进行操作时一的一端会发 ...

  3. JPA中的一对多双向关联与级联操作

    学习Spring有两周时间了 , 个人觉得服务端主要实现的是数据关系的维护和数据结构的制定 , 以及由业务需求产生的CRUD , 只要保证对前端提供的接口稳定高效响应 , 具体的前端实现完全不关心. ...

  4. Hibernate从入门到精通(九)一对多双向关联映射

    上次的博文Hibernate从入门到精通(八)一对多单向关联映射中,我们讲解了一下一对多单向映射的相关内容,这次我们讲解一下一对多双向映射的相关内容. 一对多双向关联映射 一对多双向关联映射,即在一的 ...

  5. Hibernate(九)一对多双向关联映射

    上次的博文Hibernate从入门到精通(八)一对多单向关联映射中,我们讲解了一下一对多单向映射的相关 内容,这次我们讲解一下一对多双向映射的相关内容. 一对多双向关联映射 一对多双向关联映 射,即在 ...

  6. JPA中实现双向多对多的关联关系(附代码下载)

    场景 JPA入门简介与搭建HelloWorld(附代码下载): https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/103473937 ...

  7. hibernate多对一双向关联

    关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...

  8. hibernate一对一外键双向关联

    关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...

  9. hibernate一对一主键双向关联

    关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...

随机推荐

  1. mongodb 在windows下面进行副本建创建

    一:主从复制 1: 首先看看模型图 2: 从上面的图形中我们可以分析出这种架构有如下的好处: <1>  数据备份. <2>  数据恢复. <3>  读写分离. 3: ...

  2. appium python andiroid自动化文档整理笔记

    from appium import webdriver import time,unittest,HTMLTestRunner class Testlogin(unittest.TestCase): ...

  3. Zend Framework 3.0 安装及创建初始化项目教程

    前言: 最近开始接触关于PHP的框架的学习,然而PHP的框架少说也有七八种. 百度了一下,有人说ThinkPHP简单暴力的,有人说Laravel高大上的,等等等等,难以抉择. 最终我还是选择先从接触Z ...

  4. Python迭代器,生成器--精华中的精华

    1. 迭代器 迭代器是访问集合元素的一种方式.迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束.迭代器只能往前不会后退,不过这也没什么,因为人们很少在迭代途中往后退.另外,迭代器的一大 ...

  5. maven编译时错误:无效的目标发行版

    (转)Maven 将依赖打进一个jar包 博客分类: maven   maven配置 <?xml version="1.0" encoding="UTF-8&quo ...

  6. vue-chat项目之重构与体验优化

    前言 vue-chat 也就是我的几个月之前写的一个基于vue的实时聊天项目,到目前为止已经快满400star了,注册量也已经超过了1700+,消息量达2000+,由于一直在实习,没有时间对它频繁地更 ...

  7. bzoj3209 花神的数论题 (二进制数位dp)

    二进制数位dp,就是把原本的数字转化成二进制而以,原来是10进制,现在是二进制来做,没有想像的那么难 不知到自己怎么相出来的...感觉,如果没有一个明确的思路,就算做出来了,也并不能锻炼自己的能力,因 ...

  8. JavaWeb(五)之JSTL标签库

    前言 前面介绍了EL表达式,其实EL表达式基本上是和JSTL核心标签库搭配一起使用才能发挥效果的.接下来让我们一起来认识一下吧! 在之前我们学过在JSP页面上为了不使用脚本,所以我们有了JSP内置的行 ...

  9. VB.NET生成重复窗体

    Public Class Form1 Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click ...

  10. Block使用的简单总结

    一.Block简单的使用 1.block当作参数来传递 如下定义一个没有返回值无参数的block,并把它作为参数,让系统调用,注意:这里是系统在调用,不是我们调用 那么为什么需要把block当作参数去 ...