Hibernate ——二级缓存

一、Hibernate 二级缓存

1.Hibernate 二级缓存是 SessionFactory 级别的缓存。

2.二级缓存分为两类：

（1）Hibernate内置二级缓存

（2）外置缓存，可配置的，可插拨的，外置缓存中的数据是数据库数据的复制。

3.二级缓存的并发访问策略

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

（2）二级缓存可以设定以下 4 中并发访问策略，每一种对应一种事务隔离级别。

• 非严格读写（Nonstrict-read-write）：不保证缓存与数据库中数据的一致性。对应 Read UnCommited 事务隔离级别。
• 读写型（Read-write）：提供 Read Commited 级别的事务隔离级别。
• 事务型（Transactional）：对应 Repeatable Read 级别的事务隔离级别。
• 只读型（Read-Only）：提供 Serializable 级别的数据隔离级别。

4.Hibernate 二级缓存是进程或集群范围内的缓存。是可配置的的插件。这里以 Ehcache 为例。不支持事务型的并发访问策略。

5.配置 Ehcache

（1）添加 Jar 包

（2）在 Hibernate 配置文件中启用二级缓存并指定适配的缓存适配器。

在 <session-factory> 元素内添加：

<property name="cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

（3）在 Hibernate 配置文件中配置需要使用二级缓存的持久化类，并设置它的二级缓存的并发访问策略。如：

<class-cache class="com.solverpeng.hql.Department" usage="read-write"/>

需要注意的是：<session-factory> 元素内子元素的顺序：property*, mapping*, (class-cache|collection-cache)*, event*, listener*，class-cache 元素必须位于 mapping 节点后。

（4）或者也可以在 hbm 文件中配置，如：

<hibernate-mapping>

    <class name="com.solverpeng.hql.Employee" table="employee" schema="hibernate">
        <cache usage="read-write"/>
        <id name="empId" column="emp_id"/>
        <property name="empName" column="emp_name"/>
        <property name="salary" column="salary"/>
        <many-to-one name="dept" class="com.solverpeng.hql.Department">
            <column name="dept_id_fk" not-null="true"/>
        </many-to-one>
    </class>
</hibernate-mapping>

6. 测试 Hibernate 二级缓存

（1）查询单个对象缓存

@Test
public void testSecondCache() {
    Employee o = (Employee) session.get(Employee.class, 6);
    System.out.println(o);

    transaction.commit();
    session.close();
    session = factory.openSession();
    transaction = session.beginTransaction();

    Employee o1 = (Employee) session.get(Employee.class, 6);
    System.out.println(o1);
}

查询同一个对象两次，中间关闭 Session 再开启。

没有配置二级缓存：

Hibernate:
    select
        employee0_.emp_id as emp1_1_0_,
        employee0_.emp_name as emp2_1_0_,
        employee0_.salary as salary3_1_0_,
        employee0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee employee0_
    where
        employee0_.emp_id=?
com.solverpeng.hql.Employee@40dd58f3
Hibernate:
    select
        employee0_.emp_id as emp1_1_0_,
        employee0_.emp_name as emp2_1_0_,
        employee0_.salary as salary3_1_0_,
        employee0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee employee0_
    where
        employee0_.emp_id=?
com.solverpeng.hql.Employee@40dd58f3

结果：

发送了2条 SQL 语句。

配置二级缓存后（可以在Hibernate 配置文件中配置，也可以在 Employee hbm 配置文件中配置）：

Hibernate:
    select
        employee0_.emp_id as emp1_1_0_,
        employee0_.emp_name as emp2_1_0_,
        employee0_.salary as salary3_1_0_,
        employee0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee employee0_
    where
        employee0_.emp_id=?
com.solverpeng.hql.Employee@40dd58f3
com.solverpeng.hql.Employee@40dd58f3

结果：

只发送了1条 SQL 语句。

（2）集合缓存

