基于Hibernate4.3的JPA缓存

Cache

        缓存(Cache )是计算机领域非常通用的概念。它介于应用程序和永久性数据存储源(如硬盘上的文件或者内存)之间，其作用是降低应用程序直接读写永久性数据存储源的频率，从而提高应用的运行性能。缓存中的数据是数据存储源中数据的拷贝，应用程序在运行时直接读写缓存中的数据，只在某些特定时刻按照缓存中的数据来同步更新数据存储源（JPA中persist方法、merge方法是声明实体的状态，并没有将实体持久化到数据库中，通过自动或手动调用flush才会将数据同步到数据库）。
       缓存的物理介质通常是内存，而永久性数据存储源的物理介质通常是硬盘或磁盘，应用程序读写内存的速度显然比读写硬盘的速度快，如果缓存中存放的数据量非常大，也会用硬盘作为缓存的物理介质。

       需要被缓存的数据：经常被访问、很少被修改并且需要共享访问的数据。

 

一级缓存

       基于Hibernate的JPA一级缓存是由EntityManager提供的，因此它只存在于EntityManager的生命周期中，当程序调用persist、find、getResultList 等方法时，如EntityManager缓存中还不存在相应的对象，JPA会把该对象加入到一级缓存中，当EntityManager关闭的时候该EntityManager所管理的一级缓存也会立即被清除，一级缓存是EntityManager所内置的，不能被卸载，也不能进行任何配置。

 

二级缓存

       基于Hibernate的JPA二级缓存是EntityManagerFactory提供的，能够缓存不同EntityManager中的实体对象。EntityManager查询策略为：首先查询一级缓存（当前EntityManager）中的托管数据，如果找不到查询EntityManagerFactory中缓存的数据，如果仍找不到则进行数据库查询。

 

缓存方式

       read-only：只读模式，在此模式下，如果对数据进行更新操作，会有异常。

       read_write：读写模式在更新缓存的时候会把缓存里面的数据换成一个锁，其它事务如果去取相应的缓存数据，发现被锁了，直接就去数据库查询；如果应用程序需要更新数据，那么使用读/写缓存比较合适。如果应用程序要求“序列化事务”的隔离级别（serializable transaction isolation level），那么就决不能使用这种缓存策略。
       nonstrict read/write：如果应用程序只偶尔需要更新数据（也就是说，两个事务同时更新同一记录的情况很不常见），也不需要十分严格的事务隔离。不保证缓存与数据库中数据的一致性，如果存在两个事务同时访问缓存中相同数据的可能，必须为该数据配置一个很短的数据过期时间，从而尽量避免脏读。对于极少被修改，并且允许偶尔脏读的数据，可以采用这种并发访问策略。

      transactional：仅仅在事务环境中使用，它提供了Repeatable Read事务隔离级别。对于经常被读但很少修改的数据，可以采用这种隔离类型，因为它可以防止脏读和不可重复读这类的并发问题。

 

缓存配置

配置基于Hibernate的缓存信息

<!-- 产生缓存统计信息 -->
				<entry key="hibernate.generate_statistics" value="true"/>
				<!-- 使用二级缓存 -->
				<entry key="hibernate.cache.use_second_level_cache" value="true" />
            	<entry key="hibernate.cache.use_structured_entries" value ="true" />
            	<!-- 使用查询缓存 -->  
            	<entry key="hibernate.cache.use_query_cache" value="true" /> 
            	<!-- Hibernate4第三方cache --> 
				<entry key="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
				<entry key="net.sf.ehcache.configurationResourceName" value="/ehcache-hibernate-local.xml"/>

hibernate.cache.use_second_level_cache：是否使用二级缓存。二级缓存只能够缓存实体对象，即只能够缓存使用find方法获取的实体对象。

hibernate.cache.use_query_cache：是否启用查询缓存。是针对普通属性结果集的缓存。（没有到验证use_query_cache=true或false时对缓存查询是否有影像。）

hibernate.cache.region.factory_class：第三方的缓存类。

