ITKeyword - 技术文章推荐分享

首页 > hibernate缓存详解

hibernate缓存详解

相关推荐:框架 day32 Hibernate,一级缓存,关联关系映射(一对多,多对多)

一级缓存概念*在 Session 接口的实现中包含一系列的 Java 集合, 这些 Java集合构成了Session缓存.只要 Session 实例没有结束生命周期, 存放在它缓存中的对象也不会结束生命周期*当session的save()方法持久化一个对象时,该对象被载

为什么要用hibernate缓存?hibernate是一个持久层框架,经常访问物理数据库。为了降低应用程序对物理数据源访问的次数,从而提高应用程序的运行性能,我们想到使用hibernate缓存机制。缓存内的数据是对物理数据源中的数据的复制,应用程序在运行时从缓存读写数据,在特定的时刻或事件会同步缓存和物理数据源的数据。hibernate缓存的原理缓存的主要作用是查询。hibernate缓存包括三大类:hibernate一级缓存、hibernate二级缓存和hibernate查询缓存。一级缓存一级缓存是hibernate自带的,不受用户干预。hibernate是一个线程对应一个session,一个线程可以看成一个用户。也就是说session级缓存只能给一个线程用,别的线程用不了,一级缓存就是和线程绑定的。其生命周期和session的生命周期一致,当前session一旦关闭,一级缓存就会消失,因此,一级缓存也叫session缓存或者事务级缓存,一级缓存只存储实体对象,不会缓存一般的对象属性,即:当获得对象后,就将该对象缓存起来,如果在同一个session中再去获取这个对象时,它会先判断缓存中有没有这个对象的ID,如果有,就直接从缓存中取出,否则,则去访问数据库,取了以后同时会将这个对象缓存起来。Session内置不能被卸载,Session的缓存是事务范围的缓存(Session对象的生命周期通常对应一个数据库事务或者一个应用事务)。一级缓存中,持久化类的每个实例都具有唯一的OID。缓存和连接池的区别:缓存和池都是放在内存里,实现是一样的,都是为了提高性能的。但有细微的差别,池是重量级的,里面的数据是一样的,比如一个里放100个connection连接对象,这100个对象都是一样的。而缓存里的数据,每个都不一样。比如读取100条数据库记录放到缓存里,这100条记录都不一样。以下我们结合具体示例来学习一级缓存:import java.io.Serializable;import java.util.Iterator;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration;public class CacheDemo {

private static SessionFactory sessionFactory;

static{

sessionFactory = new Configuration().configure().buildSessionFactory();

}

/**

* 同一个Session发出两次load方法查询

*

* 第二次查询的数据和第一次相同,第二次load方法是从缓存里取数据,而不会再发出sql语句到数据库中进行查询。

*/

public void cacheTest1(){

Session session = sessionFactory.openSession();

session.beginTransaction();

//第一次load查询

Student student = session.load(Student.class, 1);

System.out.println("student.name : " + student.getName());

System.out.println("*************************************");

//第二次load查询(使用缓存)

student = session.load(Student.class, 1);

System.out.println("student.name : " + student.getName());

}

/**

* 同一个Session发出两次get方法查询

*

* 第二次查询的数据和第一次相同,第二次get方法是从缓存里取数据,而不会再发出sql语句到数据库中进行查询。

*/

public void cacheTest2(){

Session session = sessionFactory.openSession();

session.beginTransaction();

//第一次get查询

Student student = session.get(Student.class, 1);

System.out.println("student.name : " + student.getName());

System.out.println("*************************************");

//第二次get查询(使用缓存)

student = session.get(Student.class, 1);

System.out.println("student.name : " + student.getName());

}

/**

* 同一个Session发出两次iterator查询对象

*

* 说起iterator查询,我们会想到,iterator查询在没有缓存的情况下会有N+1的问题。

* 执行上面的代码,我们可以看到,第一次iterator查询会发出N+1条语句,第一条sql语句查询所有的ID,

* 然后根据ID查询实体对象,有N个ID就出N条语句查询实体。第二次iterator查询,却只发一条sql语句,

* 查询所有的ID,然后根据ID到缓存里取实体对象,不再发sql语句到数据库里查询了。

*/

public void cacheTest3(){

Session session = sessionFactory.openSession();

session.beginTransaction();

//第一次iterator查询

Iterator iter = session.createQuery("from student s where s.id < 5").iterate();

while (iter.hasNext()) {

Student student = (Student)iter.next();

System.out.println("student.name : " + student.getName());

}

System.out.println("*************************************");

//第二次iterator查询(使用缓存)

iter = session.createQuery("from student s where s.id < 5").iterate();

while (iter.hasNext()) {

Student student = (Student)iter.next();

System.out.println("student.name : " + student.getName());

}

}

/**

* 同一个Session发出两次iterator查询对象的普通属性

*

* 执行上面的代码,我们可以看到,第一次iterator查询会发出N+1条语句,第二次iterator查询还是发了N+1条sql语句,

* 因为一级缓存只是缓存实体对象,而不缓存对象属性,所以在iterate第二次查询普通属性时,无法从缓存中获取,

* 从而跟第一次查询发出相同条数的sql语句。

*/

public void cacheTest4(){

Session session = sessionFactory.openSession();

session.beginTransaction();

//第一次iterator查询

Iterator iter = session.createQuery("select s.name from student s where s.id < 5").iterate();

while (iter.hasNext()) {

String name = (String)iter.next();

System.out.println("student.name : " + name);

}

System.out.println("*************************************");

//第二次iterator查询(使用缓存)

iter = session.createQuery("select s.name from student s where s.id < 5").iterate();

while (iter.hasNext()) {

String name = (String)iter.next();

System.out.println("student.name : " + name);

}

}

/**

* 两个session,每个session发出一个load方法查询实体对象

*

* 第一个session的load方法会发出sql语句查询实体对象,第二个session的load方法也会发出sql语句查询实体对象。

* session间不能共享一级缓存的数据,第一个session中的数据在其被关闭的时候就已经不存在了,

* 所以第二个session的load方法查询相同的数据还是要到数据库中查询。

*/

public void cacheTest5(){

Session session = null;

//第一个session的load查询

try {

session = sessionFactory.openSession();

session.beginTransaction();

Student student = session.load(Student.class, 1);

System.out.println("student.name : " + student.getName());

session.getTransaction().commit();

} catch (Exception e) {

session.getTransaction().rollback();

}finally{

session.close();//关闭session

}

System.out.println("***********************************");

//第二个session的load查询

try {

session = sessionFactory.openSession();

session.beginTransaction();

Student student = session.load(Student.class, 1);

System.out.println("student.class : " + student.getName());

session.getTransaction().commit();

} catch (Exception e) {

session.getTransaction().rollback();

}finally{

session.close();

}

}

/**

* 同一个session,先调用save方法再调用load方法查询刚刚save的数据

*

* 先save保存实体对象,再用load方法查询刚刚save的实体对象,则load方法不会发出sql语句到数据库查询的,

* 而是到缓存里取数据,因为save方法也支持缓存。当然前提是同一个session。

*/

public void cacheTest6(){

Session session = sessionFactory.openSession();

session.beginTransaction();

Student student = new Student().setName("Tom");

//save方法返回实体对象的ID

Serializable id = session.save(student);

//load查询刚刚save的数据

student = session.load(Student.class, 1);

System.out.println("student.name : " + student.getName());

}

/**

* 大

相关推荐:企业框架源码 SpringMVC mybatis or hibernate ehcache二级缓存maven非和maven版本

获取【下载地址】 QQ: 313596790 【免费支持更新】三大数据库 mysqloraclesqlsever 更专业、更强悍、适合不同用户群体【新录针对本系统的视频教程,手把手教开发一个模块,快速掌握本系统】A 集成代码生成器(开发利器);

批量的数据添加

*

* 大批量数据添加时,会造成内存溢出的,因为save方法支持缓存,每save一个对象就往缓存里放,如果对象足够多内存肯定要溢出。

* 一般的做法是先判断一下save了多少个对象,如果save了40个对象就对缓存手动的清理缓存,这样就不会造成内存溢出。

*

* 注意:清理缓存前,要手动调用flush方法同步到数据库,否则save的对象就没有保存到数据库里。

*

* 建议:大批量数据的添加还是不要使用hibernate,这是hibernate弱项。

*

可以使用jdbc(速度也不会太快,只是比hibernate好一点),或者使用工具产品来实现,

*

比如oracle的Oracle SQL Loader,导入数据特别快。

*/

public void cacheTest7(){

Session session = sessionFactory.openSession();

session.beginTransaction();

for (int i = 0; i < 100; i++) {

Student student = new Student().setName("Tom"+i);

session.save(student);

//每40条数据更新一次

if (i % 40 == 0) {

session.flush();

session.clear();//清除缓存数据

}

}

}}二级缓存二级缓存也称为进程缓存或者sessionFactory级的缓存,它可以被所有的session共享,二级缓存的生命周期和sessionFactory的生命周期一致,二级缓存也是只存储实体对象。二级缓存的一般过程如下:①:条件查询的时候,获取查询到的实体对象 ②:把获得到的所有数据对象根据ID放到二级缓存中 ③:当Hibernate根据ID访问数据对象时,首先从sesison的一级缓存中查,查不到的时候如果配置了二级缓存,会从二级缓存中查找,如果还查不到,再查询数据库,把结果按照ID放入到缓存中 ④:进行delete、update、add操作时会同时更新缓存由于SessionFactory对象的生命周期和应用程序的整个过程对应,因此Hibernate二级缓存是进程范围或者集群范围的缓存,有可能出现并发问题,因此需要采用适当的并发访问策略,该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的,是一个可配置的插件,默认下SessionFactory不会启用这个插件。Hibernate提供了org.hibernate.cache.CacheProvider接口,它充当缓存插件与Hibernate之间的适配器。 二级缓存比较复杂,hibernate做了一些优化,和一些第三方的缓存产品做了集成。。hibernate提供了一个简单实现,用Hashtable做的,只能作为我们的测试使用,商用还是需要第三方产品。使用缓存,肯定是长时间不改变的数据,如果经常变化的数据放到缓存里就没有太大意义了。因为经常变化,还是需要经常到数据库里查询,那就没有必要用缓存了。什么样的数据适合存放到第二级缓存中?

