- 浏览: 448793 次
- 性别:
- 来自: 深圳
文章分类
最新评论
-
g_man1990:
update config 不成功啊
build-helper-maven-plugin 配置多 source resource 文件 -
netwelfare:
文章很详细,就是太长了,读起来有点困难,倒不如写精练点,像这篇 ...
Java 基本类型 -
huyuancai1010:
function commitForm() {
var ...
加时间戳或者随机数去除js缓存 -
Smile__:
不过这个东西以前还真没研究过 。
hibernate.jdbc.fetch_size 和 hibernate.jdbc.batch_size -
Smile__:
想不到你也是北大青鸟的 。哈
hibernate.jdbc.fetch_size 和 hibernate.jdbc.batch_size
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()才是有意义的。
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);
}
}
}
发表评论
-
Hibernate search
2011-02-21 14:44 3422Hibernate Search是Hibernate的子项目, ... -
SimpleJdbc
2010-05-26 17:21 1927SimpleJdbcInsert类和SimpleJdbcCal ... -
Hibernate 注解 annotation
2010-05-05 20:37 15028一、 实体 Bean 每个持久化POJO类都是一个实体Bea ... -
Hibernate 拦截器 和 监听器
2009-11-25 11:29 1876拦截器(Intercept):顾名思义,拦截操作,也就是在Hi ... -
hibernate.jdbc.fetch_size 和 hibernate.jdbc.batch_size
2009-11-17 17:32 19923hibernate.jdbc.fetch_size 50 h ... -
Hibernate 二级缓存 和 查询缓存
2009-09-22 11:19 3068自己测试的一些结果 , ... -
get 会使用二级缓存
2009-09-03 17:17 1449经常看到session.get()和session.load( ... -
Query.list 与 Query.iterate 的区别
2009-09-03 17:08 1942list: 结果存入缓存,但不从缓存里面取;查询时属性连同id ... -
Jdbc 与 Jta 事务
2009-08-26 14:35 2665hibernate的两种事务管理jdbc 和jta方式。下边说 ... -
GenericSpringDAO<T extends ...>
2009-08-03 10:06 1519import java.io.Serializable;imp ... -
Hibernate Annotation driven equals and hashCode
2009-07-03 16:56 1471The following implementation of ... -
hibernate cascade inverse
2009-06-28 19:43 1147这两个属性都用于一多 ... -
Hibernate Criteria
2009-06-19 11:15 1064Hibernate 设计了 CriteriaSpec ... -
Hibernate的Criteria 简单用法
2009-05-26 16:52 1802在hibernate的Session里面使用createCri ... -
Hibernate中Criteria的完整用法
2009-05-26 16:46 615Criteria 在查询方法设计上可以灵活的根据 Criter ... -
Hibernate 的连接池属性简介
2009-05-07 11:30 1657Hibernate配置属性 ... -
Hibernate Inverse
2009-04-23 17:15 1277一、Inverse是hibernate双向关系中的基本概念。i ... -
hibernate的hibernate.hbm2ddl.auto属性
2009-01-06 16:33 2370<property name="hibern ... -
hibernate主键常用方式
2009-01-06 16:32 10431) assigned 主键由外部程序负责生成,无需Hibe ...
相关推荐
`Session.flush()`方法是一个关键的操作,它强制Hibernate将内存中的对象状态同步到数据库,确保数据的一致性。这篇博客深入探讨了`Session.flush()`的工作原理和应用场景。 `Session`在Hibernate中主要有以下职责...
当达到特定条件或手动调用`Session.flush()`时,Hibernate会将这些变更持久化到数据库。 Flush过程主要包括以下步骤: 1. **对象状态检查**:Hibernate会检查Session中的所有对象,判断它们是否需要被更新、插入...
4. **关闭Session**:当Session被关闭时,Hibernate会自动执行Flush操作,以确保所有未提交的更改都被持久化到数据库中。 #### 错误示例分析 在给定的部分内容中,提到了一个典型的错误场景,其中包含了一个常见的...
本示例将深入探讨Hibernate Session的生命周期及其使用,帮助你更好地理解和运用这个强大的工具。 Hibernate Session是Hibernate的核心接口,它是与数据库交互的主要接口。Session对象负责管理实体对象的状态,包括...
在Java的持久化框架Hibernate中,`Session`和`Transaction`是两个至关重要的概念,它们在数据管理和事务处理中起到核心作用。这篇文章将深入解析这两个概念及其相关知识点。 `Session`是Hibernate提供的一种与...
### Hibernate Session 详解:值得珍藏的深度解析 在Java持久化领域,Hibernate无疑占据了举足轻重的地位,而`Hibernate Session`则是其中的核心组件之一,它提供了与数据库交互的主要接口,是对象/关系映射(ORM)...
在Java的Hibernate框架中,一级缓存是Session对象内置的缓存机制,它的存在是为了优化数据库操作,减少对数据库的直接访问,从而提高应用程序的性能。一级缓存的生命周期与Session对象相同,也就是说,只要Session...
当一个对象刚刚被创建,并未通过Hibernate的Session接口进行任何操作时,它处于临时状态。此时,对象未与数据库中的任何记录关联,没有被分配唯一的数据库ID,如果对象发生改变,不会影响数据库中的数据。 2. **...
### HIbernate Session 详解 #### 一、Session在Hibernate中的地位及作用 在Hibernate框架中,`Session` 是一个非常核心且重要的组件。作为Hibernate提供的主要操作数据库的接口,`Session` 不仅承担着保存、更新...
当我们在Session上进行操作时,这些操作不会立即反映到数据库中,而是被缓存起来,直到调用`flush()`方法或者事务提交时才会真正执行。 在开始使用Session之前,需要配置Hibernate的环境,包括创建SessionFactory,...
Hibernate的Session_flush与隔离级别代码详解 Hibernate 是一个基于Java的 ORM(Object-Relational Mapping)工具,提供了将 Java 对象映射到关系数据库的能力。其中 Session_flush 和隔离级别是两个重要的概念。 ...
在使用Hibernate进行数据库操作时,事务管理和`flush`方法的正确使用至关重要,因为它们直接影响到数据的一致性和安全性。在本文中,我们将深入探讨Hibernate的事务处理机制以及`flush`方法的用法,并分析为何在某些...
session.flush(); session.getTransaction().commit(); ``` 总结 本文详细介绍了 Hibernate 中 Session 的关闭实例解析,包括 getSession() 和 openSession() 的区别、getCurrentSession() 的配置、openSession() ...
### Hibernate的核心接口——Session详解 #### 一、Session简述 **1. Session概念** - **定义**: Session 是 Hibernate 框架中最常用的接口之一,它又被称为持久化管理器。Session 负责所有与数据库交互的工作,...
- `session.createSQLQuery(sql).uniqueResult()`能直接查询到数据,是因为Hibernate在执行查询前会先flush,所以即使事务未提交,查询也是基于已flush的数据进行的,相当于查看了缓存中的状态。 4. **缓存与查询*...
- 使用`Session.flush()`显式触发脏检查,如果发现异常,事务也会回滚。 通过以上内容,我们了解了Hibernate 5在数据持久化和事务管理方面的基本操作和注意事项。在实际项目中,结合事务的隔离级别、锁机制以及适当...
在Java的持久化框架Hibernate中,管理Session和执行批量操作是优化数据库交互的关键技术。本文主要探讨了如何高效地管理Hibernate的Session以及如何实施批量处理数据,这些技巧对于提升应用程序性能至关重要。 首先...
在Java的持久化框架Hibernate中,缓存机制和Session对象的管理是其高效运作的关键要素。本文将深入探讨这两个主题,以帮助开发者更好地理解和利用Hibernate。 首先,让我们聚焦于Hibernate的缓存机制。缓存的存在是...
session.flush(); session.clear(); } } tx.commit(); session.close(); ``` 对于更新和删除操作,可以使用`scroll()`方法,这在Hibernate 2.1.6或更高版本中是支持的。`scroll()`方法返回一个`...
2. **缓存与数据库的同步**:当我们调用`Session.flush()`方法时,Hibernate会将一级缓存中所有更改过的对象同步到数据库,确保数据的一致性。而在事务提交(`Transaction.commit()`)时,Hibernate会自动执行flush...