安科网

Hibernate框架ORM基础（一对多关系的save分析）

yierxiansheng

yierxiansheng

2017-10-13

关注 关注

       相信各位技术大牛应该一眼就看懂了，我呢，只是个菜鸟，只不过想在交流中进步。故工作之余会谢谢博客。下面是Hibernate的一对多关系的对象保存到数据库的一个图文分析。在使用Hibernate框架开发时，一般不会涉及这些Hibernate的API语句，不过一对多关系在开发中却经常用到，相关的业务需求也是非常多。

备注一下：下边的代码有些不是很标准，不过本人没有去改，不过大致可以看出各个图的各种情况所对应的代码。

       以下情况是在非注解方式的分析（即一个实体类对应一个xml配置文件）。

环境：      

1、假设有俩个实体类（客户Customer【一方】和联系人LinkMan【多方】）；

2、实体类中互相有对方的属性，如：

客户实体类中有private Set<LinkMan> custLinkMan = new HashSet<LinkMan>(0);

联系人实体类中有private Customer lkmCustomer;

3、客户类对应的Customer.hbm.xml中除了其他属性的配置，还有的就是如下的一对多关系的映射

<set name="custLinkMan"> <!-- 此处不写inverse属性，后面图文中体现-->

  <key column="lkm_cust_id"></key>

  <one-to-many class="com.syh.entity.LinkMan" />

</set>

联系人类对应的LinkMan.hbm.xml中除了其他属性的配置，也有如下的关系映射配置

<many-to-one cascade="save-update" name="lkmCustomer" class="com.syh.entity.Customer" column="lkm_cust_id"></many-to-one>

4、准备一个HibernateUtil工具类，使用里面绑定了线程的方法得到session，其实因为这个不是正经开发，刻意使用普通的得到session的方法。

在保存一对多关系的实体对象到数据库的时候我们需要关注几个影响条件：

1、保存的方向性：在客户实体类中有设置联系人属性的方法，也就是那个setter方法，不过因为是set集合引用对象，实际上getter方法就够了，例如customer.getCustLinkMan().add(linkman)这个A（为了减少代码量，我先用A和B替代这个）方法就可以了；而在联系人实体类中使用的是如linkman.setLkmCustomer(costomer)这个B方法。

前面简单说明一下，这里保存的方向性指的是程序中有A方法而没有B方法（单向关系：客户知道了联系人），有B方法而没有A方法（单向关系：联系人知道了客户），有A和B俩个都存在（双向关系）。

2、保存的顺序（先保存客户还是先保存联系人的问题）；

3、客户的配置文件中是否放弃维护权，即是否设置了inverse=“true”，这个只有一方有，而多方是一定会维护的，因为外键本来就是多方表的;

造成的结果我们需要关注几个东西：

1、Hibernate发送到数据库的sql语句数；

2、是否成功插入到数据库；

3、Hibernate发送的sql语句的异同；

在这里我们只分析上述影响条件下的情况，根据排列组合3*2*2=12种情况，实际上还有单双向保存（只保存客户或只保存联系人的情况）以及级联cascade属性（不级联、客户级联、联系人级联、都级联）的问题，但加上这些，情况会变成12*3*4=144种情况，本人才疏学浅时间有限，就简单说一下以下12种情况吧。

先看图：

图一如下：

该图为联系人知道客户，即只有linkman.setLkmCustomer(costomer)这个方法。然后根据保存顺序和是否放弃维护权来看结果。

而该图的结果：

1）sql语句数在图里了；

2）都成功插入数据到数据库；

3）Hibernate发送的sql语句也体现在图里了；

图中右下角是简单的分析，需要一级缓存和快照机制的知识为基础，如果不明白欢迎给本人留言，欢迎互相交流。

如果看到图二图三，会发现第3句sql语句有不一样的地方，这是因为外键的维护权在不在一方也就是维护权在不在客户的问题。

Hibernate框架ORM基础（一对多关系的save分析）

图一对应的代码：

public class TestOneToMany1 {
	
