Hibernate一级缓存 & 二级缓存（转）

一、一级缓存Session的操作与维护

1.Hibernate对象的三种状态: transient, persistent, detached

1) transient:瞬时状态           

利用new关键字创建的对象,没有与Hibernate实施交互的，也无法保证与数据库中某条记录对应的对象被称为瞬时状态，也就是生命周期非常短的意思，因为没有任何组件管理的对象非常容易被Java虚拟机回收。

例:Customer cus = new Customer();//瞬时状态对象

 

2) persistent:持久化状态

将瞬时状态的对象保存到Hibernate缓存中，受Hibernate管理的对象被称为持久化状态Hibernate在调用flush, close ,clear方法的时候会清理缓存保证持久化对象与底层数据库的同步，所有的持久化对象，Hibernate均会为它设置一个唯一性标识符保证其在缓存中的唯一性，这个标识符可能是hashCode,带主键查询的sql语句或者其他保证唯一的字符。

save(new object),update(new object),saveorupdate(new object),persisnt(new object)

可以将一个瞬时状态转变为持久化对象

 

save(new object), persistent (new object):利用select sql where id 加载一个对象

如果加载成功那么直接显示异常(插入不允许带相同标识符的组件在缓存中存在)

 

update(new object):不执行SQL语句，直接将对象加载入内存做更新准备

如果缓存中已经拥有一个同标识符的组件，那么显示异常，因为update只能做更新处理

无法处理两个完全一致的对象(merge(new object)可以克服这个问题)

 

saveorupdate(new object):利用select sql where id 加载一个对象

如果加载成功那么直接更新，否则插入

 

注意:业务层/表示层/应用层对于持久化状态对象的更改都会引起Hibernate的同步处理(反映到数据库中)

 

3) detached:游离托管状态

缓存中已经失去该对象或者该对象的标识符，虽然对象仍然存在，对象也和数据表中的记录有对应但是由于失去了Hibernate的控制，因此该对象被称为游离托管状态。

 

注意:业务层/表示层/应用层对于托管状态对象的更改不会会引起Hibernate的同步处理

 

游离托管状态的对象是指:已经经过Hibernate管理后,

因为Session.delete(),Session.close(),Session.clear(),Session.evict()

方法的执行而失去标识符的，所以托管状态和瞬时状态的对的区别是是否受过Hibernate的管理，数据表中是否有对应的记录，托管对象只有通过lock(),update(),saveorupdate()被重新加入缓存变成持久化对象才能实施数据同步

 

2、特殊方法:persisnt(),merge()

persisnt和save方法是差不多的，唯一的区别是针对sqlserver的identity字段的处理save为了保证持久化标识符，所以会在save的过程中就直接执行insert into....select identity();以获取最新的主键信息。

persisnt执行的时机是Transaction.commit()，Session.clear(),Session.flush()的时候

 

merge()与update()类似，但是区别是对于瞬时状态的理解。

假设现在有一个瞬时状态的new Customer(1)，同时Session利用get(),load()方法

产生一个持久化状态的对象Session.get(Customer.class,1),这个时候使用update方法会抛出异常，而merge会将瞬时状态Customer中的属性复制到持久化状态的Customer

中。

 

3、查询对于一级缓存的使用

1）Session.get, Session.load方法

Session.get：迫切加载

第一查询：查询一级缓存Session缓存，如果没有那么查询二级缓存SessionFactory缓存（如果没有配置，此步省略）,如果找不到那么执行Select…..From…..Where id = ?，如果数据被查到那么将查到的数据封装到对象中，对象被分别保存在一级缓存Session缓存中，和二级缓存SessionFactory缓存（如果没有配置，此步省略）。

第二查询：查询一级缓存Session缓存，,如果找不到那么执行Select…..From…..Where id = ?，如果数据被查到那么将查到的数据封装到对象中，对象被保存在一级缓存Session缓存中。

Session.load：延迟加载

Session.load认为加载始终是成功的，所以它始终不会与数据库交互，因为load认为查询一定会成功，因此只有当需要访问被加载实体属性的时候，Session.load才会按照Session.get的查询轨迹实施搜寻，不同的是Session.load始终会查询一，二级缓存再执行SQL语句