@Test
public void testCollectionSecondLevelCache() {
    Department department = (Department) session.get(Department.class, 6);
    System.out.println(department.getDeptName());
    System.out.println(department.getEmps().size());

    transaction.commit();
    session.close();
    session = factory.openSession();
    transaction = session.beginTransaction();

    Department department2 = (Department) session.get(Department.class, 6);
    System.out.println(department2.getDeptName());
    System.out.println(department2.getEmps().size());

}

在没有配置二级缓存的情况下：

Hibernate:
    select
        department0_.dept_id as dept1_0_0_,
        department0_.dept_name as dept2_0_0_
    from
        hibernate.department department0_
    where
        department0_.dept_id=?
dept-aa
Hibernate:
    select
        emps0_.dept_id_fk as dept4_0_1_,
        emps0_.emp_id as emp1_1_1_,
        emps0_.emp_id as emp1_1_0_,
        emps0_.emp_name as emp2_1_0_,
        emps0_.salary as salary3_1_0_,
        emps0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee emps0_
    where
        emps0_.dept_id_fk=?
3
Hibernate:
    select
        department0_.dept_id as dept1_0_0_,
        department0_.dept_name as dept2_0_0_
    from
        hibernate.department department0_
    where
        department0_.dept_id=?
dept-aa
Hibernate:
    select
        emps0_.dept_id_fk as dept4_0_1_,
        emps0_.emp_id as emp1_1_1_,
        emps0_.emp_id as emp1_1_0_,
        emps0_.emp_name as emp2_1_0_,
        emps0_.salary as salary3_1_0_,
        emps0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee emps0_
    where
        emps0_.dept_id_fk=?
3

结果：

查询了两次 Department，两次Employee

只配置 Department 二级缓存：

<class-cache class="com.solverpeng.hql.Department" usage="read-write"/>

Hibernate:
    select
        department0_.dept_id as dept1_0_0_,
        department0_.dept_name as dept2_0_0_
    from
        hibernate.department department0_
    where
        department0_.dept_id=?
dept-aa
Hibernate:
    select
        emps0_.dept_id_fk as dept4_0_1_,
        emps0_.emp_id as emp1_1_1_,
        emps0_.emp_id as emp1_1_0_,
        emps0_.emp_name as emp2_1_0_,
        emps0_.salary as salary3_1_0_,
        emps0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee emps0_
    where
        emps0_.dept_id_fk=?
3
dept-aa
Hibernate:
    select
        emps0_.dept_id_fk as dept4_0_1_,
        emps0_.emp_id as emp1_1_1_,
        emps0_.emp_id as emp1_1_0_,
        emps0_.emp_name as emp2_1_0_,
        emps0_.salary as salary3_1_0_,
        emps0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee emps0_
    where
        emps0_.dept_id_fk=?
3

结果：

只查询了一次 Department，2次Employee。

说明：

开启 Department 二级缓存后，会对 Department 进行缓存，而与其关联的 emps 不会进行缓存。

配置 Department 二级缓存，同时配置关联的 emps 缓存。

<class-cache class="com.solverpeng.hql.Department" usage="read-write"/>
<collection-cache collection="com.solverpeng.hql.Department.emps" usage="read-write"/>

Hibernate:
    select
        department0_.dept_id as dept1_0_0_,
        department0_.dept_name as dept2_0_0_
    from
        hibernate.department department0_
    where
        department0_.dept_id=?
dept-aa
Hibernate:
    select
        emps0_.dept_id_fk as dept4_0_1_,
        emps0_.emp_id as emp1_1_1_,
        emps0_.emp_id as emp1_1_0_,
        emps0_.emp_name as emp2_1_0_,
        emps0_.salary as salary3_1_0_,
        emps0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee emps0_
    where
        emps0_.dept_id_fk=?
3
-----------------------------
dept-aa
Hibernate:
    select
        employee0_.emp_id as emp1_1_0_,
        employee0_.emp_name as emp2_1_0_,
        employee0_.salary as salary3_1_0_,
        employee0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee employee0_
    where
        employee0_.emp_id=?
Hibernate:
    select
        employee0_.emp_id as emp1_1_0_,
        employee0_.emp_name as emp2_1_0_,
        employee0_.salary as salary3_1_0_,
        employee0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee employee0_
    where
        employee0_.emp_id=?