	@Test
	public void test1() {
		/**
		 * 单向关系：联系人知道客户
		 * 保存顺序：先保存联系人，后保存客户
		 * 配置：默认（客户参与维护外键）
		 * 
		 * 结果：出现3条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户001");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("1联系人1");
		
		//单向关系：联系人->客户
		l.setLkmCustomer(c);
		
		//保存
		session.save(l); //保存联系人 LinkMan
		session.save(c); //保存客户 Customer
		
		//===================================================
		transaction.commit();
	}
	
	@Test
	public void test2() {
		/**
		 * 单向关系：联系人知道客户
		 * 保存顺序：先保存联系人，后保存客户
		 * 配置：inverse="true"（客户不参与维护外键）
		 * 
		 * 结果：出现3条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户001");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("2联系人1");
		
		//单向关系：联系人->客户
		l.setLkmCustomer(c);
		
		//保存
		session.save(l); //保存联系人 LinkMan
		session.save(c); //保存客户 Customer
		
		//===================================================
		transaction.commit();
	}
	
	
	@Test
	public void test3() {
		/**
		 * 单向关系：联系人知道客户
		 * 保存顺序：先保存客户，后保存联系人
		 * 配置：inverse="true"（客户不参与维护外键）
		 * 
		 * 结果：出现2条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户001");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("3联系人1");
		
		//单向关系：联系人->客户
		l.setLkmCustomer(c);
		
		//保存
		session.save(c); //保存客户 Customer
		session.save(l); //保存联系人 LinkMan
		
		//===================================================
		transaction.commit();
	}
	
	@Test
	public void test4() {
		/**
		 * 单向关系：联系人知道客户
		 * 保存顺序：先保存客户，后保存联系人
		 * 配置：默认（客户参与维护外键）
		 * 
		 * 结果：出现2条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户001");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("4联系人1");
		
		//单向关系：联系人->客户
		l.setLkmCustomer(c);
		
		//保存
		session.save(c); //保存客户 Customer
		session.save(l); //保存联系人 LinkMan
		
		//===================================================
		transaction.commit();
	}
	
}

图二如下：

该图为客户知道联系人，即只有customer.getCustLinkMan().add(linkman)这个方法。然后根据保存顺序和是否放弃维护权来看结果。

而该图的结果：

1）sql语句数在图里了；

2）插入数据到数据库中有俩条记录没有外键；

3）Hibernate发送的sql语句也体现在图里了；

左上角为第一种情况最左边那种情况的简单的分析，右上角是插入到数据库的情况。

插入数据异常的原因：

客户知道联系人，但由于设置了inverse="true"放弃了维护权，而联系人却不知道客户，想维护外键也维护不了，因此，无论先保存联系人还是先保存客户，设置了inverse=“true”的时候都会造成外键为空。

Hibernate框架ORM基础（一对多关系的save分析）

图二对应代码：

public class TestOneToMany2 {
	
	@Test
	public void test1() {
		/**
		 * 单向关系：客户知道联系人
		 * 保存顺序：先保存联系人，后保存客户
		 * 配置：默认（客户参与维护外键）
		 * 
		 * 结果：出现3条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户002");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("1联系人2");
		
		//单向关系：客户->联系人
		//l.setLkmCustomer(c);
		c.getCustLinkMan().add(l);
		
		//保存
		session.save(l); //保存联系人 LinkMan
		session.save(c); //保存客户 Customer
		
		//===================================================
		transaction.commit();
	}
	
	@Test
	public void test2() {
		/**
		 * 单向关系：联系人知道客户
		 * 保存顺序：先保存联系人，后保存客户
		 * 配置：inverse="true"（客户不参与维护外键）
		 * 
		 * 结果：出现2条sql语句,无法建立外键
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户002");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("2联系人2");
		
		//单向关系：客户->联系人
		//l.setLkmCustomer(c);
		c.getCustLinkMan().add(l);
		
		//保存
		session.save(l); //保存联系人 LinkMan
		session.save(c); //保存客户 Customer
		
		//===================================================
		transaction.commit();
	}
	
	
	@Test
	public void test3() {
		/**
		 * 单向关系：联系人知道客户
		 * 保存顺序：先保存客户，后保存联系人
		 * 配置：inverse="true"（客户不参与维护外键）
		 * 
		 * 结果：出现2条sql语句,无法建立外键
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户002");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("3联系人2");
		
		//单向关系：客户->联系人
		//l.setLkmCustomer(c);
		c.getCustLinkMan().add(l);
		
		//保存
		session.save(c); //保存客户 Customer
		session.save(l); //保存联系人 LinkMan
		
		//===================================================
		transaction.commit();
	}
	
	@Test
	public void test4() {
		/**
		 * 单向关系：联系人知道客户
		 * 保存顺序：先保存客户，后保存联系人
		 * 配置：默认（客户参与维护外键）
		 * 
		 * 结果：出现3条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户002");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("4联系人2");
		
		//单向关系：客户->联系人
		//l.setLkmCustomer(c);
		c.getCustLinkMan().add(l);
		
		//保存
		session.save(c); //保存客户 Customer
		session.save(l); //保存联系人 LinkMan
		
		//===================================================
		transaction.commit();
	}
	
}

图三如下：

该图为双向关系，即既有customer.getCustLinkMan().add(linkman)这个方法，也有linkman.setLkmCustomer(costomer)。然后根据保存顺序和是否放弃维护权来看结果。

而该图的结果：

1）sql语句数在图里了；

2）都成功插入数据到数据库（图二右上角的最后4条数据）；

3）Hibernate发送的sql语句也体现在图里了；

在这里解释一下为什么第3句sql语句会有所不同：

假如所有情况都由客户去维护外键，那么发送的第3句sql语句一定是只维护了主键，即下图中中间那个sql语句；

但由于有些情况是多方维护了外键，也就是联系人自己维护外键，所以会出现下图右下角的那个sql语句。

至于多方自己维护外键会更新自己全部的信息，这个要去研究Hibernate的源码，本人菜鸟一个，这个就交给各位大神了。

Hibernate框架ORM基础（一对多关系的save分析）

图三对应代码：

public class TestOneToMany3 {
	
	@Test
	public void test1() {
		/**
		 * 单向关系：联系人知道客户，客户知道联系人
		 * 保存顺序：先保存联系人，后保存客户
		 * 配置：默认（客户参与维护外键）
		 * 
		 * 结果：出现3条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户003");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("1联系人3");
		
		//单向关系：联系人->客户、客户->联系人
		l.setLkmCustomer(c);
		c.getCustLinkMan().add(l);
		
		//保存
		session.save(l); //保存联系人 LinkMan
		session.save(c); //保存客户 Customer
		
		//===================================================
		transaction.commit();
	}
	
	@Test
	public void test2() {
		/**
		 * 单向关系：联系人知道客户，客户知道联系人
		 * 保存顺序：先保存联系人，后保存客户
		 * 配置：inverse="true"（客户不参与维护外键）
		 * 
		 * 结果：出现3条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户003");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("2联系人3");
		
		//单向关系：联系人->客户、客户->联系人
		l.setLkmCustomer(c);
		c.getCustLinkMan().add(l);
		
		//保存
		session.save(l); //保存联系人 LinkMan
		session.save(c); //保存客户 Customer
		
		//===================================================
		transaction.commit();
	}
	
	
	@Test
	public void test3() {
		/**
		 * 单向关系：联系人知道客户，客户知道联系人
		 * 保存顺序：先保存客户，后保存联系人
		 * 配置：inverse="true"（客户不参与维护外键）
		 * 
		 * 结果：出现2条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户003");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("3联系人3");
		
		//单向关系：联系人->客户、客户->联系人
		l.setLkmCustomer(c);
		c.getCustLinkMan().add(l);
		
		//保存
		session.save(c); //保存客户 Customer
		session.save(l); //保存联系人 LinkMan
		
		//===================================================
		transaction.commit();
	}
	
	@Test
	public void test4() {
		/**
		 * 单向关系：联系人知道客户，客户知道联系人
		 * 保存顺序：先保存客户，后保存联系人
		 * 配置：默认（客户参与维护外键）
		 * 
		 * 结果：出现3条sql语句
		 * 		原因：
		 */
		Session session = HibernateUtil.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		//===================================================
		//客户实例化
		Customer c = new Customer();
		c.setCustName("客户003");
		//联系人实例化
		LinkMan l = new LinkMan();
		l.setLkmName("4联系人3");
		
		//单向关系：联系人->客户、客户->联系人
		l.setLkmCustomer(c);
		c.getCustLinkMan().add(l);
		
		//保存
		session.save(c); //保存客户 Customer
		session.save(l); //保存联系人 LinkMan
		
		//===================================================
		transaction.commit();
	}
	
}