如果SQL语句无法返回对象，那么Session.load直接抛出异常。

 

2）Query.list, Query.iterator方法

Query.list：查询过程中不会读取任何缓存尤其是一级缓存，而是直接执行SQL语句，SQL语句有Query的HQL转换而得，执行结果会被保存在一级缓存中。

我们可以通过ehcache缓存组件为Hibernate配置查询缓存(query cache[hibernate 3.x以上版本])，这Query.list会每次查询的过程中先访问二级缓存中的查询缓存，如果没有再执行SQL语句，查询返回的结果会分别保存在一，二级缓存中。

 

Query.iterator:与Query.list的不同在于，它会每次访问均查询一级缓存，但是

Query.iterator记载数据的方式不是完整的SQL语句，而是N+1条SQL语句

例如：Query.list 对于一张5条记录的表的检索方式是Select ….. From Customer

而Query.iterator的检索方式是:

执行5句Select ….. From Customer where id = ?（单个对象实施记载）

  

二、二级缓存SessionFactory 的配置与测试

1. 利用ehcache配置Second level cache 和 Query cache

在src目录下建立ehcache.xml文件内容如下:

<?xml version="1.0" encoding="UTF-8" ?>2 <ehcache>3 <!—4     设置对象钝化目录，二级缓存中长时间不使用或者超时的对象5     会被保存在当前目录\java\io\tmpdir目录中，这样可以节省空间 6 -->7 <diskStore path="java.io.tmpdir"/>8 9 </ehcache>

<!-- 默认二级缓存工作模式 2          maxElementsInMemory:缓存中最大对象数 3          eternal:缓存中的对象是否永久保留 4          timeToIdleSeconds:多少毫秒后可以考虑一个对象的放入钝化目录中 5          timeToLiveSeconds:多少毫秒后可以考虑一个对象从激活状态-闲置状态 6          overflowToDisk:是否允许将闲置对象钝化入硬盘 7          diskPersistent:钝化后该对象是否允许永久无法反钝化 8          diskExpiryThreadIntervalSeconds:钝化线程间隔处理时间(毫秒) 9          memoryStoreEvictionPolicy:钝化对象选择模型(LRU:使用最少的先钝化技术)10     -->11     <defaultCache12             maxElementsInMemory="10000"13             eternal="false"14             timeToIdleSeconds="120"15 16             timeToLiveSeconds="120"17             overflowToDisk="true"18             diskPersistent="false"19             diskExpiryThreadIntervalSeconds="120"20             memoryStoreEvictionPolicy="LRU"21 22             />

<!-- 默认二级查询缓存工作模式-->2    <cache name="org.hibernate.cache.StandardQueryCache"3             maxElementsInMemory="10000" 4             eternal="false" 5             timeToIdleSeconds="1800" 6             timeToLiveSeconds="0" 7             overflowToDisk="true"/>

<!-- 为时间邮差准备的二级查询缓存工作模式 2          主要有同步数据方法调用,例如lock(LockMode.READ) 3     -->          4    <cache name="org.hibernate.cache.UpdateTimestampsCache" 5             maxElementsInMemory="5000" 6             eternal="true" 7             timeToIdleSeconds="1800" 8  9             timeToLiveSeconds="0"             10             overflowToDisk="true"/>

2. 配置h 注意：缓存监控方法如果要能够执行，需要在hibernate.cfg.xml中设置以下配置

ibernate.cfg.xml

<!-- 使用ehcache第三方缓存技术 --> 2     <property name="cache.provider_class"> 3         net.sf.ehcache.hibernate.EhCacheProvider 4     </property> 5     <!-- 启用运行查询缓存 --> 6     <property name="cache.use_query_cache">true</property> 7  8     <!-- 启用二级缓存（SessionFactory缓存） --> 9     <property 10     name="cache.use_second_level_cache">true</property>

3. 为需要二级缓存管理的对象设置标识列(*.hbm.xml)

