一、概况

(一)瞬时状态(暂时态)

在对象中假设对象刚被创建但没有被持久化的话就是瞬时态

特点:

(1) 不和 Session 实例关联

(2)在数据库中没有和瞬时对象关联的记录

(二)持久状态

持久化对象就是已经被保存进数据库的实体对象,而且这个实体对象如今还处于Hibernate的Session缓存管理之中。这时对该实体对象的不论什么改动。都会在清理缓存时同步到数据库中。

特点:

(1)持久的实例在数据库中有相应的记录,并拥有一个持久化标识(identifier).

(2)和session相关联的对象

(三)游离状态(托管状态、离线状态)

当一个持久化对象,脱离开Hibernate的缓存管理后。它就处于游离状态,游离对象和自由对象的最大差别在于,游离对象在数据库中可能还存在一条与它相应的记录,仅仅是如今这个游离对象脱离了Hibernate的缓存管理,而自由对象不会在数据库中出现与它相应的数据记录。

特点:

(1) 本质上和瞬时对象同样

(2)仅仅是比瞬时对象多了一个数据库记录标识值id。

二、转化图

通过下面的转换图就能够明确三态之间是怎样转换的。假设将这幅图印在自己的脑子里,三态就没什么神圣的啦!

三、实战

以上是对三态理论知识上的解说,那么接下来就从实际代码中体验一下它们的奥妙吧。

1.TestTransient  

     session = HibernateUtil.openSession();
session.beginTransaction();
User user = new User();
user.setUsername("aaa");
user.setPassword("aaa");
user.setBorn(new Date());
/*
* 以上user就是一个Transient(瞬时状态),此时user并没有被session进行托管。即在session的
* 缓存中还不存在user这个对象。当运行完save方法后,此时user被session托管,而且数据库中存在了该对象
* user就变成了一个Persistent(持久化对象)
*/
session.save(user);
session.getTransaction().commit();

此时我们知道hibernate会发出一条insert的语句。运行完save方法后。该user对象就变成了持久化的对象了

Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)

2.TestPersistent01

     

 session = HibernateUtil.openSession();
session.beginTransaction();
User user = new User();
user.setUsername("aaa");
user.setPassword("aaa");
user.setBorn(new Date());
//以上u就是Transient(瞬时状态),表示没有被session管理并且数据库中没有
//运行save之后,被session所管理,并且,数据库中已经存在,此时就是Persistent状态
session.save(user);
//此时u是持久化状态。已经被session所管理,当在提交时。会把session中的对象和眼下的对象进行比較
//假设两个对象中的值不一致就会继续发出对应的sql语句
user.setPassword("bbb");
//此时会发出2条sql,一条用户做插入,一条用来做更新
session.getTransaction().commit();

在调用了save方法后。此时user已经是持久化对象了,被保存在了session缓存其中。这时user又又一次改动了属性值,那么在提交事务时,此时hibernate对象就会拿当前这个user对象和保存在session缓存中的user对象进行比較,假设两个对象同样,则不会发送update语句,否则,假设两个对象不同,则会发出update语句。

Hibernate: insertinto t_user (born, password, username) values (?, ?

, ?

)
Hibernate: updatet_user set born=?, password=?, username=? where id=?

3.TestPersistent02

     

 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setBorn(new Date());
u.setUsername("zhangsan");
u.setPassword("zhangsan");
session.save(u);
u.setPassword("222");
//该条语句没有意义
session.save(u);
u.setPassword("zhangsan111");
//没有意义
session.update(u);
u.setBorn(sdf.parse("1988-12-22"));
//没有意义
session.update(u);
session.getTransaction().commit();

这个时候会发出多少sql语句呢?还是相同的道理,在调用save方法后,u此时已经是持久化对象了,记住一点:假设一个对象以及是持久化状态了。那么此时对该对象进行各种改动。或者调用多次update、save方法时。hibernate都不会发送sql语句。仅仅有当事物提交的时候。此时hibernate才会拿当前这个对象与之前保存在session中的持久化对象进行比較,假设不相同就发送一条update的sql语句。否则就不会发送update语句

Hibernate: insertinto t_user (born, password, username) values (?

, ?

, ?

)
Hibernate: updatet_user set born=?, password=?, username=? where id=?

4.TestPersistent03

      

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setBorn(sdf.parse("1976-2-3"));
u.setUsername("zhangsan2");
u.setPassword("zhangsan2");
session.save(u);
/*
* 下面三条语句没有不论什么意义
*/
session.save(u);
session.update(u);
session.update(u);
u.setUsername("zhangsan3");
session.getTransaction().commit();

