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.Finalliboptionalehcache下的所有jar，导入到工程。

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

拷贝hibernate-release-5.2.9.Finalprojectetcehcache.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=开发部门]