Hibernate缓存机制：

　　缓存范围：

　　　　应用程序中根据缓存的范围，可以将缓存分为三类:

　　　  （1）事务范围缓存（单Session，即一级缓存）
　　　　　　事务范围的缓存只能被当前事务访问，每个事务都有各自的缓存。缓存的生命周期依赖于事务的生命周期：当事务结束时，缓存的生命周期也会结束。事务范围的缓存使用内存作为存储介质。Hibernate中的一级缓存就属于事务范围。

　　　  （2）应用范围缓存（单SessionFactory，即二级缓存）
　　　　　　应用范围的缓存可以被应用程序内的所有事务共享访问。缓存的生命周期依赖于应用的生命周期，当应用结束时，缓存的生命周期同时结束。应用范围的缓存可以使用内存或硬盘作为存储介质。Hibernate的二级缓存就属于应用范围。

　　　  （3）集群范围缓存（多SessionFactory）
　　　　　　在集群环境中，缓存被一个机器或多个机器的进程共享，缓存中的数据被复制到集群环境中的每个进程节点，进程间通过远程通信来保证缓存中的数据的一致性，缓存中的数据通常采用对象的松散数据形式。有些Hibernate的二级缓存第三方插件支持集群范围缓存。

　　　（1） 一级缓存：

　　　　　　一级缓存，就是Session缓存，其实就是内存中的一块空间，在这个内存空间存放了相互关联的Java对象。Session缓存是事务级缓存。伴随着事务的开启而开启，伴随着事务的关闭而关闭。Session缓存由Hibernate进行管理。Session缓存，是Hibernate内置的。是不能被程序员取消的。即，只要使用Hibernate，就一定要使用，更确切地说，就一定在使用Session缓存。
　　　　　　当程序调用Session的load()方法、get()方法、save()方法、saveOrUpdate()方法、update()方法或查询接口方法时，Hibernate会对实体对象进行缓存。当通过load()或get()方法查询实体对象时，Hibernate会首先到缓存中查询，在找不到实体对象的情况下，Hibernate才会发出SQL语句到DB中查询。从而提高了Hibernate的使用效率。

　　　　　　一级缓存相关的方法：

　　　　　　　　evict(Object o)：从Session中删除指定对象

　　　　　　　　clear()：无参数，将Session缓存清空

　　　　　　　　contains(Object o)：判断指定对象是否在Session中存在

　　　　　　　　flush()：无参数，将Session中对象状态同步到DB中

　　　　　　快照（引用自北京动力节点）：

　　　　　　　　代码说明：

 1 @Test
 2 public void test01_SQL() {
 3     //1. 获取Session
 4     Session session = HbnUtils.getSession();
 5     try {
 6         //2. 开启事务
 7         session.beginTransaction();
 8         //3. 操作
 9         //session.get的时候，hibernate就将数据库中的数据加载到session缓存中，同时也会备份到快照中
10         Student student = session.get(Student.class, 2);
11         student.setName("n_2");
12         session.update(student);
13         //4. 事务提交
14         //commit是唯一的同步时间点，当程序运行到同步时间点时，
15         //hibernate先判断session缓存中的数据和快照中的数据是否相同，
16         //如果不相同，则更新数据库，如果相同，则不更新数据库，
17         //以上，两种情况，无论是否写了update，都成立
18         session.getTransaction().commit();
19     } catch (Exception e) {
20         e.printStackTrace();
21         //5. 事务回滚
22         session.getTransaction().rollback();
23     }
24 }

　　　　　Session的刷新与同步：

　　　　　　Session的刷新是指，Session缓存中的数据的更新。Session的同步是指，将Session缓存中的数据同步更新到DB中。执行同步的时间点只有一个：事务的提交。

　　　　　　当代码中执行了对Session中现有数据的修改操作，即update()与delete()语句后，Session缓存并不会马上刷新，即并不会马上执行update与delete的SQL语句，而是在某个时间点到来时，才会刷新缓存，更新缓存中的数据。刷新的时间点主要有三个：

　　　　　　　　（1）执行Query查询

　　　　　　　　（2）执行session.flush()

　　　　　　　　（3）执行事务的提交

　　　　　　通过Session的setFlushMode()方法，可以设置缓存刷新模式：

　　　　　　注意：增删改操作，当刷新时间点到来时是否马上进行缓存更新，各自情况还是不同的。

　　　　　　　　删除操作，一到达刷新时间点，马上执行delete语句，更新Session中数据；