net.sf.ehcache.configurationResourceName：encache查询缓存配置文件。

ehcache-hibernate-local.xml文件内容

<?xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false" name="hibernateCache">
	<diskStore path="java.io.tmpdir/ehcache/jpa" />
	<!-- 使用encache2.6,否则提示不存在属性maxEntriesLocalHeap -->
	<defaultCache maxEntriesLocalHeap="10000" eternal="false" timeToIdleSeconds="300" timeToLiveSeconds="600"
		overflowToDisk="true" maxEntriesLocalDisk="100000" />
	<!-- 也可以单独为某个实体指定配置信息 -->
<!-- 	<cache name="com.projects.jpa.entity.Customer" maxEntriesLocalHeap="1000" eternal="true" -->
<!-- 		overflowToDisk="true" maxEntriesLocalDisk="10000"/> -->
</ehcache>

为需要缓存的实体类配置Hibernate的Cache属性，如果不配置Cache注解，是不对实体进行二级缓存的。

@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)
public class Customer extends BaseEntity {
         ......
}

问题：即使以上都配置了，使用getResultList也不能使用缓存，需要为Query对象明确指定使用缓存如下：

		Query query = entityManager.createQuery("from Customer c") ;
		query.setHint("org.hibernate.cacheable", true);
		List<Customer> list = query.getResultList() ;

      

 

参考文章：http://www.iteye.com/topic/1133637

 

目前在使用spring-data-jpa和hibernate4的时候，对于缓存关系不是很清楚，以及二级缓存和查询缓存的各种配置等等，于是就有了这篇初级的jpa+hibernate缓存配置使用的文章。


JPA和hibernate的缓存关系，以及系统demo环境说明

JPA全称是：Java Persistence API

引用

JPA itself is just a specification, not a product; it cannot perform persistence or anything else by itself.

JPA仅仅只是一个规范，而不是产品；使用JPA本身是不能做到持久化的。

所以，JPA只是一系列定义好的持久化操作的接口，在系统中使用时，需要真正的实现者，在这里，我们使用Hibernate作为实现者。所以，还是用spring-data-jpa+hibernate4+spring3.2来做demo例子说明本文。


JPA规范中定义了很多的缓存类型：一级缓存，二级缓存，对象缓存，数据缓存，等等一系列概念，搞的人糊里糊涂，具体见这里：
http://en.wikibooks.org/wiki/Java_Persistence/Caching

不过缓存也必须要有实现，因为使用的是hibernate，所以基本只讨论hibernate提供的缓存实现。

很多其他的JPA实现者，比如toplink（EclipseLink），也许还有其他的各种缓存实现，在此就不说了。



先直接给出所有的demo例子

hibernate实现中只有三种缓存类型：

一级缓存，二级缓存和查询缓存。

在hibernate的实现概念里，他把什么集合缓存之类的统一放到二级缓存里去了。


1. 一级缓存测试：

文件配置：

<bean id="entityManagerFactory"
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />
    <property name="packagesToScan" value="com.restjplat.quickweb" />
    <property name="jpaProperties">
        <props>
            <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
            <prop key="hibernate.format_sql">true</prop>
        </props>
    </property>
</bean>

可见没有添加任何配置项。

private void firstCacheTest(){
    EntityManager em = emf.createEntityManager();
    Dict d1 = em.find(Dict.class, 1); //find id为1的对象
    Dict d2 = em.find(Dict.class, 1); //find id为1的对象
    logger.info((d1==d2)+""); //true

    EntityManager em1 = emf.createEntityManager();
    Dict d3 = em1.find(Dict.class, 1); //find id为1的对象
    EntityManager em2 = emf.createEntityManager();
    Dict d4 = em2.find(Dict.class, 1); //find id为1的对象
    logger.info((d3==d4)+""); //false
}

输出为：因为sql语句打出来太长，所以用*号代替
Hibernate: ***********
2014-03-17 20:41:44,819  INFO [main] (DictTest.java:76) - true
Hibernate: ***********
Hibernate: ***********
2014-03-17 20:41:44,869  INFO [main] (DictTest.java:84) - false

