EHCache Spring

从 Spring 1.1.1 开始，EHCache 就作为一种通用缓存解决方案集成进 Spring。
我将示范拦截器的例子，它能把方法返回的结果缓存起来。
 
利用 Spring IoC 配置 EHCache
在 Spring 里配置 EHCache 很简单。你只需一个 ehcache.xml 文件，该文件用于配置 EHCache：
<ehcache>

    <!—设置缓存文件 .data 的创建路径。

         如果该路径是 Java 系统参数，当前虚拟机会重新赋值。

         下面的参数这样解释：
         user.home – 用户主目录
         user.dir      – 用户当前工作目录
         java.io.tmpdir – 默认临时文件路径 -->
    <diskStore path="java.io.tmpdir"/>

    <!—缺省缓存配置。CacheManager 会把这些配置应用到程序中。

        下列属性是 defaultCache 必须的：

        maxInMemory           - 设定内存中创建对象的最大值。
        eternal                        - 设置元素（译注：内存中对象）是否永久驻留。如果是，将忽略超
                                              时限制且元素永不消亡。
        timeToIdleSeconds  - 设置某个元素消亡前的停顿时间。
                                              也就是在一个元素消亡之前，两次访问时间的最大时间间隔值。
                                              这只能在元素不是永久驻留时有效（译注：如果对象永恒不灭，则
                                              设置该属性也无用）。
                                              如果该值是 0 就意味着元素可以停顿无穷长的时间。
        timeToLiveSeconds - 为元素设置消亡前的生存时间。
                                               也就是一个元素从构建到消亡的最大时间间隔值。
                                               这只能在元素不是永久驻留时有效。
        overflowToDisk        - 设置当内存中缓存达到 maxInMemory 限制时元素是否可写到磁盘
                                               上。
        -->

    <cache name="org.taha.cache.METHOD_CACHE"
        maxElementsInMemory="300"
        eternal="false"
        timeToIdleSeconds="500"
        timeToLiveSeconds="500"
        overflowToDisk="true"
        />
</ehcache>
拦截器将使用 ”org.taha.cache.METHOD_CACHE” 区域缓存方法返回结果。下面利用 Spring IoC 让 bean 来访问这一区域。

<!-- ======================   缓存   ======================= -->

<bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
  <property name="configLocation">
    <value>classpath:ehcache.xml</value>
  </property>
</bean>

<bean id="methodCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
  <property name="cacheManager">
    <ref local="cacheManager"/>
  </property>
  <property name="cacheName">
    <value>org.taha.cache.METHOD_CACHE</value>
  </property>
</bean> 
构建我们的 MethodCacheInterceptor
该拦截器实现org.aopalliance.intercept.MethodInterceptor接口。一旦运行起来(kicks-in)，它首先检查被拦截方法是否被配置为可缓存的。这将可选择性的配置想要缓存的 bean 方法。只要调用的方法配置为可缓存，拦截器将为该方法生成 cache key 并检查该方法返回的结果是否已缓存。如果已缓存，就返回缓存的结果，否则再次调用被拦截方法，并缓存结果供下次调用。
 
com.ph.serviceportal.infoboard.util.MethodCacheInterceptor
  package com.ph.serviceportal.infoboard.util;

import java.io.Serializable;

import net.sf.ehcache.Cache;
import net.sf.ehcache.Element;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

public class MethodCacheInterceptor implements MethodInterceptor,
        InitializingBean ...{
    private static final Log logger = LogFactory
            .getLog(MethodCacheInterceptor.class);

    private Cache cache;

    public void setCache(Cache cache) ...{
        this.cache = cache;
    }

    /** *//**
     * 
     */
    public MethodCacheInterceptor() ...{
        super();
        // TODO 自动生成构造函数存根 
    }

    /** *//**
     * 主方法
     * 如果某方法可被缓存就缓存其结果
     * 方法结果必须是可序列化的(serializable)
     */
    public Object invoke(MethodInvocation invocation) throws Throwable ...{
        String targetName = invocation.getThis().getClass().getName();
        String methodName = invocation.getMethod().getName();
        Object[] arguments = invocation.getArguments();
        Object result;

        logger.debug("在缓存中查找方法返回的对象!");
        String cacheKey = getCacheKey(targetName, methodName, arguments);
        Element element = cache.get(cacheKey);
        if (element == null) ...{
            logger.debug("正在拦截方法!");
            result = invocation.proceed();

            logger.debug("正在缓存对象!");
            element = new Element(cacheKey, (Serializable)result);
            cache.put(element);
        }
        return element.getValue();
    }

    /** *//**
     *创建一个缓存对象的标识: targetName.methodName.argument0.argument1...
     */
    private String getCacheKey(String targetName, String methodName,
            Object[] arguments) ...{
        StringBuffer sb = new StringBuffer();
        sb.append(targetName).append(".").append(methodName);
        if ((arguments != null) && (arguments.length != 0)) ...{
            for (int i = 0; i < arguments.length; i++) ...{
                sb.append(".").append(arguments[i]);
            }
        }

        return sb.toString();
    }

    /**//* （非 Javadoc）
     * @see org.springframework.beans.factory.InitializingBeanafterPropertiesSet()
     */
    public void afterPropertiesSet() throws Exception ...{
        Assert.notNull(cache, "需要一个缓存. 使用setCache(Cache)分配一个.");

    }
}

  com.ph.serviceportal.infoboard.util.MethodCacheAfterAdvice 
 