1) 很少被修改的数据

2) 不是很重要的数据,允许出现偶尔并发的数据

3) 不会被并发访问的数据

4) 常量数据

什么样的数据不适合存放到第二级缓存中?

1) 经常被修改的数据

2) 绝对不允许出现并发访问的数据,如财务数据,绝对不允许出现并发

3) 与其他应用共享的数据。我们以一个和EHCache二级缓存产品集成的示例来看一下程序代码实现:EHCache的jar文件在hibernate的lib里,我们还需要设置一系列的缓存使用策略,需要一个配置文件ehcache.xml来配置。这个文件放在类路径下。//默认配置,所有的类都遵循这个配置<defaultCache

//缓存里可以放10000个对象

maxElementsInMemory="10000"

//过不过期,如果是true就是永远不过期

eternal="false"

//一个对象被访问后多长时间还没有访问就失效(120秒还没有再次访问就失效)

timeToIdleSeconds="120"

//对象存活时间(120秒),如果设置永不过期,这个就没有必要设了

timeToLiveSeconds="120"

//溢出的问题,如果设成true,缓存里超过10000个对象就保存到磁盘里

overflowToDisk="true"/>我们也可以对某个对象单独配置:<cache name="com.bjpowernode.hibernate.Student"

maxElementsInMemory="100"