<hibernate-mapping> 2  <class name="cn.newtouch.myhibernate.po.Customer" schema="HIBERNATE" table="CUSTOMER"> 3  4   <!— 表示Customer需要受到缓存管理 --> 5     <cache usage="read-write"/> 6   <id name="id" type="java.lang.Long"> 7    <column name="ID" precision="8" scale="0"/> 8  9    <generator class="assigned"/>10   </id>

4. 测试实体查询对于二级缓存的执行模式：

public void testSecondLevelCacheForEntityQuery() { 2         Configuration cfg = new Configuration().configure(); 3         SessionFactory factory = cfg.buildSessionFactory(); 4         Session cnn = factory.openSession(); 5         SessionStatistics ss = cnn.getStatistics(); 6         Statistics s = factory.getStatistics(); 7         cnn.get(Customer.class, 1l); 8         System.out.println("FIRST GET:" +ss.getEntityCount()); 9         System.out.println("FIRST GET PUT:" +10                                   s.getSecondLevelCachePutCount());11         System.out.println("FIRST GET MISS:" + 12     s.getSecondLevelCacheMissCount());13         System.out.println("FIRST GET HIT:" + 14     s.getSecondLevelCacheHitCount());    15         cnn.get(Customer.class, 1l);16             17         System.out.println("SECOND GET:" +ss.getEntityCount());18         System.out.println("SECOND GET PUT:" + 19     s.getSecondLevelCachePutCount());20         System.out.println("SECOND GET MISS:" + 21     s.getSecondLevelCacheMissCount());22         System.out.println("HIT:" + 23     s.getSecondLevelCacheHitCount());24         cnn.clear();25         System.out.println("BEFORE CLEAR:" + ss.getEntityCount());26         System.out.println("BEFORE CLEAR PUT:" + 27     s.getSecondLevelCachePutCount());28         System.out.println("BEFORE CLEAR MISS:" + 29     s.getSecondLevelCacheMissCount());30         System.out.println("BEFORE CLEAR HIT:" + 31     s.getSecondLevelCacheHitCount());32         33     Session anotherSession = factory.openSession();34         anotherSession.get(Customer.class, 1l);35         System.out.println("ANOTHER SESSION:" + 36     ss.getEntityCount());37         System.out.println("ANOTHER SESSION PUT:" + 38     s.getSecondLevelCachePutCount());39         System.out.println("ANOTHER SESSION MISS:" + 40     s.getSecondLevelCacheMissCount());41         System.out.println("ANOTHER SESSION HIT:" + 42     s.getSecondLevelCacheHitCount());43         anotherSession.clear();44     }

测试二级缓存的结果是

FIRST GET:1FIRST GET PUT:1FIRST GET MISS:1FIRST GET HIT:0=======================================SECOND GET:1SECOND GET PUT:1SECOND GET MISS:1SECOND GET HIT:0=======================================BEFORE CLEAR:0BEFORE CLEAR PUT:1BEFORE CLEAR MISS:1BEFORE CLEAR HIT:0=======================================ANOTHER SESSION:0ANOTHER SESSION PUT:1ANOTHER SESSION MISS:1ANOTHER SESSION HIT:1

5. 测试HQL查询对于二级缓存的执行模式