package com.ph.serviceportal.infoboard.util;

import java.lang.reflect.Method;

import net.sf.ehcache.Cache;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

public class MethodCacheAfterAdvice implements AfterReturningAdvice,
        InitializingBean ...{

    private Cache cache;

    public void setCache(Cache cache) ...{
        this.cache = cache;
    }

    /** *//**
     *
     */
    public MethodCacheAfterAdvice() ...{
        super();
    }

    /**//*
     * （非 Javadoc）
     *
     * @see org.springframework.aop.AfterReturningAdviceafterReturning(java.lang.Object,
     *      java.lang.reflect.Method, java.lang.Object[], java.lang.Object)
     */
    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable ...{
        StringBuffer buffer = new StringBuffer();
        buffer.append(arg3.getClass().getName()).append(".").append(
                arg1.getName());
        if (arg2 != null && arg2.length != 0) ...{
            for (int i = 0; i < arg2.length; i++) ...{
                buffer.append(".").append(arg2[i]);
            }

        }
        cache.remove(buffer);
    }

    /**//*
     * （非 Javadoc）
     *
     * @see org.springframework.beans.factory.InitializingBeanafterPropertiesSet()
     */
    public void afterPropertiesSet() throws Exception ...{
        Assert.notNull(cache, "需要一个缓存. 使用setCache(Cache)分配一个.");
    }
}

MethodCacheInterceptor 代码说明了：
默认条件下，所有方法返回结果都被缓存了（methodNames 是 null）
缓存区利用 IoC 形成
cacheKey 的生成还包括方法参数的因素（译注：参数的改变会影响 cacheKey）
使用 MethodCacheInterceptor
下面摘录了怎样配置 MethodCacheInterceptor and MethodCacheAfterAdvice：
<bean id="methodCacheInterceptor"
        class="com.ph.serviceportal.infoboard.util.MethodCacheInterceptor">
        <property name="cache">
            <ref local="methodCache" />
        </property>
    </bean>
    <bean id="methodCacheAfterAdvice"
        class="com.ph.serviceportal.infoboard.util.MethodCacheAfterAdvice">
        <property name="cache">
            <ref local="methodCache" />
        </property>
    </bean>
    <bean id="methodCachePointCut"
        class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice">
            <ref local="methodCacheInterceptor" />
        </property>
        <property name="patterns">
            <list>
                <value>.*find.*</value>
                <value>.*get.*</value>
            </list>
        </property>
    </bean>
    <bean id="methodCacheAdvicePointCut"
        class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice">
            <ref local="methodCacheAfterAdvice" />
        </property>
        <property name="patterns">
            <list>
                <value>.*upd.*</value>
                <value>.*save.*</value>
                <value>.*delete.*</value>
            </list>
        </property>
    </bean>
结合上一篇文章，我们有如下配置： spring+JAX-RPC(Axis) 构建webservice
    <bean name="infoboardService"
        class="com.ph.serviceportal.infoboard.service.InfoBoardServiceImpl">
        <property name="dataRetriever" ref="infoboardDAO" />
    </bean>

    <bean name="infoboardDAO"
        class="com.ph.serviceportal.infoboard.dao.InfoboardDAOImpl">
        <property name="infoboardDAO">
            <ref local="infoboardServiceRpcProxy" />
        </property>
    </bean>

    <bean id="infoboardServiceRpcProxy"
        class="org.springframework.remoting.jaxrpc.JaxRpcPortProxyFactoryBean">
        <property name="serviceInterface">
            <value>
                com.hp.serviceportal.infoboard.dao.IInfoboardDAO
            </value>
        </property>
        <property name="wsdlDocumentUrl">
            <value>
                http://qatest17.mro.cpqcorp.net/infoboard_ws_1100/infoboard.asmx?wsdl
            </value>
        </property>
        <property name="namespaceUri">
            <value>http://tempuri.org/InfoBoard_WS/Service1</value>
        </property>
        <property name="serviceName">
            <value>Service1</value>
        </property>
        <property name="portName">
            <value>Service1Soap</value>
        </property>
        <property name="portInterface">
            <value>
                org.tempuri.InfoBoard_WS.Service1.Service1Soap
            </value>
        </property>
    </bean>