eternal="false"

timeToIdleSeconds="10000"

timeToLiveSeconds="10000"

overflowToDisk="true"/><!-- 配置缓存提供商 --><property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property><!-- 启用二级缓存,这也是它的默认配置 --><property name="hibernate.cache.use_second_level_cache">true</property>启用二级缓存的配置可以不写的,因为默认就是true开启二级缓存。必须还手动指定那些实体类的对象放到缓存里在hibernate.cfg.xml里://在<sessionfactory>标签里,在<mapping>标签后配置<class-cache class="com.bjpowernode.hibernate.Student" usage="read-only"/>或者在实体类映射文件里://在<class>标签里,<id>标签前配置<cache usage="read-only"/>usage属性表示使用缓存的策略,一般优先使用read-only,表示如果这个数据放到缓存里了,则不允许修改,如果修改就会报错。这就要注意我们放入缓存的数据不允许修改。因为放缓存里的数据经常修改,也就没有必要放到缓存里。使用read-only策略效率好,因为不能改缓存。但是可能会出现脏数据的问题,这个问题解决方法只能依赖缓存的超时,比如上面我们设置了超时为120秒,120后就可以对缓存里对象进行修改,而在120秒之内访问这个对象可能会查询脏数据的问题,因为我们修改对象后数据库里改变了,而缓存却不能改变,这样造成数据不同步,也就是脏数据的问题。第二种缓存策略read-write,当持久对象发生变化,缓存里就会跟着变化,数据库中也改变了。这种方式需要加解锁,效率要比第一种慢。下面我们结合具体示例来学习二级缓存:

/**

* 开启二级缓存,两个session,每个session发出一个load/get方法查询实体对象

*

* 第二次查询的数据和第一次相同,不会发出查询语句,因为配置二级缓存,session可以共享二级缓存中的数据。

* 所以第二次load方法是从缓存里取数据,而不会再发出sql语句到数据库中进行查询。

*/

public void cacheTest1(){

Session session = null;

//第一次load查询

try {

session = sessionFactory.openSession();

session.beginTransaction();

Student student = session.load(Student.class, 1);

System.out.println("student.name : " + student.getName());

session.getTransaction().commit();

} catch (Exception e) {

session.getTransaction().rollback();

}finally{

session.close();//关闭session

}

System.out.println("***********************************");

//第二次load查询

try {

session = sessionFactory.openSession();

session.beginTransaction();

Student student = session.load(Student.class, 1);

System.out.println("student.class : " + student.getName());

session.getTransaction().commit();

} catch (Exception e) {

session.getTransaction().rollback();

}finally{

session.close();

}

}}注意:二级缓存必须让sessionfactory管理,让sessionfactory来清除二级缓存。sessionFactory.evict(Student.class);//清除二级缓存中所有student对象sessionFactory.evict(Student.class,1);//清除二级缓存中id为1的student对象如果在第一个session调用load或get方法查询数据后,把二级缓存清除了,那么第二个session调用load或get方法查询相同的数据时,还是会发出sql语句查询数据库的,因为缓存里没有数据只能到数据库里查询。我们查询数据后会默认自动的放到二级和一级缓存里,如果我们想查询的数据不放到缓存里,也是可以的。也就是说我们可以控制一级缓存和二级缓存的交换。session.setCacheMode(CacheMode.IGNORE);禁止将一级缓存中的数据往二级缓存里放。还是用上面代码测试,在第一个session调用load方法前,执行session.setCacheMode(CacheMode.IGNORE);这样load方法查询的数据不会放到二级缓存里。那么第二个session执行load方法查询相同的数据,会发出sql语句到数据库中查询,因为二级缓存里没有数据,一级缓存因为不同的session不能共享,所以只能到数据库里查询。上面我们讲过大批量的数据添加时可能会出现溢出,解决办法是每当天就40个对象后就清理一次一级缓存。如果我们使用了二级缓存,光清理一级缓存是不够的,还要禁止一二级缓存交互,在save方法前调用session.setCacheMode(CacheMode.IGNORE)二级缓存也不会存放普通属性的查询数据,这和一级缓存是一样的,只存放实体对象。session级的缓存对性能的提高没有太大的意义,因为生命周期太短了。查询缓存查询缓存意义不大,查询缓存说白了就是存放由list方法或iterate方法查询的数据。我们在查询时很少出现完全相同条件的查询,这也就是命中率低,这样缓存里的数据总是变化的,所以说意义不大。除非是多次查询都是查询相同条件的数据,也就是说返回的结果总是一样,这样配置查询缓存才有意义。我们这里不做过多解释。Hibernate查找对象如何应用缓存?当Hibernate根据ID访问数据对象的时候,首先从Session一级缓存中查;查不到,如果配置了二级缓存,那么从二级缓存中查;如果都查不到,再查询数据库,把结果按照ID放入到缓存删除、更新、增加数据的时候,同时更新缓存。最后贴出一个一级缓存和二级缓存的对比图:

$(function () {

$('pre.prettyprint code').each(function () {

var lines = $(this).text().split('\n').length;

var $numbering = $('<ul/>').addClass('pre-numbering').hide();

$(this).addClass('has-numbering').parent().append($numbering);

for (i = 1; i <= lines; i++) {

$numbering.append($('<li/>').text(i));

};

$numbering.fadeIn(1700);

});

});

相关推荐:JAVA框架之Hibernate【Hibernate缓存详解】

1、缓存介绍Hibernate中提供了两级Cache,第一级别的缓存是Session级别的缓存,它是属于事务范围的缓存。这一级别的缓存由hibernate管理的,一般情况下无需进行干预;第二级别的缓存是SessionFactory级别的缓存,它是属于进程范围或群集范围的缓存。这一级别

为什么要用hibernate缓存?hibernate是一个持久层框架,经常访问物理数据库。为了降低应用程序对物理数据源访问的次数,从而提高应用程序的运行性能,我们想到使用hibernate缓存机制。缓存内...

------分隔线----------------------------