相信这个測试用例。大家应该都知道结果了。没错。此时hibernate也会发出两条sql语句。原理一样的

Hibernate: insertinto t_user (born, password, username) values (?, ?, ?

)
Hibernate: updatet_user set born=? , password=?, username=? where id=?

5.TestPersistent04

     

 session = HibernateUtil.openSession();
session.beginTransaction();
//此时u是Persistent
User u =(User)session.load(User.class, 4);
//因为u这个对象和session中的对象不一致,所以会发出sql完毕更新
u.setUsername("bbb");
session.getTransaction().commit();

我们来看看此时会发出多少sql语句呢?相同记住一点:当session调用load、get方法时,此时假设数据库中有该对象,则该对象也变成了一个持久化对象。被session所托管。

因此。这个时候假设对对象进行操作。在提交事务时相同会去与session中的持久化对象进行比較,因此这里会发送两条sql语句

Hibernate: selectuser0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_,user0_.username as username0_0_ from t_user user0_ where user0_.id=?
Hibernate: updatet_user set born=?, password=?, username=? where id=?

6.TestPersistent05

     

 session = HibernateUtil.openSession();
session.beginTransaction();
//此时u是Persistent
User u =(User)session.load(User.class, 4);
u.setUsername("123");
//清空session
session.clear();
session.getTransaction().commit();

再看这个样例,当我们load出user对象时,此时user是持久化的对象。在session缓存中存在该对象,此时我们在对user进行改动后。然后调用session.clear()方法,这个时候就会将session的缓存对象清空,那么session中就没有了user这个对象,这个时候在提交事务的时候。发现已经session中已经没有该对象了,所以就不会进行不论什么操作,因此这里仅仅会发送一条select语句

Hibernate: selectuser0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_,user0_.username as username0_0_ from t_user user0_ where user0_.id=?

7.TestDetached01

      

session = HibernateUtil.openSession();
session.beginTransaction();
//此时u是一个离线对象,没有被session托管
User u = new User();
u.setId(4);
u.setPassword("hahahaha");
//当运行save的时候总是会加入一条数据,此时id就会依据Hibernate所定义的规则来生成
session.save(u);
session.getTransaction().commit();

我们看到,当调用了u.setId(4)时。此时u是一个离线的对象,由于数据库中存在id=4的这个对象。可是该对象又没有被session所托管。所以这个对象就是离线的对象。要使离线对象变成一个持久化的对象。应该调用什么方法呢?我们知道调用save方法。能够将一个对象变成一个持久化对象,可是。当save一运行的时候。此时hibernate会依据id的生成策略往数据库中再插入一条数据,所以假设调用save方法,此时数据库会发送一条插入的语句:

Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)

所以对于离线对象。假设要使其变成持久化对象的话。我们不能使用save方法,而应该使用update方法

8.TestDetached02

     

 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//完毕update之后也会变成持久化状态
session.update(u);
u.setBorn(sdf.parse("1998-12-22"));
u.setPassword("world");
u.setUsername("world");
//会发出一条sql
session.update(u);
session.getTransaction().commit();

此时我们看到。当调用了update方法以后,此时u已经变成了一个持久化的对象,那么假设此时对u对象进行改动操作后,在事务提交的时候,则会拿该对象和session中刚保存的持久化对象进行比較,假设不同就发一条sql语句

Hibernate: updatet_user set born=?, password=?, username=? where id=?

9.TestDetached03

      

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//完毕update之后也会变成持久化状态
session.update(u);
u.setBorn(sdf.parse("1998-12-22"));
u.setPassword("lisi");
u.setUsername("lisi");
//会抛出异常
u.setId(333);
session.getTransaction().commit();

我们看这个样例,前面的操作一样。调用update方法后。user变成了一个持久化对象。在对user进行一些改动后,此时又通过u.setId(333)方法设置了u的ID,那么这个时候,hibernate会报错。由于我们的u当前已经是一个持久化对象。假设试图改动一个持久化对象的ID的值的话,就会抛出异常,这点要特别注意

org.hibernate.HibernateException:identifier of an instance of com.xiaoluo.bean.User was altered from 5 to 333

10.TestDetached04

     

 session = HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//如今u就是transient对象
session.delete(u);
//此时u已经是瞬时对象,不会被session和数据库所管理
u.setPassword("wangwu");
session.getTransaction().commit();

接着我们来看这个样例,这里在调用了session.delete()方法以后,此时后u就会变成一个瞬时对象,由于此时数据库中已经不存在该对象了,既然u已经是一个瞬时对象了。那么对u再进行各种改动操作的话。hibernate也不会发送不论什么的改动语句,因此这里仅仅会有一条
delete的语句发生:

Hibernate: deletefrom t_user where id=?

11.TestDetached05

     

 session = HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(4);
u.setPassword("zhaoliu");
//假设u是离线状态就运行update操作,假设是瞬时状态就运行Save操作
//可是注意:该方法并不经常使用
session.saveOrUpdate(u);
session.getTransaction().commit();

这里我们来看看saveOrUpdate这种方法,这种方法事实上是一个"偷懒"的方法,假设对象是一个离线对象,那么在运行这种方法后,事实上是调用了update方法,假设对象是一个瞬时对象。则会调用save方法,记住:假设对象设置了ID值,比如u.setId(4)。那么该对象会被假设当作一个离线对象,此时就会运行update操作。

<span style="font-size:24px;">Hibernate: updatet_user set born=?, password=?, username=? where id=?</span>

假设此时我将u.setId(4)这句话凝视掉,那么此时u就是一个瞬时的对象。那么此时就会运行save操作,就会发送一条insert语句

Hibernate: insertinto t_user (born, password, username) values (?, ?, ?

)

12.TestDetached06

     

 session = HibernateUtil.openSession();
session.beginTransaction();
//u1已经是持久化状态
User u1 =(User)session.load(User.class, 3);
System.out.println(u1.getUsername());
//u2是离线状态
User u2 = new User();
u2.setId(3);
u2.setPassword("123456789");
//此时u2将会变成持久化状态,在session的缓存中就存在了两份相同的对象,在session中不能存在两份拷贝。否则会抛出异常
session.saveOrUpdate(u2);

我们再来看一下这个样例,此时我们的u1已经是持久化的对象了。保存在session缓存中,u2通过调用saveOrUpdate方法后也变成了一个持久化的对象,此时也会保存在session缓存中,这个时候session缓存中就存在了一个持久化对象有两个引用拷贝了,这个时候hibernate就会报错