hibernate 实体类 orm linkman orm框架

yierxiansheng

yierxiansheng

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

Hibernate 5 @Entity 如何 extends 另外一个类

在实际项目设计中，我们可以希望在 JPA 中定义 @Entity 表。但是在这个 @Entity 类中，我们希望 extends 另外一个类，在另外一个类中我们可以把一些通用的属性设置到里面。需要在 DataObject 中添加 @MappedSuperc

栖梧桐 2020-04-11

Hibernate 与 Mybatis 如何共存？打破你的认知！

很长一段时间，网上有很多关于Hibernate与Mybatis孰优孰劣的争论，两个阵营的人谁也不能说服谁，每个人的理由都很有道理。今天，我分享的主题是：在一个项目中同时使用Hibernate和Mybatis两个ORM框架。Hibernate封装了很多有用的

jimgreatly 2020-08-03

hibernate

本质上就是将数据从一种形式转换到另外一种形式。

东方咖啡屋 2020-06-13

JavaEE持久层框架对比与hibernate主键生成策略总结

它把数据库表映射到pojo类，然后通过对类的操作来实现对数据库的增删改查，sql语句自动生成。我刚工作的时候，一直用hibernate，后来springboot兴起，不让有那么多配置文件，就用了spring data JPA。ibatis是个不完整的ORM