由此可见：同一个session内部，一级缓存生效，同一个id的对象只有一个。不同session，一级缓存无效。

2. 二级缓存测试：

文件配置：

1:实体类直接打上 javax.persistence.Cacheable 标记。

@Entity
@Table(name ="dict")
@Cacheable
public class Dict extends IdEntity{}

2：配置文件修改，在 jpaProperties 下添加，用ehcache来实现二级缓存，另外因为加入了二级缓存，我们将hibernate的统计打开来看看到底是不是被缓存了。

<prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
<prop key="javax.persistence.sharedCache.mode">ENABLE_SELECTIVE</prop>
<prop key="hibernate.generate_statistics">true</prop>

注1：如果在配置文件中加入了
<prop key="javax.persistence.sharedCache.mode">ENABLE_SELECTIVE</prop& gt;，则不需要在实体内配置hibernate的 @cache标记，只要打上JPA的@cacheable标记即可默认开启该实体的2级缓存。

注2：如果不使用javax.persistence.sharedCache.mode配置，直接在实体内打@cache标记也可以。

@Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
public class Dict extends IdEntity{}

至于 hibernate的 hibernate.cache.use_second_level_cache这个属性，文档里是这么写的：

引用

Can be used to completely disable the second level cache, which is enabled by default for classes which specify a <cache> mapping.

即打上只要有@cache标记，自动开启。

所以有两种方法配置开启二级缓存：

第一种不使用hibernate的@cache标记，直接用@cacheable标记和缓存映射配置项。

第二种用hibernate的@cache标记使用。


另外javax.persistence.sharedCache.mode的其他配置如下：

The javax.persistence.sharedCache.mode property can be set to one of the following values:

• ENABLE_SELECTIVE (Default and recommended value): entities are not cached unless explicitly marked as cacheable.
• DISABLE_SELECTIVE: entities are cached unless explicitly marked as not cacheable.
• NONE: no entity are cached even if marked as cacheable. This option can make sense to disable second-level cache altogether.
• ALL: all entities are always cached even if marked as non cacheable.

如果用all的话，连实体上的@cacheable都不用打，直接默认全部开启二级缓存

测试代码：

private void secondCachetest(){
        EntityManager em1 = emf.createEntityManager();
        Dict d1 = em1.find(Dict.class, 1); //find id为1的对象
        logger.info(d1.getName());
        em1.close();

        EntityManager em2 = emf.createEntityManager();
        Dict d2 = em2.find(Dict.class, 1); //find id为1的对象
        logger.info(d2.getName());
        em2.close();
    }

输出：

Hibernate: **************
a
a
===================L2======================
com.restjplat.quickweb.model.Dict : 1

可见二级缓存生效了，只输出了一条sql语句，同时监控中也出现了数据。

另外也可以看看如果是配置成ALL，并且把@cacheable删掉,输出如下：

Hibernate: ************
a
a
===================L2======================
com.restjplat.quickweb.model.Children : 0
com.restjplat.quickweb.model.Dict : 1
org.hibernate.cache.spi.UpdateTimestampsCache : 0
org.hibernate.cache.internal.StandardQueryCache : 0
com.restjplat.quickweb.model.Parent : 0
=================query cache=================

并且可以看见，所有的实体类都加入二级缓存中去了


3. 查询缓存测试：

一，二级缓存都是根据对象id来查找，如果需要加载一个List的时候，就需要用到查询缓存。

在Spring-data-jpa实现中，也可以使用查询缓存。

文件配置：
在 jpaProperties 下添加，这里必须明确标出增加查询缓存。

<prop key="hibernate.cache.use_query_cache">true</prop>

然后需要在方法内打上@QueryHint来实现查询缓存，我们写几个方法来测试如下：

public interface DictDao extends JpaRepository<Dict, Integer>,JpaSpecificationExecutor<Dict>{

