Hibernate（十六）：Hibernate二级缓存

• Hibernate缓存

缓存（Cache）:计算机领域非常通用的概念。它介于应用程序和永久性数据存储源（如磁盘上的文件或者数据库）之间，起作用是降低应用程序直接读取永久性数据存储源的频率，从而提高应用的运行性能。缓存中的数据是数据存储源中数据的拷贝。缓存的物理介质通常是内存。

Hibernate中提供了两个级别的缓存

1）第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存由hibernate管理。

测试函数1：Hibernate一级缓存示例

     @Test
     public void testHibernateCacheLevel1() {
         Department depart0 = (Department) session.get(Department.class, 1);
         System.out.println(depart0);

         Department depart1 = (Department) session.get(Department.class, 1);
         System.out.println(depart1);
     }

执行sql及结果：

 Hibernate:
     select
         department0_.ID as ID1_0_0_,
         department0_.NAME as NAME2_0_0_
     from
         DX_DEPARTMENT department0_
     where
         department0_.ID=?
 Department [id=1, name=开发部门]

 Department [id=1, name=开发部门]

测试函数2：Hibernate一级缓存是事务级别证明

     @Test
     public void testHibernateCacheLevel1_Transaction() {
         Department depart0 = (Department) session.get(Department.class, 1);
         System.out.println(depart0);

         transaction.commit();
         session.close();
         session = sessionFactory.getCurrentSession();
         transaction = session.beginTransaction();

         Department depart1 = (Department) session.get(Department.class, 1);
         System.out.println(depart1);
     }

执行sql及结果：

 Hibernate:
     select
         department0_.ID as ID1_0_0_,
         department0_.NAME as NAME2_0_0_
     from
         DX_DEPARTMENT department0_
     where
         department0_.ID=?
 Department [id=1, name=开发部门]

 Hibernate:
     select
         department0_.ID as ID1_0_0_,
         department0_.NAME as NAME2_0_0_
     from
         DX_DEPARTMENT department0_
     where
         department0_.ID=?
 Department [id=1, name=开发部门]

备注：

本章节所涉及到的demo工程是基于《Hibernate（十二）：HQL查询（一）》所创建的工程基础上进行测试。

2）第二级别的缓存是SesssionFactory级别的缓存，它是属于进程范围的缓存。

• SessionFactory级别的缓存

SesssionFactory的缓存可以分为两类

1）内置缓存：Hibernate自带的，不可卸载。通常在Hibernate的初始化阶段，Hibernate会把映射元数据和预定义的SQL语句放到SessionFactory的缓存中，映射元数据是映射文件中数据（.hbm.xml文件中的数据）的赋值，该内置缓存是只读的。

2）外置缓存（二级缓存）：一个可配置的缓存插件。在默认情况下，SessionFactory不会启用这个缓存插件。外置缓存中的数据是数据库数据的复制，外置缓存的物理介质可以是内存或硬盘。

• Hibernate二级缓存的适用范围

1）适合放入二级缓存的数据：

　　很少被修改

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

2）不适合放入二级缓存中的数据

　　经常被修改

　　财务数据，绝对不允许出现并发问题

　　与其他应用程序共享的数据

• Hibernate二级缓存架构图

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

1）两个并发的事务同时访问持久层的缓存的相同数据时，也有可能出现各类并发问题。

2）二级缓存可以设定以下4种类型的并发访问策略，每一种访问策略对应一种事务隔离界别：

　　√ 非严格读写（Nonstrict-read-write）:不保证缓存与数据库中数据一致性。提供Read Uncommited 事务隔离级别，对于极少被修改，而且允许脏读的数据可以采用该策略。

　　√ 读写型（Read-write）：提供Read Commited事务隔离级别。对于经常读但是很少被修改的数据，可以采用该隔离类型，因为它可以防止脏读。

　　√ 事务型（Transactional）:仅在受管理环境下适用，它提供了Repeateable Read事务隔离级别。对于经常读但很少被修改的数据，可以采用这种隔离策略，应为它可以防止脏读和不可重复读。