tlsmile 2020-05-28

第十一节：Hibernate 原生Sql

如果你想使用数据库特定的功能如查询提示或 Oracle 中的 CONNECT 关键字的话，你可以使用原生 SQL 数据库来表达查询。Hibernate 3.x 允许您为所有的创建，更新，删除，和加载操作指定手写 SQL ，包括存储过程。通常字段名无法匹配需

喝绿茶的猫 2020-03-28

【java框架】JPA(1) -- JPA入门

JPA是Java Persistence API的简称，它是Sun公司在充分吸收现有ORM框架的基础上，开发而来的一个Java EE 5.0平台标准的开源的对象关系映射规范。总结一句话就是：JPA是持久化的关系映射规范、接口API，而Hibernate是其

微微撒 2020-03-08

Java开发人员应该学习的5个基本框架

Spring，Hibernate，Spring Boot，Spring Security和Spring Cloud是最重要的Java框架。Java开发人员，您好，如果您正在考虑应该学习哪种框架以成为完整的开发人员，那么您来对地方了。尽管有数十种Java框架

feinifi 2020-10-13

踩坑了！踩坑了！NHibernate使用批量插入Oracle数据，Batch属性

今天看NHibernate文档，发现了NHibernate提供批量操作数据的支持，目前仅支持sql server和Oracle，果断要试试啊。结果发现，竟然批量插入Oracle数据无效。--启动批量操作，可有效减少nh与数据库的连接。设置为0时，默认不启动

solarspot 2020-07-28

NHibernate之并发控制简记

对于web和企业来说，跨用户交互过程的数据事务是不可接受的。单一的应用事务中可能会跨多个数据库事务。如果这些数据库事务只有一个进行了更新数据，其他的只是简单的读数据，则这个应用事务就是原子性的。如果出现多个用户同时写入了一条数据，最后结果是不确定的。如果多

solarspot 2020-07-28

JPA(Hibernate)代理类的hibernateLazyInitializer属性系列化异常

　　今天在Spring Boot项目中使用JPA进行数据库访问时，

栖梧桐 2020-07-08

hibernate（四）

　　hibernate使用了 slf4j，现在我们想使用 log4j，需要中间 jar 包 slf4j-log4j12-1.7.2.jar　　导入 jar 包：slf4j-log4j12-1.7.2.jar 和 log4j-1.2.16.jar　　在 sr

CXC0 2020-06-14

Hibernate框架（五）Hibernate主键生成策略

1 hibernate要求实体类里面有一个属性作为唯一值，对应表主键，主键可以不同生成策略。3 在class属性里面有很多值

Kele0 2020-06-08

Hibernate框架（六）Hibernate的一级缓存

1 数据存到数据库里面，数据库本身是文件系统，使用流方式操作文件效率不是很高。hibernate的一级缓存使用范围，是session范围，从session创建到session关闭范围

LetonLIU 2020-06-08

Hibernate简单增删改查

LetonLIU 2020-05-29

hibernate中的主键生成策略

2) identity 由数据库维护。通常mysql等拥有自增主键的数据库使用。3）native 由hibernate决定。5) increment：自动增长主键，由hibernate维护。

DAV数据库 2020-05-11

hibernate中的查询方式

1）通过session进行主键查询，session.get/load update/delete/save. 2）通过hql进行查询。Hql主要是面向对象。①当hql查询所有字段时，直接写from后面就行，select * 可以省略；其中Query相当于预

栖梧桐 2020-05-11

【Hibernate】03 配置文件 &amp; API

Session是一个单线程的对象，不能被公用！！！

LetonLIU 2020-05-10

mybatis和hibernate的比较

hibernate 自动生成表，生成关系对于单表的CRUD 不用写sql 和hqlmybtais 对于多表连接查询等等更加方便 因为sql写起来简单

栖梧桐 2020-04-25

hibernate中元数据ClassMetadata用法及原理

9. public boolean[] getPropertyNullability()：得到所有属性的“是否允许为空”属性。

LetonLIU 2020-04-23

hibernate连接数据库中文乱码

useUnicode=true&characterEncoding=utf8，不然会出现编译错误，错误提示为将&连接符改为;。设置这些之后乱码问题就解决了。

wintershii 2020-04-21
yierxiansheng

yierxiansheng

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号