Hibernate二级缓存简述及基于Spring4,Hibernate5,Ehcache3的二级缓存配置

• Hibernate L2缓存
  • 缓存的分类
  • L2缓存工作原理
  • 放入二级缓存的数据
• Ehcache
  • 依赖
  • ehcache.xml
  • 常用的memoryStoreEvictionPolicy（缓存算法）
  • ehcache使用
• Spring配置
  • sessionFactory配置
  • hibernateTemplate配置
• Hiberante二级缓存的使用
  • 不使用二级缓存的方法
  • 使用二级缓存的方法
  • iterate()查询原理和N+1问题
• 参考文档

目前的项目是一个极少写冲突，多读，多重复HQL语句的项目，因此非常适合使用Hibernate的二级缓存进行查询优化。目前项目使用的均是最新版本的框架，配置成功后很快就成功使用了，大概讲讲配置方法。

1. Hibernate L2缓存

1.1. 缓存的分类

• 事务缓存：作用于事务范围，session结束则缓存清除，Hibernate的L1缓存为事务缓存，默认开启，我们在纯Hibernate项目中手写过回滚的代码，能够回滚就是因为事务缓存。
• 应用缓存：作用于应用范围，被所有事务共享，依赖于应用的生命周期。所以，非常适合使用一个同样依赖于应用生命周期的轻量级缓存来实现，ehcache几乎是最好的选择。
• 集群缓存：该缓存类似于真正的数据库被一个集群共享，典型的如Redis就很适合做集群缓存。

1.2. L2缓存工作原理

Hibernate的L1，L2缓存均是通过id进行工作，当Hibernate根据id访问对象时会先在一级缓存中查找，如果查不到则在二级缓存中查找。

SessionFactory二级缓存根据功能和目的又可以划分为内置缓存和外置缓存，内置缓存存放映射元数据和预定义SQL语句，前者为映射文件中数据的副本，后者为根据副本推导出的SQL语句。内置缓存是只读的，因此不需要与映射文件进行同步。外置缓存是Hibernate的一个插件，默认不启用，即Hibernate的L2缓存。外置缓存的数据是数据库数据的副本，外置缓存的介质可以是内存或者硬盘。

1.3. 放入二级缓存的数据

一般包含以下几种：

• 很少被修改的数据
• 不是很重要的数据，允许出现偶尔并发的数据。
• 不会被并发访问的数据。
• 常量数据。
• 不会被第三方修改的数据。

2. Ehcache

Ehcache是一个健壮的简洁的轻量的纯Java进程的内存缓存框架，因此其存在与Java进程直接相关联。通过在硬盘和内存里对数据进行拷贝，实现了数据库的缓存。由于Apache的支持，Ehcache非常稳健。

2.1. 依赖

<!--ehcache依赖slf4j-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
<!--slf4j依赖log4j-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
<!--ehcache-->
        <dependency>
            <groupId>org.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>3.3.1</version>
        </dependency>
<!--hibernate.ehcache-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
            <version>${org.hibernate.version}</version>
        </dependency>

2.2. ehcache.xml

该文件需要放置src中（Maven项目的resources中），以便编译后在根目录内，也可以显示指定位置。这个文件给出了ehcache的基本配置。

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <diskStore path="java.io.tmpdir"/>
    <!--没有特殊设置时系统默认使用此设置-->
    <defaultCache
            maxElementsInMemory="1000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="true"
            maxElementsOnDisk="10000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
    />
    <!--想使用查询缓存，这两个类需要添加-->
    <cache name="org.hibernate.cache.spi.UpdateTimestampsCache"
           maxElementsInMemory="5000"
           eternal="true"
           overflowToDisk="true" />
    <cache name="org.hibernate.cache.internal.StandardQueryCache"
           maxElementsInMemory="10000"
           eternal="false"
           timeToLiveSeconds="120"
           overflowToDisk="true" />
    <cache name="javaClassName" maxElementsInMemory="2000" eternal="false"
           timeToIdleSeconds="120" timeToLiveSeconds="120"
           overflowToDisk="true" />
</ehcache>

ehcache的各属性介绍如下：

• name:缓存名称。
• maxElementsInMemory：缓存最大个数。
• eternal:对象是否永久有效，一但设置了，timeout将不起作用。
• timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
• timeToLiveSeconds：设置对象在失效前允许存活时间,最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0，也就是对象存活时 间无穷大。
• overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
• diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
• maxElementsOnDisk：硬盘最大缓存个数。
• diskPersistent：是否缓存虚拟机重启期数据，默认false。
• diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
• memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU。你可以设置为 FIFO或是LFU。
• clearOnFlush：内存数量最大时是否清除。

2.3. 常用的memoryStoreEvictionPolicy（缓存算法）

关于常用的缓存算法主要有三种：

