在update后显示执行flush

langzhiwang888

浏览: 182051 次
性别:
来自: 青岛

最近访客更多访客>>

xubbsun

luckyhan0218

zihai367

logcy

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

Hibernate视频学习笔记（5）SessionFlush简介

Session flush测试：

Session flush方法主要做了两件事情：

清理缓存：

执行SQL：

session在什么情况下执行flush

默认在事务提交时

显示的调用flush

在执行查询前，如：iterate

在uuid情况下：save时不会发sql语句（与native不同）

执行flush会立刻发出SQL,临时集合会清理掉

数据库隔离级别：

隔离级别
是否脏读
是否存在不可重复读
是否存在幻读

Read Uncommited
是
是
是

Read commited
否
是
是

Repeatable Read
否
否
是

Serializable
否
否
否

Select @@tx_isolation;

Set transaction isolation level read uncommitted;

测试uuid主键生成策略：

因为user的主键生成策略采用uuid,所以调用完成save后，只是将user纳入了session管理，不会发出insert语句，但是id已经生成，session中的existsInDatabase状态为false

调用flush,hibernate会清理缓存，执行SQL

如果数据库的隔离级别设置为未提交读，那么我们可以看到flush过的数据，并且我们看到session中的existsInDatabase状态为true

提交事务默认情况下commit操作会先执行flush清理缓存，所以不用显示调用flush

commit后数据是无法回滚的

evict将对象从session中清除，session的EntryEntries属性中拿出

无法成功提交事务，因为hibernate在清理缓存时，在session的insertions临时集合中取出user对象进行insert操作后需要更新EntityEntries的existsInDatabase属性为true,而我们采用evict已经将user从session的Entity Entries中拿出了，所以找不到相关数据，无法更新，抛出异常

解决方式是在evict前之行session.flush,将insertions清除，将existsInDatabase设置为true,当执行evict后提交时就不会发生异常情况了，因为hibernate清理缓存时，在session的insertions集合中无法找到user对象，所以就不会发出insert语句，也不会更新session中的existsInDatabase的状态

测试native主键生成策略：

因为user得主键生成策略为native,所以调用session.save后将执行insert语句，返回由数据库生成的id,纳入了session的管理，还修改了session中的existsInDatabase状态为true

这种情况evict后commit没有任何问题：因为save的同时已经发出insert语句并清理insertions

更新existsInDatabase状态为true,在执行evict时将对象从session中拿出，commit时由于insertions不存在，所以不会发出insert语句也不会更新existsInDatabase的状态，所以不存在主键生成策略为uuid时遇到的问题

测试assign主键生成策略：

测试用例：先增加一个，然后修改，然后再增加

但是生成语句时却是：先增加，然后修改

hibernate按照save,update,delete顺序提交相关操作

如何按照我们的意图操作？

在update后显示执行flush

session flush在commit之前默认都会执行他。也可以手动执行它，他主要做了两件事：
1）清理缓存。
2）执行SQL。

session在什么情况下执行flush
* 默认在事务提交时
* 显示的调用flush
* 在执行查询前，如：iterate
hibernate按照save(insert),update、delete顺序提交相关操作

**********************************************************************
在下面的情况下，Hibernate会调用Session.flush()以清理缓存：
1)事务提交时如果flush模式不为FlushMode.NEVER,commit()将调用flush().
2)在某些查询语句之前（此查询语句之前的语句已经改变了数据库状态，所以需要调用flush（）以同步数据库是查出来的数据是经过更改的）。在调用Session.flush()时，涉及的SQL语句会按照下面的顺序执行。
（1所有的实体进行插入的语句，其顺序按照对象执行Session.save()的时间顺序。
（2）所有对实体进行更新的语句
（3）所有进行集合的删除语句
（4）所有对集合元素进行删除，更新或者插入的语句
（5）所有进行集合插入的语句
（6）所有对实体进行删除的语句，其顺序按照对象执行Session.delete()的时间顺序。（7）有一个例外是，如果对象使用native方式生成的ID（持久化标识），则他们一执行save就会被插入。除非明确地指定了flush（）命令，否则关于Session何时会执行这些JDBC调用完全是无法保证的，只能保证他们执行的前后顺序。

