为什么要用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方法返回实体对象的IDSerializable id = session.save(student);//load查询刚刚save的数据student = session.load(Student.class, 1);System.out.println("student.name : " + student.getName());}/*** 大批量的数据添加* * 大批量数据添加时，会造成内存溢出的，因为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放入到缓存删除、更新、增加数据的时候，同时更新缓存。

最后贴出一个一级缓存和二级缓存的对比图：

【大话Hibernate】hibernate缓存详解相关推荐

Hibernate二级缓存详解（转）
Hibernate二级缓存详解(转) 本文转载 http://www.blogjava.net/supercrsky/articles/238580.html 与Session相对的是,Session ...
Hibernate二级缓存详解
与Session相对的是,SessionFactory也提供了相应的缓存机制.SessionFactory缓存可以依据功能和目的的不同而划分为内置缓存和外置缓存. SessionFactory的内置 ...
(转）Hibernate的配置详解
http://blog.csdn.net/yerenyuan_pku/article/details/65041077 在<Hibernate快速入门>一文中,我有讲到Hibernate的 ...
struts2+hibernate+spring配置详解
#struts2+hibernate+spring配置详解 struts2+hibernate+spring配置详解哎 ,当初一个人做好难,现在终于弄好了,希望自学这个的能少走些弯路. 以下是自己配 ...
Java开源项目Hibernate包作用详解
Java开源项目Hibernate包作用详解本文引自:http://hi.baidu.com/nick6610/blog/item/70b58afa0d0eab9259ee90f7.html Jav ...
Hibernate Criteria对象详解(条件查询)
Hibernate Criteria对象详解 2014-9-1 16:21| 发布者: 传智特刊| 查看: 7290| 评论: 0 摘要: Hibernate框架是目前JavaEE软件开发的企业主流框 ...
MyBatis 一级缓存二级缓存详解
相关内容: 架构师系列内容:架构师学习笔记(持续更新) MyBatis 缓存详解 cache 缓存缓存是一般的ORM 框架都会提供的功能,目的就是提升查询的效率和减少数据库的压力.跟Hibernat ...
[面试专题]Web缓存详解
Web缓存详解标签(空格分隔): 缓存缓存之于性能优化请求更快:通过将内容缓存在本地浏览器或距离最近的缓存服务器(如CDN),在不影响网站交互的前提下可以大大加快网站加载速度. 降低服务器压力: ...
vue里页面的缓存详解
关于vue里页面的缓存详解实用的例子ABC 往下查看 keep-alive是vue内置的一个组件,可以使被它包含的组件处于保留状态,或避免被重新渲染. 用法: 在keep-alive标签内部添加 i ...
Spring循环依赖和三级缓存详解
Spring循环依赖和三级缓存详解 Spring在启动过程中,使用到了三个map,称为三级缓存我们可以这样理解,假设,我们只有一个缓存容器,并且缓存是直接开放给用户可以调用的,如果将未完成赋值的Be ...

【大话Hibernate】hibernate缓存详解