　　　　　　　　更新操作，到达刷新时间点后，是否马上执行update语句，更新Session中数据，还要看该修改内容是否与快照一致若一致，则执行，否则，则不执行；

　　　　　　　　插入操作，无需等到刷新时间点的到达，见到save()后马上执行insert语句。因为插入操作不是修改Session中已经的存在数据，而是给Session中添加数据。

　　　（2） 二级缓存：

　　　　　　二级缓存是SessionFactory级的缓存，其生命周期与SessionFactory一致。SessionFactory缓存可以依据功能和目的的不同而划分为内置缓存和外置缓存。 
　　　　　　SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句，映射元数据是映射文件中数据的副本，而预定义SQL语句是在Hibernate初始化阶段根据映射元数据推导出来的SQL。SessionFactory的内置缓存是只读的，应用程序不能修改缓存中的映射元数据和预定义SQL语句，因此SessionFactory不需要进行内置缓存与映射文件的同步。
　　　　　　SessionFactory的外置缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用这个插件。外置缓存的数据是数据库数据的副本，外置缓存的介质可以是内存或者硬盘。SessionFactory的外置缓存也被称为Hibernate的二级缓存。
Hibernate本身只提供了二级缓存的规范，但并未实现，故需要第三方缓存产品的支持。常用的二级缓存第三方插件有： 
　　　　　　　　EHCache、Memcached、OSCache、SwarmCache、JBossCache等。这些插件的功能各有侧重，各有特点。

　　　　　　二级缓存的执行：当Hibernate根据ID访问数据对象时，首先会从一级缓存Session中查找。若查不到且配置了二级缓存，则会从二级缓存中查找；若还查不到，就会查询数据库，把结果按照ID放入到缓存中。执行增、删、改操作时，会同步更新缓存。

　　　　　　 二级缓存内容分类，根据缓存内容的不同，可以将Hibernate二级缓存分为四类：

　　　　　　　　　　（1）类缓存：缓存对象为实体类对象

　　　　　　　　　　（2）集合缓存：缓存对象为集合类对象

　　　　　　　　　　（3）更新时间戳缓存：

　　　　　　　　　　（4）查询缓存：缓存对象为查询结果

　　　　　　  二级缓存的并发访问策略：

　　　　　　　　事务型（transactional）：隔离级别最高，对于经常被读但很少被改的数据，可以采用此策略。因为它可以防止脏读与不可重复读的并发问题。发生异常的时候，缓存也能够回滚（系统开销大）。

　　　　　　　　读写型（read-write）：对于经常被读但很少被改的数据，可以采用此策略。因为它可以防止脏读的并发问题。更新缓存的时候会锁定缓存中的数据。

　　　　　　　　非严格读写型（nonstrict-read-write）：不保证缓存与数据库中数据的一致性。对于极少被改，并且允许偶尔脏读的数据，可采用此策略。不锁定缓存中的数据。

　　　　　　　　只读型（read-only）：对于从来不会被修改的数据，可使用此策略。

　　　　　　 二级缓存管理相关的方法：

　　　　　　　　与二级缓存管理相关的方法，一般都定义在Cache接口中。而Cache对象的获取，需要通过SessionFactory的getCache()方法：

　　　　　　　　　　Cache cache = sessionFactory.getCache();　　　　　　

　　　　 　　二级缓存的配置（应用EHCache插件）：

　　　　　　　　（1）导入ehcache的jar包，略

　　　　　　　　（2）在hibernate.cfg.xml中的<session-factory>元素中加入如下内容，开启二级缓存和注册二级缓存区域工厂：

1 <!-- 开启二级缓存 -->
2 <property name="hibernate.cache.use_second_level_cache">
3     true
4 </property>
5 <!-- 注册二级缓存区域工厂 -->
6 <property name="hibernate.cache.region.factory_class">
7     org.hibernate.cache.ehcache.EhCacheRegionFactory
8 </property>

　　　　　　　　（3）解压EHCache的核心Jar包ehcache-core-2.4.3.jar，将其中的一个配置文件ehcache-failsafe.xml直接放到项目的src目录下，并更名为ehcache.xml，注意其中的配置可以修改：

 1 <defaultCache
 2         maxElementsInMemory="10000"
 3         eternal="false"
 4         timeToIdleSeconds="120"
 5         timeToLiveSeconds="120"
 6         maxElementsOnDisk="10000000"
 7         diskExpiryThreadIntervalSeconds="120"
 8         memoryStoreEvictionPolicy="LRU">
 9     <persistence strategy="localTempSwap"/>