对infoboardservice进行增强:
    <bean id="infoboardServiceCacheProxy"
        class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.ph.serviceportal.infoboard.service.IInfoBoardService</value>
        </property>
        <property name="target">
            <ref local="infoboardService" />
        </property>
        <property name="interceptorNames">
            <list>
                <value>methodCachePointCut</value>
                <value>methodCacheAfterAdvice</value>
            </list>
        </property>
    </bean>

 

-------------------------

 

 

1、首先设置EhCache，建立配置文件ehcache.xml，默认的位置在class-path，可以放到你的src目录下：

＜?xml version="1.0" encoding="UTF-8"?＞
＜ehcache＞
　＜diskStore path="java.io.tmpdir"/＞
　　＜defaultCache
　　　maxElementsInMemory="10000" ＜!-- 缓存最大数目 --＞
　　　eternal="false" ＜!-- 缓存是否持久 --＞
　　　overflowToDisk="true" ＜!-- 是否保存到磁盘，当系统当机时--＞
　　　timeToIdleSeconds="300" ＜!-- 当缓存闲置n秒后销毁 --＞
　　　timeToLiveSeconds="180" ＜!-- 当缓存存活n秒后销毁--＞
　　　diskPersistent="false"
　　　diskExpiryThreadIntervalSeconds= "120"/＞
＜/ehcache＞

2、在Hibernate配置文件中设置：

＜!-- 设置Hibernate的缓存接口类，这个类在Hibernate包中 --＞
＜property name="cache.provider_class"＞org.hibernate.cache.EhCacheProvider＜/property＞
　＜!-- 是否使用查询缓存 --＞
　＜property name="hibernate.cache.use_query_cache"＞true＜/property＞
　　如果使用spring调用Hibernate的sessionFactory的话，这样设置：
　　＜!--HibernateSession工厂管理 --＞
　　　＜bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"＞
　　　＜property name="dataSource"＞
　　　　＜ref bean="datasource" /＞
　　　＜/property＞
　　　＜property name="hibernateProperties"＞
　　　＜props＞
　　　　＜prop key="hibernate.dialect"＞org.hibernate.dialect.Oracle9Dialect＜/prop＞
　　　　＜prop key="connection.provider_class"＞org.hibernate.connection.C3P0ConnectionProvider＜/prop＞
　　　　＜prop key="hibernate.show_sql"＞true＜/prop＞
　　　　＜prop key="hibernate.cache.use_query_cache"＞true＜/prop＞
　　　　＜prop key="hibernate.cache.provider_class"＞org.hibernate.cache.EhCacheProvider＜/prop＞
　　　＜/props＞
　＜/property＞
　＜property name="mappingDirectoryLocations"＞
　　＜list＞
　　　＜value＞/WEB-INF/classes/cn/rmic/manager/hibernate/＜/value＞
　　＜/list＞
　＜/property＞
＜/bean＞

说明一下：如果不设置“查询缓存”，那么hibernate只会缓存使用load()方法获得的单个持久化对象，如果想缓存使用findall()、list()、Iterator()、createCriteria()、createQuery()等方法获得的数据结果集的话，就需要设置
hibernate.cache.use_query_cache true 才行

3、在Hbm文件中添加＜cache usage="read-only"/＞

4、如果需要“查询缓存”，还需要在使用Query或Criteria()时设置其setCacheable(true);属性

5、实践出真知，给一段测试程序，如果成功的话第二次查询时不会读取数据库

package cn.rmic.hibernatesample;
import java.util.List;


import org.hibernate.CacheMode;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;


import cn.rmic.hibernatesample.hibernate.HibernateSessionFactory;
import cn.rmic.manager.po.Resources;


public class testCacheSelectList ...{


　/** *//**
　* @param args
　*/
　public static void main(String[] args) ...{
　　// TODO Auto-generated method stub


　　Session s=HibernateSessionFactory.getSession();
　　Criteria c=s.createCriteria(Resources.class);
　　c.setCacheable(true);
　　List l=c.list();
　　// Query q=s.createQuery("From Resources r")
　　// .setCacheable(true)
　　// .setCacheRegion("frontpages") ;
　　// List l=q.list();
　　Resources resources=(Resources)l.get(0);
　　System.out.println("-1-"+resources.getName());
　　HibernateSessionFactory.closeSession();
　　try ...{
　　　Thread.sleep(5000);
　　} catch (InterruptedException e) ...{
　　　// TODO Auto-generated catch block
　　　e.printStackTrace();
　　}
　　s=HibernateSessionFactory.getSession();
　　c=s.createCriteria(Resources.class);
　　c.setCacheable(true);
　　l=c.list();
　　// q=s.createQuery("From Resources r").setCacheable(true)
　　// .setCacheRegion("frontpages");
　　// l=q.list();
　　resources=(Resources)l.get(0);
　　System.out.println("-2-"+resources.getName());
　　HibernateSessionFactory.closeSession();
　}
}