public void testSecondLevelCacheForQueries() { 2          3         Configuration cfg = new Configuration().configure(); 4         SessionFactory factory = cfg.buildSessionFactory(); 5         Session cnn = factory.openSession(); 6          7     SessionStatistics ss = cnn.getStatistics(); 8         Statistics s = factory.getStatistics(); 9         10     Query query = 11             cnn.createQuery("From Customer A");12         query.setCacheable(true);13     query.setCacheRegion(14     "cn.newtouch.myhibernate.po.Customer");15         query.list();16         System.out.println("FIRST Query:" +ss.getEntityCount());17 System.out.println("Level's PUT:" + 18     s.getSecondLevelCachePutCount());19 System.out.println("Level's MISS:" + 20     s.getSecondLevelCacheMissCount());21 System.out.println("Level's HIT:" +    22     s.getSecondLevelCacheHitCount());23 System.out.println("Queries's PUT:" + 24     s.getQueryCachePutCount());25 System.out.println("Queries's MISS:" + 26     s.getQueryCacheMissCount());27 System.out.println("Queries's HIT:" + 28     s.getQueryCacheHitCount());29 System.out.println("=======================================");30 31         query = cnn.createQuery("From Customer A");32         query.setCacheable(true);33     query.setCacheRegion(34     "cn.newtouch.myhibernate.po.Customer");35         query.list();36             37 System.out.println("SECOND Query:" +ss.getEntityCount());38 System.out.println("Level's PUT:" + 39     s.getSecondLevelCachePutCount());40 System.out.println("Level's MISS:" + 41     s.getSecondLevelCacheMissCount());42 System.out.println("Level's HIT:" +    43     s.getSecondLevelCacheHitCount());44 System.out.println("Queries's PUT:" + 45     s.getQueryCachePutCount());46 System.out.println("Queries's MISS:" + 47     s.getQueryCacheMissCount());48 System.out.println("Queries's HIT:" + 49     s.getQueryCacheHitCount());50 System.out.println("=======================================");51         52         cnn.clear();53         System.out.println("BEFORE CLEAR:" +ss.getEntityCount());54 System.out.println("Level's PUT:" + 55     s.getSecondLevelCachePutCount());56 System.out.println("Level's MISS:" + 57     s.getSecondLevelCacheMissCount());58 System.out.println("Level's HIT:" +    59     s.getSecondLevelCacheHitCount());60 System.out.println("Queries's PUT:" + 61     s.getQueryCachePutCount());62 System.out.println("Queries's MISS:" + 63     s.getQueryCacheMissCount());64 System.out.println("Queries's HIT:" + 65     s.getQueryCacheHitCount());66 System.out.println("=======================================");67     68         Session anotherSession = factory.openSession();69         70         query = 71             anotherSession.createQuery("From Customer A");72         query.setCacheable(true);73     query.setCacheRegion(74     "cn.newtouch.myhibernate.po.Customer");75         query.list();76         77 System.out.println("ANOTHER SESSION:" +ss.getEntityCount());78 System.out.println("Level's PUT:" + 79     s.getSecondLevelCachePutCount());80 System.out.println("Level's MISS:" + 81     s.getSecondLevelCacheMissCount());82 System.out.println("Level's HIT:" +    83     s.getSecondLevelCacheHitCount());84 System.out.println("Queries's PUT:" + 85     s.getQueryCachePutCount());86 System.out.println("Queries's MISS:" + 87     s.getQueryCacheMissCount());88 System.out.println("Queries's HIT:" + 89     s.getQueryCacheHitCount());90 System.out.println("=======================================");91         92         anotherSession.clear();93 ｝

测试二级缓存的结果是：

FIRST Query:2 2 Level's PUT:2 3 Level's MISS:0 4 Level's HIT:0 5 Queries's PUT:1 6 Queries's MISS:1 7 Queries's HIT:0 8 ======================================= 9 SECOND Query:210 Level's PUT:211 Level's MISS:012 Level's HIT:013 Queries's PUT:114 Queries's MISS:115 Queries's HIT:116 =======================================17 BEFORE CLEAR:018 Level's PUT:219 Level's MISS:020 Level's HIT:021 Queries's PUT:122 Queries's MISS:123 Queries's HIT:124 =======================================25 ANOTHER SESSION:026 Level's PUT:227 Level's MISS:028 Level's HIT:229 Queries's PUT:130 Queries's MISS:131 Queries's HIT:2

注意：缓存监控方法如果要能够执行，需要在hibernate.cfg.xml中设置以下配置

 

<property name="generate_statistics">true</property>

 

以下情况适合使用二级缓存：

1、很少被修改的数据

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

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

4、参考数据,指的是供应用参考的常量数据，它的实例数目有限，它的实例会被许多其他类的实例引用，实例极少或者从来不会被修改。

Hibernate二级缓存的并发策略你了解吗：

1 只读缓存 read only 
不须要锁与事务，因为缓存自数据从数据库加载后就不会改变。

    如果数据是只读的，例如引用数据，那么总是使用“read-only”策略，因为它是最简单、最高效的策略，也是集群安全的策略。是性能第一的策略 。

2 读写缓存 read write 
对缓存的更新发生在数据库事务完成后。缓存需要支持锁。
在一个事务中更新数据库，在这个事务成功完成后更新缓存，并释放锁。 
锁只是一种特定的缓存值失效表述方式，在它获得新数据库值前阻止其他事务读写缓存。那些事务会转而直接读取数据库。
缓存必须支持锁，事务支持则不是必须的。如果缓存是一个集群，“更新缓存”的调用会将新值推送给所有副本，这通常被称为“推（push）”更新策略。

    如果你的数据是又读又写的，那么使用“read-write”策略。这通常是性能第三的策略，因为它要求有缓存锁，缓存集群中使用重量级的“推”更新策略。

3 非严格读写缓存 nonstrict read write 
在一个事务中更新数据库，在这个事务完成前就清除缓存，为了安全起见，无论事务成功与否，在事务完成后再次清除缓存。
既不需要支持缓存锁，也不需要支持事务。如果是缓存集群，“清除缓存”调用会让所有副本都失效，这通常被称为“拉（pull）”更新策略。

    如果你的数据读很多或者很少有并发缓存访问和更新，那么可以使用“nonstrict-read-write”策略。感谢它的轻量级“拉”更新策略，它通常是性能第二好的策略。

4 事务缓存 transactional （一定要在JTA环境中）
对缓存和数据库的更新被包装在同一个JTA事务中，这样缓存与数据库总是保持同步的。数据库和缓存都必须支持JTA。

    除非你真的想将缓存更新和数据库更新放在一个JTA事务里，否则不要使用“transactional”策略，因为JTA需要漫长的两阶段提交处理，这导致它基本是性能最差的策略。

五、缓存锁的性能也要了解，知道加了锁后性能会下降： 
    为了保证数据的安全性，不发生脏数据，各个缓存通常使用锁来保证 
在本地方式运行时，缓存最大的开销就是使用锁来在保证共享数据完整性。 
在集群环境中，RPC调用，锁，是性能上大开销。

 

下面以JBoss Cache为例说一说锁：
JBoss Cache1.* 和 2.* 时代，提供乐观锁，悲观锁，但是性能不高。 
JBoss Cache3.0 MVCC锁方案性能很高。

悲观锁：这些锁的隔离级别和数据库实施的隔离级别相同，这种方案简单而且健壮，允许多用户同时读取数据。读操作阻塞写操作，悲观锁的读写是互斥的，无法同时进行的，写的性能不好。

乐观锁：这个方式则牵涉到数据版本，可以获得高度并发性。那些请求读取数据的用户不会因为并发数据库写入操作而受到阻塞。而且，乐观锁定方式还可以避免悲观锁定中有可能发生的死锁。但它仍然有两个主要的缺点：一是性能问题。因为不断的将结点的状态拷贝到每个并发线程所造成的内存和 CPU 开销是不容忽略的。二是尽管并发时允许了写操作，但是一旦发现数据的版本不对，事务提交时不可避免的还是会失败。也就是说，此时写事务虽然可以不受限制的进行大量处理和写操作，但是这样在事务结束的时候容易出现提交失败。

多版本并发控制（MVCC）：在数据访问速度上较之前者也胜出百倍。MVCC 提供了非阻塞 (non-blocking) 读操作 ( 它并不会去阻塞 wirter threads) ，在避免死锁的同时也提供了更高级的并发机制。更棒的是，我们的 MVCC 实现甚至可以对 reader threads 完全不采用任何锁 ( 对于像缓存这样频繁读取的系统来说，意义太大了 ) ，

 

六、批量处理时请不要使用二级缓存
当你执行大量的 添加与修改时，并且这个实体对象被配置为启用二级缓存，你考虑过二级缓存会怎么样吗？请看下面代码：

Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); for ( int i=0; i<100000; i++ ) { Customer customer = new Customer(.....); //如果你的 hibernate.cache.use_second_level_cache 是 true, 请在会话级别上关闭他 //向（任何一级）缓存中加载大量数据通常也意味着它们很快会被清除出去，这会增加GC开销。 session.setCacheMode(CacheMode.IGNORE); session.save(customer); if ( i % 50 == 0 ) { //将本批插入的对象立即写入数据库并释放内存 session.flush(); session.clear(); } } tx.commit(); session.close();