通过设置session.setFlushMode(),可以精确控制Hibernate的FlushMode.
(1)FlushMode.AUTO:Hibernate判断对象属性有没有改变，如果被更改成为脏数据，则在一个查询语句钱将更新此改动以保证数据库的同步。这也是Hibernate的默认清理模式。(2)FlushMode.COMMIT:在事务结束之前清理session的缓存.这样有可能导致查出脏数据
(3)FlushMode.NEVER：除非强制调用Session.flush(),否则永远不清理Session。想当于将数据库设置为一个只读的数据库。
(4) FlushMode.ALWAYS：在每一个查询数据之前都调用Session.flush()。很显然这种效率很低。
只用当使用触发器，或把Hibernate和JDBC混合使用，直接调用Session.flush()才是有意义的。

注意：
事物在没commit，即没提交之前是可以回滚的。

隔离级别              脏读不可重复读幻读 ReadUncommitted   Y       Y           Y ReadCommitted      N       Y           Y RepeatableRead      N       N           Y Serializable            N       N           N ReadCommited是oracle的默认隔离级别。可以通过悲观锁，消除不可重复读。 RepeatableRead是Mysql的默认级别。数据库的隔离级别：(设置数据库的隔离级别是为了防止并发访问)这里有几个概念：脏读，不可重复读，幻读没有提交就可以读叫脏读。不可重复读是指第一次读的时候是张三，接着再读一次变为李四了，当重复读的时候出现了错误，叫不可重复读。可以使用悲观锁来锁住，别人修改不了
就可以避免不可重复读。幻读是指例如当查询年龄时查18到20，出现5条记录，当刷新一下就变成10条了，这叫幻读。
1》未提交读（Read uncommit）：即假如当在发出insert，但是还没执行commit就可以读，数据库中就已经存在，外部已经可以访问这个数据，这样是不安全的。这种使用的少。他存在脏读。也存在不可重复读和幻读。2》提交读（read commit）：即在提交之后（commit）才可以读。大部分数据库都是采用这种。oracle默认就是这个。这种情况下避免了脏读。存在不可重复读。也存在幻读。3》可重复读（repeatable read）：这个是Myswl的默认级别，只有提交了才可以读，即执行了commit之后才会在数据库中存在。他不存在不可重复读，因为当读一条记录的时候相当于加了悲观锁把锁，别人就读不到，故避免了不可重复读。但是幻读无法避免。4》序列化读（serialiaizble read）：这是最高隔离级别，这个是串行的，只有你执行完之后别人才可以执行，这个是用的很少。他没有脏读，没有不可重复读也没有幻读。从1到4是从低到高的。测试：
public class SessionFlushTest extends TestCase {
/**
* 测试uuid主键生成策略
*/
public void testSave1() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();

User1 user = new User1();
user.setName("李四");
user.setPassword("123");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//因为user的主键生成侧路采用的是uuid，所以调用完成save后，只是将user纳入到了session的管理
//不会发出insert语句，但是id已经生成，session中existsInDatebase状态为false
session.save(user);
//调用flush，hibernate会清理缓存，执行sql
//如果数据库的隔离级别设置为为提交读，那么我们可以看到flush过的数据
//并且session中existsInDatebase状态为true
session.flush();
//提交事务
//默认情况下commit操作会先执行flush清理缓存，所以不用显示的调用flush
//commit后数据是无法回滚的，没有commit，事物是可以回滚的
tx.commit();
}catch(Exception e) {
e.printStackTrace();
tx.rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 测试native主键生成策略
*/
public void testSave2() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();

User2 user = new User2();
user.setName("张三1");
user.setPassword("123");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//因为user的主键生成策略为native,所以调用session.save后，将执行insert语句，返回有数据库生成的id
//纳入了session的管理，修改了session中existsInDatebase状态为true
//如果数据库的隔离级别设置为为提交读，那么我们可以看到save过的数据
session.save(user);
tx.commit();
}catch(Exception e) {
e.printStackTrace();
tx.rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 测试uuid主键生成策略
*/
public void testSave3() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();

User1 user = new User1();
user.setName("王五");
user.setPassword("123");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//因为user的主键生成侧路采用的是uuid，所以调用完成save后，只是将user纳入到了session的管理
//不会发出insert语句，但是id已经生成，session中existsInDatebase状态为false
session.save(user);
//将user对象从session中逐出，即session的EntityEntries属性中逐出
session.evict(user);
//无法成功提交，因为hibernate在清理缓存时，在session的insertions集合中取出user对象进行insert操作后
//需要更新entityEntries属性中的existsInDatabase为true，而我们采用evict已经将user从session的entityEntries
//中逐出了，所以找不到相关数据，无法更新，抛出异常
tx.commit();
}catch(Exception e) {
e.printStackTrace();
tx.rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 测试uuid主键生成策略
*/
public void testSave4() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();

User1 user = new User1();
user.setName("王五");
user.setPassword("123");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//因为user的主键生成侧路采用的是uuid，所以调用完成save后，只是将user纳入到了session的管理
//不会发出insert语句，但是id已经生成，session中existsInDatebase状态为false
session.save(user);
//flush后hibernate会清理缓存，会将user对象保存到数据库中，将session中的insertions中的user对象
//清除，并且设置session中existsInDatebase的状态为true
session.flush();
//将user对象从session中逐出，即session的EntityEntries属性中逐出
session.evict(user);
//可以成功提交，因为hibernate在清理缓存时，在session的insertions集合中无法找到user对象
//所以就不会发出insert语句，也不会更新session中的existsInDatabase的状态
tx.commit();
}catch(Exception e) {
e.printStackTrace();
tx.rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 测试native主键生成策略
*/
public void testSave5() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();

User2 user = new User2();
user.setName("张三11");
user.setPassword("123");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//因为user的主键生成策略为native,所以调用session.save后，将执行insert语句，返回有数据库生成的id
//纳入了session的管理，修改了session中existsInDatebase状态为true
//如果数据库的隔离级别设置为为提交读，那么我们可以看到save过的数据
session.save(user);
//将user对象从session中逐出，即session的EntityEntries属性中逐出
session.evict(user);
//可以成功提交，因为hibernate在清理缓存时，在session的insertions集合中无法找到user对象
//所以就不会发出insert语句，也不会更新session中的existsInDatabase的状态
tx.commit();
}catch(Exception e) {
e.printStackTrace();
tx.rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 测试assigned主键生成策略
*
*/
public void testSave6() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();

User3 user = new User3();
user.setId("001");
user.setName("张三");
session.save(user);
user.setName("王五");
session.update(user);
User3 user3 = new User3();
user3.setId("002");
user3.setName("李四");
session.save(user3);
//Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)
//Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)
//Hibernate: update t_user3 set name=?, password=?, create_time=?, expire_time=? where user_id=?
//hibernate按照save(insert),update、delete顺序提交相关操作
tx.commit();
}catch(Exception e) {
e.printStackTrace();
tx.rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

/**
* 测试assigned主键生成策略
*
*/
public void testSave7() {
Session session = null;
Transaction tx = null;
try {
session = HibernateUtils.getSession();
tx = session.beginTransaction();

User3 user = new User3();
user.setId("003");
user.setName("张三");
session.save(user);
user.setName("王五");
session.update(user);
session.flush();
User3 user3 = new User3();
user3.setId("004");
user3.setName("李四");
session.save(user3);
//Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)
//Hibernate: update t_user3 set name=?, password=?, create_time=?, expire_time=? where user_id=?
//Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)
//因为我们在session.udpate(user)后执行了flush，所以在清理缓存时执行flush前的sql不会生成
//sql会按照我们的意愿执行
tx.commit();
}catch(Exception e) {
e.printStackTrace();
tx.rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

}

分享到：