Hibernate:
    select
        employee0_.emp_id as emp1_1_0_,
        employee0_.emp_name as emp2_1_0_,
        employee0_.salary as salary3_1_0_,
        employee0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee employee0_
    where
        employee0_.emp_id=?
3

结果：

发送了更多的查询 Employee 的SQL。

说明：

开启集合的二级缓存后，此时会缓存集合中对象的 id ，而不会对集合中的对象进行缓存。若想缓存，需要关联的集合中的对象也开启二级缓存。如：

<class-cache class="com.solverpeng.hql.Department" usage="read-write"/>
<collection-cache collection="com.solverpeng.hql.Department.emps" usage="read-write"/>
<class-cache class="com.solverpeng.hql.Employee" usage="read-write"/>

Hibernate:
    select
        department0_.dept_id as dept1_0_0_,
        department0_.dept_name as dept2_0_0_
    from
        hibernate.department department0_
    where
        department0_.dept_id=?
dept-aa
Hibernate:
    select
        emps0_.dept_id_fk as dept4_0_1_,
        emps0_.emp_id as emp1_1_1_,
        emps0_.emp_id as emp1_1_0_,
        emps0_.emp_name as emp2_1_0_,
        emps0_.salary as salary3_1_0_,
        emps0_.dept_id_fk as dept4_1_0_
    from
        hibernate.employee emps0_
    where
        emps0_.dept_id_fk=?
3
-----------------------------
dept-aa
3

结果：

除 Department 外，关联的 Employee 也被缓存了。

（3）查询缓存（针对 HQL、QBC）

在二级缓存开启的情况下，HQL、QBC 也不能对查询进行缓存。

@Test
public void testQueryCache() {
    Query query = session.createQuery("from Employee ");

    List<Employee> list = query.list();
    System.out.println(list.size());

    List<Employee> emps2 = query.list();
    System.out.println(emps2.size());
}

Hibernate:
    select
        employee0_.emp_id as emp1_1_,
        employee0_.emp_name as emp2_1_,
        employee0_.salary as salary3_1_,
        employee0_.dept_id_fk as dept4_1_
    from
        hibernate.employee employee0_
12
Hibernate:
    select
        employee0_.emp_id as emp1_1_,
        employee0_.emp_name as emp2_1_,
        employee0_.salary as salary3_1_,
        employee0_.dept_id_fk as dept4_1_
    from
        hibernate.employee employee0_
12

开启查询缓存：

• 在 Hibernate 配置文件中开启查询缓存
• 若想启用查询缓存的查询语句，需要调用 Query 或 Criteria 的 setCacheable() 方法。
• 查询缓存依赖于二级缓存

<property name="hibernate.cache.use_query_cache">true</property>

@Test
public void testQueryCache() {
    Query query = session.createQuery("from Employee ");
    query.setCacheable(true);
    List<Employee> list = query.list();
    System.out.println(list.size());

    List<Employee> emps2 = query.list();
    System.out.println(emps2.size());
}

Hibernate:
    select
        employee0_.emp_id as emp1_1_,
        employee0_.emp_name as emp2_1_,
        employee0_.salary as salary3_1_,
        employee0_.dept_id_fk as dept4_1_
    from
        hibernate.employee employee0_
12
12

（4）时间戳缓存区域：时间戳缓存区存放了对于查询结果相关的表进行插入、更新或删除操作的时间戳。Hibernate通过时间戳缓存区来判定被缓存的查询结果是否过期。

@Test
public void testTimStampCache() {
    Query query = session.createQuery("from Employee ");
    query.setCacheable(true);
    List<Employee> list = query.list();
    System.out.println(list.size());

    Employee employee = (Employee) session.get(Employee.class, 6);
    employee.setEmpName("emp@@");

    List<Employee> emps2 = query.list();
    System.out.println(emps2.size());
}

Hibernate:
    select
        employee0_.emp_id as emp1_1_,
        employee0_.emp_name as emp2_1_,
        employee0_.salary as salary3_1_,
        employee0_.dept_id_fk as dept4_1_
    from
        hibernate.employee employee0_
