hibernate二级缓存

整理自：http://www.iteye.com/topic/18904

 

Hibernate一级缓存是session级别的，默认开启的。如果在同一个session中对同一个id进行两次load()（get()不会使用缓存），Hibernate只会对数据库发起一次查询。

 

Hibernate二级缓存是全局缓存，默认为关闭状态。同时，它需要第三方缓存商提供实现。Hibernate3.5缓存策略提供商有EHCache、OSCache、JBoss Cache 1.x等。

Hibernate二级缓存配置：（以EHCache为例）

1、hibernate.cfg.xml

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>

	<session-factory>
		......
		<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
		<property name="hibernate.cache.use_query_cache">true</property>
		......
	</session-factory>

</hibernate-configuration>

2、EHCache配置文件ehcache.xml：（放在src目录下）

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
	<diskStore path="d:/ehcachedir/" /><!--缓存中的数据保存在磁盘上的路径-->
	<defaultCache maxElementsInMemory="1000" eternal="false"
		overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="180"
		diskPersistent="false" diskExpiryThreadIntervalSeconds="120" />
</ehcache>

maxElementsInMemory为缓存中可以存放元素的个数，当overflowToDisk属性的值为true，如果此时向缓存中添加第

1001个元素时，ehcache就会将缓存中的部分数据保存到磁盘上的临时文件中；eternal属性表示缓存是否永不超时，值为true表示永不超时；timeToLiveSeconds属性是缓存中每个元素（POJO）的超时时间，超过这个时间，该元素就会从缓存中被移走；timeToIdleSeconds是发呆时间，是可选的。

3、实体类映射配置文件：（*.hbm.xml）

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.charlie.bean.Zit" table="zit" catalog="bbc">

		<cache usage="read-only" /><!-- 设置缓存模式-->

		<id name="id" type="java.lang.String">
			<column name="id" length="7" />
			<generator class="assigned"></generator>
		</id>

		......
		
	</class>
</hibernate-mapping>

 4、Dao中的代码需要设置使用缓存：

public List findAllByCache() {
		log.debug("finding all Zit instances");

		List list = null;
		Session session = getSession();
		Transaction tx = null;
		String queryString = "from Zit";

		Query query = session.createQuery(queryString);
		query.setCacheable(true);//设置使用缓存
		try {
			tx = session.beginTransaction();
			list = query.list();
			tx.commit();
		} catch (RuntimeException re) {
			log.error("find all failed", re);
			tx.rollback();

		} finally {
			session.close();
		}
		return list;
}

 缓存我们可以简单的看成一个HashMap，通过key在缓存中查找value，对于数据库中的一条记录，也就是Java中的一个对象来讲，是根据id来找的，缓存的key就是id，value是pojo，当你调用load(),list(),iterate()方法，只要读出一个对象，都会写入缓存。iterate()比较特殊，它会先将符合条件的所有数据的id先查询出来，之后使用每个id进行load()，如果缓存中存在该对象就从缓存中取，如果不存在就直接查询数据库。执行iterate()：

2012-02-23 21:23:45,439 DEBUG (AbstractBatcher.java:401) - 
    select
        zit0_.objuid as col_0_0_ 
    from
        bbc.zit zit0_
2012-02-23 21:23:45,486 DEBUG (AbstractBatcher.java:401) - 
    select
        zit0_.objuid as objuid0_0_,
        zit0_.atnm as atnm0_0_,
        zit0_.itat as itat0_0_,
        zit0_.itlv as itlv0_0_,
        zit0_.blat as blat0_0_,
        zit0_.importDate as importDate0_0_,
        zit0_.lend as lend0_0_ 
    from
        bbc.zit zit0_ 
    where
        zit0_.objuid=?
科目号：123 科目名称：短期信用贷款
2012-02-23 21:23:45,517 DEBUG (AbstractBatcher.java:401) - 
    select
        zit0_.objuid as objuid0_0_,
        zit0_.atnm as atnm0_0_,
        zit0_.itat as itat0_0_,
        zit0_.itlv as itlv0_0_,
        zit0_.blat as blat0_0_,
        zit0_.importDate as importDate0_0_,
        zit0_.lend as lend0_0_ 
    from
        bbc.zit zit0_ 
    where
        zit0_.objuid=?
科目号：12301 科目名称：工业短期信用贷款
2012-02-23 21:23:45,517 DEBUG (AbstractBatcher.java:401) - 
    select
        zit0_.objuid as objuid0_0_,
        zit0_.atnm as atnm0_0_,
        zit0_.itat as itat0_0_,
        zit0_.itlv as itlv0_0_,
        zit0_.blat as blat0_0_,
        zit0_.importDate as importDate0_0_,
        zit0_.lend as lend0_0_ 
    from
        bbc.zit zit0_ 
    where
        zit0_.objuid=?
科目号：12302 科目名称：商业短期信用贷款

 这样大家可能会想，同样的查询条件，第一次先list，第二次再iterate，就可以使用到缓存了。实际上这是很难的，因为你无法判断什么时候是第一次，而且每次查询的条件通常是不一样的，假如数据库里面有100条记录，id从1到100，第一次list的时候出了前50个id，第二次iterate的时候却查询到30至70号id，那么30-50是从缓存里面取的，51到70是从数据库取的，共发送1+20条sql。所以我一直认为iterate没有什么用，总是会有1+N的问题。

当某个ID通过hibernate修改时，hibernate会知道，于是移除缓存。 

使用二级缓存的前提：

你的hibernate程序对数据库有独占的写访问权，其他的进程更新了数据库，hibernate是不可能知道的。你操作数据库必需直接通过hibernate，如果你调用存储过程，或者自己使用jdbc更新数据库，hibernate也是不知道的。hibernate3.0的大批量更新和删除是不更新二级缓存的，但是据说3.1已经解决了这个问题。 

这个限制相当的棘手，有时候hibernate做批量更新、删除很慢，但是你却不能自己写jdbc来优化，很郁闷吧。 

SessionFactory也提供了移除缓存的方法，你一定要自己写一些JDBC的话，可以调用这些方法移除缓存，这些方法是： 

void evict(Class persistentClass) 
          //Evict all entries from the second-level cache. 
void evict(Class persistentClass, Serializable id) 
         // Evict an entry from the second-level cache. 
void evictCollection(String roleName) 
         // Evict all entries from the second-level cache. 
void evictCollection(String roleName, Serializable id) 
         // Evict an entry from the second-level cache. 
void evictQueries() 
         // Evict any query result sets cached in the default query cache region. 
void evictQueries(String cacheRegion) 
         // Evict any query result sets cached in the named query cache region. 

 

不过我不建议这样做，因为这样很难维护。比如你现在用JDBC批量更新了某个表，有3个查询缓存会用到这个表，用evictQueries(String cacheRegion)移除了3个查询缓存，然后用evict(Class persistentClass)移除了class缓存，看上去好像完整了。不过哪天你添加了一个相关查询缓存，可能会忘记更新这里的移除代码。如果你的jdbc代码到处都是，在你添加一个查询缓存的时候，还知道其他什么地方也要做相应的改动吗？