10 </defaultCache>

　　　　　　　　（4）指定缓存内容：

　　　　　　　　　　指定缓存内容，即指定哪个类或哪个集合要进行二级缓存。指定的位置有两处：映射文件、主配置文件。这两种任选其一即可。它们的效果是相同的，但各有利弊： 
　　　　　　　　　　　　在映射文件中指定缓存内容，查看其类的映射文件时，一眼就可看到类为缓存类，集合为缓存集合。但，弊端是，缓存的指定位置分散，缺乏项目的整体性。 
　　　　　　　　　　　　在主配置文件中指定缓存内容，可一眼看到整个项目中所有缓存类与缓存集合。但，弊端是，缓存内容的指定与类映射分离。

　　　　　　　　　　映射文件中指定缓存内容：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5
 6 <hibernate-mapping package="com.tongji.beans">
 7     <class name="Country">
 8         <!-- 指定当前类为类缓存对象 -->
 9         <!-- <cache usage="read-only"/> -->
10         <id name="cid">
11             <generator class="native"/>
12         </id>
13         <property name="cname"/>
14         <set name="ministers" cascade="save-update">
15             <!-- 指定当前集合为集合缓存对象 -->
16             <!-- <cache usage="read-only"/> -->
17             <key column="countryId"/>
18             <one-to-many class="Minister"/>
19         </set>
20     </class>
21 </hibernate-mapping>

　　　　　　　　　　在主配置文件中指定缓存内容：在<mapping/>标签的后面指定类缓存与集合缓存

1 <!-- 指定类缓存 -->
2 <class-cache usage="read-only" class="com.tongji.beans.Minister" />
3 <class-cache usage="read-only" class="com.tongji.beans.Country" />
4 <!-- 指定集合缓存 -->
5 <collection-cache usage="read-only"
6     collection="com.tongji.beans.Country.ministers" />

　　　　　　　补充：

　　　　　　　　　　（1）类缓存，缓存的是类的详情；集合缓存，在没有对集合中元素对应的类进行类缓存的时候，缓存的是所有元素的id。

　　　　　　　　　　（2）Query查询缓存，即session.createQuery(hql)时进行缓存。说明以下三点：

　　　　　　　　　　　　（1）Query查询的结果也会存放到一、二级缓存中

　　　　　　　　　　　　（2）Query查询默认不会从一、二级缓存中读取数据,但可以改变：

　　　　　　　　　　　　　　先在主配置文件中，开启Query查询总开关：<property name="hibernate.cache.use_query_cache">true</property>

　　　　　　　　　　　　　　查询时的代码：

 1 @Test
 2 public void test02() {
 3     //1. 获取Session
 4     Session session = HbnUtils.getSession();
 5     try {
 6         //2. 开启事务
 7         session.beginTransaction();
 8         //3. 操作
 9         //第一次查询
10         String hql = "from Country where cid=1";
11         Country country1 = (Country) session.createQuery(hql).setCacheable(true).uniqueResult();
12         System.out.println("第一次查询：Country = " + country1);
13         //第二次查询
14         Country country2 = (Country) session.createQuery(hql).setCacheable(true).uniqueResult();
15         System.out.println("第二次查询：Country = " + country2);
16
17         //将一级缓存数据清空
18         session.clear();
19
20         //第三次查询，从二级缓存中读取
21         Country country3 = (Country) session.createQuery(hql).setCacheable(true).uniqueResult();
22         System.out.println("第三次查询：Country = " + country3);
23         //4. 事务提交
24         session.getTransaction().commit();
25     } catch (Exception e) {
26         e.printStackTrace();
27         //5. 事务回滚
28         session.getTransaction().rollback();
29     }
30 }

　　　　　　　　　　（3）Query查询要从缓存中读取数据，必须保证Query所执行的HQL语句完全相同。因为Query查询，不仅将数据存放到了缓存中，还将HQL语句存放到了缓存中。

　　　　　　　　　　（4）修改时间戳：在二级缓存存放的对象中，比一级缓存中多出一个属性，updateTimeStamp，修改时间戳。只要这个属性发生改变，就说明有操作修改了DB中的数据，二级缓存中的该缓存对象已经不是最新数据，需要从DB中再次查询更新。

　　　　　　　　　　　　而Query接口的executeUpdate()方法所进行的更新，可以绕过一级缓存，但会修改二级缓存中缓存对象的updateTimeStamp值，由于该值的改变，二级缓存就会通过新的查询来更新缓存中的数据（一、二级缓存都更新了）。