12
Hibernate:
    update
        hibernate.employee
    set
        emp_name=?,
        salary=?,
        dept_id_fk=?
    where
        emp_id=?
Hibernate:
    select
        employee0_.emp_id as emp1_1_,
        employee0_.emp_name as emp2_1_,
        employee0_.salary as salary3_1_,
        employee0_.dept_id_fk as dept4_1_
    from
        hibernate.employee employee0_
12

二、ehcache.xml

<ehcache>
    <diskStore path="java.io.tmpdir"/>

    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

    <cache name="sampleCache1"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        />

</ehcache>

1.<diskStore>: 指定一个目录：当 EHCache 把数据写到硬盘上时, 将把数据写到这个目录下.

2.<defaultCache>: 设置缓存的默认数据过期策略

3.<cache> 设定具体的命名缓存的数据过期策略。每个命名缓存代表一个缓存区域

4.缓存区域(region)：一个具有名称的缓存块，可以给每一个缓存块设置不同的缓存策略。如果没有设置任何的缓存区域，则所有被缓存的对象，都将使用默认的缓存策略。即：<defaultCache.../>

5.Hibernate在不同的缓存区域保存不同的类/集合。

• 对于类而言，区域的名称是类名。如:com.atguigu.domain.Customer
• 对于集合而言，区域的名称是类名加属性名。如com.atguigu.domain.Customer.orders

6.cache 元素的属性

（1）name:设置缓存的名字,它的取值为类的全限定名或类的集合的名字

（2）maxInMemory:设置基于内存的缓存中可存放的对象最大数目

（3）eternal:设置对象是否为永久的,true表示永不过期,此时将忽略timeToIdleSeconds 和 timeToLiveSeconds属性; 默认值是false。

（4）timeToIdleSeconds:设置对象空闲最长时间,以秒为单位, 超过这个时间,对象过期。当对象过期时,EHCache会把它从缓存中清除。如果此值为0,表示对象可以无限期地处于空闲状态。

（5）timeToLiveSeconds:设置对象生存最长时间,超过这个时间,对象过期。如果此值为0,表示对象可以无限期地存在于缓存中. 该属性值必须大于或等于 timeToIdleSeconds 属性值。

（6）overflowToDisk:设置基于内存的缓存中的对象数目达到上限后,是否把溢出的对象写到基于硬盘的缓存中。

三、管理 Session

–Session 对象的生命周期与本地线程绑定

–Session 对象的生命周期与 JTA 事务绑定

–Hibernate 委托程序管理 Session 对象的生命周期

四、批量处理数据

建议通过 JDBC 的方式来进行批量操作。

@Test
public void testBathch() {
    session.doWork(new Work() {
        @Override
        public void execute(Connection connection) throws SQLException {
            // 执行批量操作
        }
    });
}

五、总结

配置 Hibernate 二级缓存的步骤：

1.配置 Hibernate 配置文件

（1）配置启用二级缓存

<property name="cache.use_second_level_cache">true</property>

（2）配置二级缓存使用的产品

<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

（3）配置对哪些类使用 hibernate 的二级缓存以及并发策略

<class-cache class="com.solverpeng.hql.Department" usage="read-write"/>
<collection-cache collection="com.solverpeng.hql.Department.emps" usage="read-write"/>
<class-cache class="com.solverpeng.hql.Employee" usage="read-write"/>

（4）在 hbm 文件中配置缓存

<set name="emps" inverse="true">
    <cache usage="read-write"/>
    <key>
        <column name="dept_id_fk" not-null="true"/>
    </key>
    <one-to-many not-found="ignore" class="com.solverpeng.hql.Employee"/>
</set>

2. 对于集合缓存来说，还需要配置集合中的元素对应的持久化类也使用二级缓存! 否则将会多出 n 条 SQL 语句.

3. 查询缓存

（1）在 Hibernate 配置文件中开启查询缓存支持：<property name="cache.use_query_cache">true</property>

（2）调用 Query 或 Criteria 的 setCacheable(true)方法

（3）查询缓存依赖于二级缓存