    // spring-data-jpa默认继承实现的一些方法，实现类为
    // SimpleJpaRepository。
    // 该类中的方法不能通过@QueryHint来实现查询缓存。
    @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })
    List<Dict> findAll();

    @Query("from Dict")
    @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })
    List<Dict> findAllCached();

    @Query("select t from Dict t where t.name = ?1")
    @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })
    Dict findDictByName(String name);
}

测试方法

private void QueryCacheTest(){
        //无效的spring-data-jpa实现的接口方法
        //输出两条sql语句
        dao.findAll();
        dao.findAll();
        System.out.println("================test 1 finish======================");
        //自己实现的dao方法可以被查询缓存
        //输出一条sql语句
        dao.findAllCached();
        dao.findAllCached();
        System.out.println("================test 2 finish======================");
        //自己实现的dao方法可以被查询缓存
        //输出一条sql语句
        dao.findDictByName("a");
        dao.findDictByName("a");
        System.out.println("================test 3 finish======================");
    }

输出结果：

Hibernate: **************
Hibernate: **************
================test 1 finish======================
Hibernate: ***********
================test 2 finish======================
Hibernate: ***********
================test 3 finish======================
===================L2======================
com.restjplat.quickweb.model.Dict : 5
org.hibernate.cache.spi.UpdateTimestampsCache : 0
org.hibernate.cache.internal.StandardQueryCache : 2
=================query cache=================
select t from Dict t where t.name = ?1
select generatedAlias0 from Dict as generatedAlias0
from Dict

很明显，查询缓存生效。但是为什么第一种方法查询缓存无法生效，原因不明，只能后面看看源代码了。

4.集合缓存测试：

根据hibernate文档的写法，这个应该是算在2级缓存里面。

测试类：

@Entity
@Table(name ="parent")
@Cacheable
public class Parent extends IdEntity {

    private static final long serialVersionUID = 1L;
    private String name;
    private List<Children> clist;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @OneToMany(fetch = FetchType.EAGER,mappedBy = "parent")
        @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
    public List<Children> getClist() {
        return clist;
    }
    public void setClist(List<Children> clist) {
        this.clist = clist;
    }
}

@Entity
@Table(name ="children")
@Cacheable
public class Children extends IdEntity{