<span style="font-size:24px;">org.hibernate.NonUniqueObjectException:a different object with the same identifier value was already associated withthe session: [com.xiaoluo.bean.User#3]</span>

一个session中不能存在对一个持久化对象的双重copy的,要解决这种方法,我们这里又要介绍session的还有一个方法 merge方法,这种方法的作用就是解决一个持久化对象两分拷贝的问题,这种方法会将两个对象合并在一起成为一个对象。

      

session = HibernateUtil.openSession();
session.beginTransaction();
//u1已经是持久化状态
User u1 =(User)session.load(User.class, 3);
System.out.println(u1.getUsername());
//u2是离线状态
User u2 = new User();
u2.setId(3);
u2.setPassword("123456789");
//此时u2将会变成持久化状态,在session的缓存中就存在了两份相同的对象,在session中不能存在两份拷贝,否则会抛出异常
// session.saveOrUpdate(u2);
//merge方法会推断session中是否已经存在同一个对象,假设存在就将两个对象合并
session.merge(u2);
//最佳实践:merge一般不用
session.getTransaction().commit();

我们看到通过调用了merge方法以后,此时会将session中的两个持久化对象合并为一个对象,可是merge方法不建议被使用

<span style="font-size:24px;">Hibernate: selectuser0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_,user0_.username as username0_0_ from t_user user0_ where user0_.id=?
zhangsan
Hibernate: updatet_user set born=?, password=?, username=? where id=? </span>

四、总结

Hibernate三态瞬时态、持久态、游离态可谓是学习Hibernate的入门基础,仅仅有对它们之间的转换理出头绪,才干在实战中发挥其最大优势。这才是刚刚開始,期待下一出好戏吧。

Hibernate之三态篇的更多相关文章

  1. (Hibernate进阶)Hibernate系列——总结篇(九)

    这篇博文是hibernate系列的最后一篇,既然是最后一篇,我们就应该进行一下从头到尾,整体上的总结,将这个系列的内容融会贯通. 概念 Hibernate是一个对象关系映射框架,当然从分层的角度看,我 ...

  2. Hibernate第十篇【Hibernate查询详解、分页查询】

    前言 在Hibernate的第二篇中只是简单地说了Hibernate的几种查询方式-.到目前为止,我们都是使用一些简单的主键查询阿-使用HQL查询所有的数据-.本博文主要讲解Hibernate的查询操 ...

  3. Hibernate第六篇【多对多映射、一对一映射】

    前言 前面已经讲解了一对多和多对一的映射是怎么配置了,也讲解了inverse和cascade属性对关联关系的影响,本博文讲解多对多的映射和一对一的映射! 多对多映射 需求:一个项目由多个员工开发,一个 ...

  4. 【SSH进阶之路】Hibernate系列——总结篇(九)

    这篇博文是Hibernate系列的最后一篇,既然是最后一篇,我们就应该进行一下从头到尾,整体上的总结,将这个系列的内容融会贯通. 概念 Hibernate是一个对象关系映射框架,当然从分层的角度看,我 ...

  5. SSH环境搭建之Hibernate环境搭建篇

    SSH环境搭建之Hibernate环境搭建篇 搭建有两种方式: 1.使用IntelliJ IDEA或者MyEclipse的逆向工程(关系模型 -> 对象模型),我使用的是IntelliJ IDE ...

  6. 【SSH三大框架】Hibernate基础第二篇:编写HibernateUtil工具类优化性能

    相对于上一篇中的代码编写HibernateUtil类以提高程序的执行速度 首先,仍然要写一个javabean(User.java): package cn.itcast.hibernate.domai ...

  7. Hibernate第五篇【inverse、cascade属性详解】

    前言 上一篇博文已经讲解了一对多和多对一之间的关系了,一对多和多对一存在着关联关系(外键与主键的关系).本博文主要讲解Inverse属性.cascade属性.这两个属性对关联关系都有影响 Invers ...

  8. 【SSH三大框架】Hibernate基础第一篇:编写第一个Hibernate程序

    接下来这几章节学习的是Hibernate,Hibernate的主要作用就是用来和数据库进行连接,简化了JDBC的操作. 首先,我们创建项目,然后把Hibernate的jar包和sqlserver的驱动 ...

  9. 【SSH三个框架】Hibernate第十篇基础:inverse属性具体解释

    inverse后经常用于双向1-N在相关性.它也可以在使用N-N该协会,这里,例如用双1-N联想 或两个与各部门及工作人员,两javabean没有写. 首先,我们的员工看映射文件: <?xml ...

随机推荐

  1. DI:Defect Index(缺陷率)

    DI:Defect Index(缺陷率) 定义:DI值是衡量软件质量的高低的指标之一. 公式:DI= 致命级别的问题个数*10+严重级别的问题个数*3+一般级别的问题个数*1+提示级别的问题个数*0. ...

  2. 任务一:零基础HTML编码

    面向人群: 零基础或初学者 难度: 简单 重要说明 百度前端技术学院的课程任务是由百度前端工程师专为对前端不同掌握程度的同学设计.我们尽力保证课程内容的质量以及学习难度的合理性,但即使如此,真正决定课 ...

  3. 深入理解typeof操作符

    typeof可以检测数据的类型 typeof返回结果的其实是字符串:可以通过以下测试出来 console.log( typeof(typeof(a))); // string typeof返回的数据类 ...

  4. InnoDB INFORMATION_SCHEMA Tables about Compression

    InnoDB INFORMATION_SCHEMA Tables about Compression 了解关于压缩的InnoDB INFORMATION_SCHEMA表,可以深入了解压缩的整体运行情况 ...

  5. Linux磁盘管理及Lvm

    1. 硬盘接口 IDE: SATA:常用: SCSI:主要用于高端服务器,linux默认: SAS 2. 硬盘种类 SATA硬盘:串口硬盘,有较强的纠错能力: SCSI 硬盘:默认硬盘: SAS 硬盘 ...

  6. scp免密码拷贝和ssh免密码登录

    版权声明:本文为博主原创文章,未经允许不得转载. 在平常的工作中经常在两个服务器之间传输文件,而且经常从本地远程登录服务器,每次都要输入密码显然很没效率,这时候该怎么办呢? 首先假设服务器A和B,要想 ...

  7. c++_方格分割

    标题:方格分割 6x6的方格,沿着格子的边线剪开成两部分.要求这两部分的形状完全相同. 如图:p1.png, p2.png, p3.png 就是可行的分割法. 试计算:包括这3种分法在内,一共有多少种 ...

  8. python基础知识04-散列类型运算优先级和逻辑运算

    散列类型 1.集合 定义集合 se = {1,2,3,4} se = set()定义空集合 se = {1,3,5,7} se2 = {1,3,8,9} se & se2 {1,3} 交集 s ...

  9. mysql启动问题

    /usr/local/mysql/bin/mysqld: Can't find file: './mysql/plugin.frm' (errno: 13 - Permission denied) - ...

  10. 利用virtualbox中的虚机制作主机启动盘

    制作镜像的过程: 第一步:1.Windows下先下载安装virtualbox usb3.0驱动:https://download.virtualbox.org/virtualbox/5.2.20/Or ...