　　√ 只读型（Read-Only）:提供Serializable数据隔离级别，对于从来不会被修改的数据，可以采用这种访问策略。

• 管理Hibernate的二级缓存

1）Hibernate的二级缓存是进程或集群分为内的缓存

2）二级缓存是可配置的插件，Hibernate允许选用选用以下类型的缓存插件：

　　√ EHCache：可作为进程范围内存的缓存，存放数据的物理介质可以使用内存或磁盘，对Hibernate查询缓存提供了支持。

　　√ OpenSymphony OSCahce：可以作为内存范围内的缓存，存放数据的物理介质可以使用内存或硬盘，提供了丰富的缓存数据过期策略，对Hibernate的查询缓存提供了支持。

　　√ SwarmCache：可以作为集群范围内的缓存，但不支持Hibernate的查询缓存。

　　√ JBoosCache：可作为集群范围内的缓存，支持Hibernate的查询缓存。

4种缓存插件支持的并发访问策略：

• EHCache的使用：

步骤一：添加EHCache需要的jar包

找到hibernate开发路径\hibernate-release-5.2.9.Final\lib\optional\ehcache\下的所有jar，导入到工程。

步骤二：拷贝ehcache.xml文件到src下

拷贝hibernate-release-5.2.9.Final\project\etc\ehcache.xml文件到src下

步骤三：通过配置hibernate.cfg.xml文件启用hibernate二级缓存，并指定二级缓存的实现类

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-configuration PUBLIC
         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
         "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 <hibernate-configuration>
     <session-factory>
             。。。
         <!-- 启用二级缓存 -->
         <property name="hibernate.cache.use_second_level_cache">true</property>
         <!-- 配置二级缓存使用的插件 -->
         <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
             。。。
     </session-factory>
 </hibernate-configuration>

步骤四：在hibernate.cfg.xml或者Department.hbm.xml中配置，针对Department启用二级缓存。

1）通过配置hibernate.cfg.xml启用Department类的二级缓存

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        。。。
        <!-- 启用二级缓存 -->
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <!-- 配置二级缓存使用的插件 -->
        <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

        <mapping resource="com/dx/hibernate09/hql01/Department.hbm.xml" />
        <mapping resource="com/dx/hibernate09/hql01/Employee.hbm.xml" />

        <class-cache usage="read-write" class="com.dx.hibernate09.hql01.Department"/>
    </session-factory>
</hibernate-configuration>

2）通过配置Department.hbm.xml来启用Department类的二级缓存

 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 <!-- Generated 2017-6-9 23:13:49 by Hibernate Tools 3.5.0.Final -->
 <hibernate-mapping>
     <class name="com.dx.hibernate09.hql01.Department" table="DX_DEPARTMENT">
         <cache usage="read-write" />

         <id name="id" type="java.lang.Integer">
             <column name="ID" />
             <generator class="native" />
         </id>
         <property name="name" type="java.lang.String">
             <column name="NAME" />
         </property>

         <set name="employees" table="DX_EMPLOYEE" inverse="true" lazy="true">
             <key>
                 <column name="DEPARTMENT_ID" />
             </key>
             <one-to-many class="com.dx.hibernate09.hql01.Employee" />
         </set>
     </class>
 </hibernate-mapping>

测试代码：

     @Test
     public void testHibernateCacheLevel1_Transaction() {
         Department depart0 = (Department) session.get(Department.class, 1);
         System.out.println(depart0);

         transaction.commit();
         session.close();
         session = sessionFactory.getCurrentSession();
         transaction = session.beginTransaction();

         Department depart1 = (Department) session.get(Department.class, 1);
         System.out.println(depart1);
     }

执行sql及结果：

 Hibernate:
     select
         department0_.ID as ID1_0_0_,
         department0_.NAME as NAME2_0_0_
     from
         DX_DEPARTMENT department0_
     where
         department0_.ID=?
 Department [id=1, name=开发部门]

 Department [id=1, name=开发部门]