    private static final long serialVersionUID = 1L;
    private String name;
    private Parent parent;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "parent_id")
    public Parent getParent() {
        return parent;
    }

    public void setParent(Parent parent) {
        this.parent = parent;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

测试方法：

private void cellectionCacheTest(){
        EntityManager em1 = emf.createEntityManager();
        Parent p1 = em1.find(Parent.class, 1);
        List<Children> c1 = p1.getClist();
        em1.close();
        System.out.println(p1.getName()+" ");
        for (Children children : c1) {
            System.out.print(children.getName()+",");
        }
        System.out.println();
        EntityManager em2 = emf.createEntityManager();
        Parent p2 = em2.find(Parent.class, 1);
        List<Children> c2 = p2.getClist();
        em2.close();
        System.out.println(p2.getName()+" ");
        for (Children children : c2) {
            System.out.print(children.getName()+",");
        }
        System.out.println();
    }

输出：

Hibernate: ********************
Michael
kate,Jam,Jason,Brain,
Michael
kate,Jam,Jason,Brain,
===================L2======================
com.restjplat.quickweb.model.Children : 4
com.restjplat.quickweb.model.Dict : 0
org.hibernate.cache.spi.UpdateTimestampsCache : 0
com.restjplat.quickweb.model.Parent.clist : 1
org.hibernate.cache.internal.StandardQueryCache : 0
com.restjplat.quickweb.model.Parent : 1
=================query cache=================

在统计数据里可见二级缓存的对象数量。

本文我们不讨论关于缓存的更新策略，脏数据等等的东西，只是讲解配置方式。


接下来是源代码篇

理清楚各种配置以后，我们来看一下hibernate和spring-data-jpa的一些缓存实现源代码。

上面有个遗留问题，为什么spring-data-jpa默认实现的findAll（）方法无法保存到查询缓存？只能啃源代码了。

打断点跟踪吧

入口方法是spring-data-jpa里的 SimpleJpaRepository类

public List<T> findAll() {
        return getQuery(null, (Sort) null).getResultList();
    }

然后到 QueryImpl<X>类的
private List<X> list() {
        if (getEntityGraphQueryHint() != null) {
            SessionImplementor sessionImpl = (SessionImplementor) getEntityManager().getSession();
            HQLQueryPlan entityGraphQueryPlan = new HQLQueryPlan( getHibernateQuery().getQueryString(), false,
                    sessionImpl.getEnabledFilters(), sessionImpl.getFactory(), getEntityGraphQueryHint() );
            // Safe to assume QueryImpl at this point.
            unwrap( org.hibernate.internal.QueryImpl.class ).setQueryPlan( entityGraphQueryPlan );
        }
        return query.list();
    }

进入query.list();

query类的代码解析google一下很多，于是直接到最后：

进入QueryLoader的list方法。

protected List list(
            final SessionImplementor session,
            final QueryParameters queryParameters,
            final Set<Serializable> querySpaces,
            final Type[] resultTypes) throws HibernateException {

        final boolean cacheable = factory.getSettings().isQueryCacheEnabled() &&
            queryParameters.isCacheable();

        if ( cacheable ) {
            return listUsingQueryCache( session, queryParameters, querySpaces, resultTypes );
        }
        else {
            return listIgnoreQueryCache( session, queryParameters );
        }
    }

果然有个cacheable，值为false，说明的确是没有从缓存里取数据。

用自定义的jpa查询方法测试后发现，这个值为true。

于是接着看cacheable的取值过程：

final boolean cacheable = factory.getSettings().isQueryCacheEnabled() &&
            queryParameters.isCacheable();

factory.getSettings().isQueryCacheEnabled() 这个一定是true，因为是在配置文件中打开的。那只能是queryParameters.isCacheable() 这个的问题了。

在query.list()的方法内部：

public List list() throws HibernateException {
        verifyParameters();
        Map namedParams = getNamedParams();
        before();
        try {
            return getSession().list(
                    expandParameterLists(namedParams),
                    getQueryParameters(namedParams)
                );
        }
        finally {
            after();
        }
    }

getQueryParameters(namedParams)这个方法实际获取的是query对象的cacheable属性的值，也就是说，query对象新建的时候cacheable的值决定了这个query方法能不能被查询缓存。

接下来query的建立过程：

在 SimpleJpaRepository 类中 return applyLockMode(em.createQuery(query));

直接由emcreate，再跟踪到 AbstractEntityManagerImpl中

@Override
    public <T> QueryImpl<T> createQuery(
            String jpaqlString,
            Class<T> resultClass,
            Selection selection,
            QueryOptions queryOptions) {
        try {
            org.hibernate.Query hqlQuery = internalGetSession().createQuery( jpaqlString );

            ....
            return new QueryImpl<T>( hqlQuery, this, queryOptions.getNamedParameterExplicitTypes() );
        }
        catch ( RuntimeException e ) {
            throw convert( e );
        }
    }
即通过session.createQuery(jpaqlString ) 创建初始化对象。

在query类定义中
public abstract class AbstractQueryImpl implements Query {

        private boolean cacheable;
}
cacheable不是对象类型，而是基本类型，所以不赋值的情况下默认为“false”。

也就是说spring-data-jpa接口提供的简单快速的各种接口实现全是不能使用查询缓存的，完全不知道为什么这么设计。

接下来看看我们自己实现的查询方法实现：

直接找到query方法的setCacheable（）方法打断点，因为肯定改变这个值才能有查询缓存。

于是跟踪到 SimpleJpaQuery类中
protected Query createQuery(Object[] values) {
        return applyLockMode(applyHints(doCreateQuery(values), method), method);
}

在返回query的过程中通过applyHints（）方法读取了方法上的QueryHint注解从而设置了查询缓存。