• LRU：（Least Rencently Used）新来的对象替换掉使用时间算最近很少使用的对象。
• LFU：（Least Frequently Used）替换掉按命中率高低算比较低的对象。
• FIFO: （First In First Out）把最早进入二级缓存的对象替换掉。

2.4. ehcache使用

ehcache不支持事务，有三种模式：

• READ_ONLY: 适用于仅读取，如果有数据的更新操作则会异常。
• READ_WRITE: 用读写锁控制缓存
• NON_STRICT_READ_WRITE: 不加锁控制缓存，写写会有冲突，适用于很难发生写冲突的系统。

具体使用时，在hibernate持久化生成的Entity上使用类似这样的标签，即可为该数据库添加二级缓存。

@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)

通常情况下，缓存用于多读少写的表，在这种表中，最高效，最符合缓存本身行为的应该是READ_ONLY模式，即，在读取时使用缓存，发生写操作时清空缓存。

3. Spring配置

3.1. sessionFactory配置

当我们使用Spring的hibernateTemplate时，需要对sessionFactory进行配置，其中有无关于ehcache的部分可以参考Spring4托管Hibernate5并利用HibernateTemplate进行数据库操作，这里主要讲解和ehcache相关的设置。

<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        ……
        <property name="hibernateProperties">
            <props>
                ……
                <prop key="hibernate.cache.use_second_level_cache">true</prop>
                <prop key="hibernate.cache.use_query_cache">true</prop>
                <prop key="hibernate.cache.region.factory_class">
                org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory</prop>
            </props>
        ……

• hibernate.cache.use_second_level_cache 是hibernate中L2缓存的开关，必须为true。
• hibernate.cache.use_query_cache 是hibernate的查询缓存的开关，可以自己决定是否开启。
• hibernate.cache.region.factory_class 承载L2缓存的方法，即选择L2缓存数据库。官方很坑的从hibernate4开始就存在文档问题，文档中仍为provider_class，实际上早已换为了这个方法（idea的默认提示中找不到，但运行后如果没添加，错误日志里可以显示出）。需要注意的是，需要使用Singleton模式的Factory，否则会有冲突问题。具体原因还不明了。

另外有几个可以开启的选项，包括

• hibernate.generate_statistics 生成统计日志，如果项目在调试，这是一个很好的开发选项。记得实际运行时关闭掉。
• hibernate.cache.provider_configuration_file_resource_path 提供配置文件的路径，如果你不想使用默认路径，那么需要在这里配置，其格式和web.xml中的路径一致。

3.2. hibernateTemplate配置

其实就是开启一下查询缓存，一条

    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory" />
        <property name="cacheQueries" value="true"/>
    </bean>

4. Hiberante二级缓存的使用

Hibernate的所有查询方法均用到事务缓存，但对于SessionFactory缓存，只有部分方法会使用。

4.1. 不使用二级缓存的方法

Hibernate的各种查询方式中，以下几种方式不使用缓存，直接从数据库读写：

• get()
• find()
• list()

其中后两者在使用hibernateTemplate时均为find()方法。但当开启了查询缓存后，使用这些方法时，同样也会把查询的结果存入缓存，这会造成一定的时间消耗，但是可以有效的避免使用缓存时的N+1问题。

4.2. 使用二级缓存的方法

Hibernate的以下方法使用二级缓存

• load()
• iterate()

这里面特别说明一下iterate()方法，该方法返回的是一个指向查询结果的指针，当方法返回指针后，如果想通过指针获取整个查询结果，则需要使用事务，并在表上加如下标签：

@Proxy(lazy = false)

关闭hibernate的懒加载。否则，当想要通过返回的iterator获取其下一方法，iterator.next()，则会因为变量已经进入游离态，无法找到下一方法。即使如此，寻找下一指针的方法也需要和返回iterator的方法处于同一事务内才能成功。

一个对lazy=false产生的损耗的补救方案是使用Spring的OpenSessionInViewFilter来管理session,在web.xml中添加

    <filter>
        <filter-name>OpenSessionInViewFilter</filter-name>
        <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>OpenSessionInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

即可。

4.3. iterate()查询原理和N+1问题

使用iterate()方法时，Hibernate会先访问数据库，查询所有要查询对象的id，再访问缓存，通过id查询所有要查询对象，当对象在缓存中时，直接返回结果，当对象不再缓存中时，访问数据库查询该对象。因此，当缓存没有建立时，这样的查询方法会产生N+1次查询，远比find（）方法的1次数据库查询效率低下。所以，简单的使用iterator对数据进行查询是十分不合理的，两种方案可以考虑。

• 在用户访问前，对数据库中常用数据进行缓存，比如，在程序启动后自动执行一次find()行为把常用数据进行存储。
• 用户的第一次访问使用find()方法，并获取缓存，之后的访问使用iterate()方法。

5. 参考文档

CacheConcurrencyStrategy的五种缓存方式的简单介绍

ehcache memcache redis 三大缓存男高音

Hibernate4之二级缓存配置