Spring搭配Ehcache实例解析

1 ehcache简介

ehcache 是一个纯java的进程内缓存框架，具有快速、精干等特点，是hibernate中默认的cacheprovider。

ehcache是一种广泛使用的开源java分布式缓存。主要面向通用缓存,java ee和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持rest和soap api等特点。

ehcache最初是由greg luck于2003年开始开发。2009年,该项目被terracotta购买。软件仍然是开源,但一些新的主要功能(例如，快速可重启性之间的一致性的)只能在商业产品中使用，例如enterprise ehcache and bigmemory。维基媒体foundationannounced目前使用的就是ehcache技术。

总之ehcache还是一个不错的缓存技术，我们来看看spring搭配ehcache是如何实现的。

2 spring搭配ehcache

系统结果如下：

3 具体配置介绍

有这几部分的结合：

src：java代码，包含拦截器，调用接口，测试类

src/cache-bean.xml：配置ehcache，拦截器，以及测试类等信息对应的bean

src/ehcache.xml：ehcache缓存配置信息

webroot/lib：库

4 详细内容介绍

4.1 src

4.1.1 拦截器

代码中首先配置了两个拦截器：

第一个拦截器为：

com.test.ehcache.cachemethodinterceptor

内容如下：

package com.test.ehcache;

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.springframework.beans.factory.initializingbean;
import org.springframework.util.assert;

public class cachemethodinterceptor implements methodinterceptor,
 initializingbean {

 private cache cache;

 public void setcache(cache cache) {
 this.cache = cache;
 }

 public cachemethodinterceptor() {
 super();
 }

 /**
 * 拦截servicemanager的方法，并查找该结果是否存在，如果存在就返回cache中的值，
 * 否则，返回数据库查询结果，并将查询结果放入cache
 */
 public object invoke(methodinvocation invocation) throws throwable {
 //获取要拦截的类
 string targetname = invocation.getthis().getclass().getname();
 //获取要拦截的类的方法
 string methodname = invocation.getmethod().getname();
 //获得要拦截的类的方法的参数
 object[] arguments = invocation.getarguments();
 object result;

 //创建一个字符串，用来做cache中的key
 string cachekey = getcachekey(targetname, methodname, arguments);
 //从cache中获取数据
 element element = cache.get(cachekey);

 if (element == null) {
 //如果cache中没有数据，则查找非缓存，例如数据库，并将查找到的放入cache

  result = invocation.proceed();
  //生成将存入cache的key和value
  element = new element(cachekey, (serializable) result);
  system.out.println("-----进入非缓存中查找，例如直接查找数据库，查找后放入缓存");
  //将key和value存入cache
  cache.put(element);
 } else {
 //如果cache中有数据，则查找cache

  system.out.println("-----进入缓存中查找，不查找数据库，缓解了数据库的压力");
 }
 return element.getvalue();
 }

 /**
 * 获得cache的key的方法，cache的key是cache中一个element的唯一标识，
 * 包括包名+类名+方法名，如：com.test.service.testserviceimpl.getobject
 */
 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();
 }

 /**
 * implement initializingbean，检查cache是否为空 70
 */
 public void afterpropertiesset() throws exception {
 assert.notnull(cache,
  "need a cache. please use setcache(cache) create it.");
 }

}

cachemethodinterceptor用来拦截以“get”开头的方法，注意这个拦截器是先拦截，后执行原调用接口。

还有一个拦截器：

com.test.ehcache.cacheafterreturningadvice

具体内容：

package com.test.ehcache;

import java.lang.reflect.method;
import java.util.list;

import net.sf.ehcache.cache;

import org.springframework.aop.afterreturningadvice;
import org.springframework.beans.factory.initializingbean;
import org.springframework.util.assert;

public class cacheafterreturningadvice implements afterreturningadvice,
 initializingbean {

 private cache cache;

 public void setcache(cache cache) {
 this.cache = cache;
 }

 public cacheafterreturningadvice() {
 super();
 }

 public void afterreturning(object arg0, method arg1, object[] arg2,
  object arg3) throws throwable {
 string classname = arg3.getclass().getname();
 list list = cache.getkeys();
 for (int i = 0; i < list.size(); i++) {
  string cachekey = string.valueof(list.get(i));
  if (cachekey.startswith(classname)) {
  cache.remove(cachekey);
  system.out.println("-----清除缓存");
  }
 }
 }

 public void afterpropertiesset() throws exception {
 assert.notnull(cache,
  "need a cache. please use setcache(cache) create it.");
 }

}

cacheafterreturningadvice用来拦截以“update”开头的方法，注意这个拦截器是先执行原调用接口，后被拦截。

4.1.2 调用接口

接口名称为：

com.test.service.servicemanager

具体内容如下：

package com.test.service;

import java.util.list;

public interface servicemanager { 
 public list getobject(); 

 public void updateobject(object object); 
}

实现类名称为：

com.test.service.servicemanagerimpl

具体内容如下：

package com.test.service;

import java.util.arraylist;
import java.util.list;

public class servicemanagerimpl implements servicemanager {

 @override
 public list getobject() {
 system.out.println("-----servicemanager：缓存cache内不存在该element，查找数据库，并放入cache！");

 return null;
 }

 @override
 public void updateobject(object object) {
 system.out.println("-----servicemanager：更新了对象，这个类产生的cache都将被remove！");
 }

}

4.1.3 测试类

测试类名称为：

com.test.service.testmain

具体内容为：

package com.test.service;

import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;

public class testmain {

 public static void main(string[] args) {

 string cachestring = "/cache-bean.xml";
 applicationcontext context = new classpathxmlapplicationcontext(
  cachestring);
 //获取代理工厂proxyfactory生成的bean，以便产生拦截效果
 servicemanager testservice = (servicemanager) context.getbean("proxyfactory");

 // 第一次查找
 system.out.println("=====第一次查找");
 testservice.getobject();

 // 第二次查找
 system.out.println("=====第二次查找");
 testservice.getobject();

 // 执行update方法（应该清除缓存）
 system.out.println("=====第一次更新");
 testservice.updateobject(null);

 // 第三次查找
 system.out.println("=====第三次查找");
 testservice.getobject();
 } 
}

此处要注意，获取bean是通过代理工厂proxyfactory生产的bean，这样才会有拦截效果。

能够看出来，在测试类里面设置了四次调用，执行顺序为：

第一次查找
第二次查找
第一次更新
第三次查找

4.2 src/cache-bean.xml

cache-bean.xml用来配置ehcache，拦截器，以及测试类等信息对应的bean，内容如下：

<?xml version="1.0" encoding="utf-8"?> 
 <!doctype beans public "-//spring//dtd bean//en" 
"http://www.springframework.org/dtd/spring-beans.dtd"> 
<beans> 
 <!-- 引用ehcache 的配置--> 
 <bean id="defaultcachemanager" 
 class="org.springframework.cache.ehcache.ehcachemanagerfactorybean"> 
 <property name="configlocation"> 
  <value>ehcache.xml</value> 
 </property>
 </bean> 

 <!-- 定义ehcache的工厂，并设置所使用的cache的name，即“com.tt” --> 
 <bean id="ehcache" class="org.springframework.cache.ehcache.ehcachefactorybean"> 
 <property name="cachemanager"> 
  <ref local="defaultcachemanager" /> 
 </property>
 <!-- cache的名称 -->
 <property name="cachename"> 
  <value>com.tt</value> 
 </property> 
 </bean> 

 <!-- 创建缓存、查询缓存的拦截器 --> 
 <bean id="cachemethodinterceptor" class="com.test.ehcache.cachemethodinterceptor"> 
 <property name="cache"> 
  <ref local="ehcache" /> 
 </property> 
 </bean>

 <!-- 更新缓存、删除缓存的拦截器 --> 
 <bean id="cacheafterreturningadvice" class="com.test.ehcache.cacheafterreturningadvice"> 
 <property name="cache"> 
  <ref local="ehcache" /> 
 </property> 
 </bean>

 <!-- 调用接口，被拦截的对象 -->
 <bean id="servicemanager" class="com.test.service.servicemanagerimpl" /> 

 <!-- 插入拦截器，确认调用哪个拦截器，拦截器拦截的方法名特点等，此处调用拦截器com.test.ehcache.cachemethodinterceptor -->
 <bean id="cachepointcut" 
 class="org.springframework.aop.support.regexpmethodpointcutadvisor"> 
 <!-- 加入切面，切面为当执行完print方法后，在执行加入的切面 -->
 <property name="advice"> 
  <ref local="cachemethodinterceptor" /> 
 </property> 
 <property name="patterns"> 
  <list> 
  <!-- 
   ### .表示符合任何单一字元   
   ### +表示符合前一个字元一次或多次   
   ### *表示符合前一个字元零次或多次   
   ### \escape任何regular expression使用到的符号   
  -->   
  <!-- .*表示前面的前缀(包括包名)，意思是表示getobject方法-->
  <value>.*get.*</value> 
  </list> 
 </property> 
 </bean> 

 <!-- 插入拦截器，确认调用哪个拦截器，拦截器拦截的方法名特点等，此处调用拦截器com.test.ehcache.cacheafterreturningadvice -->
 <bean id="cachepointcutadvice" 
 class="org.springframework.aop.support.regexpmethodpointcutadvisor"> 
 <property name="advice"> 
  <ref local="cacheafterreturningadvice" /> 
 </property> 
 <property name="patterns"> 
  <list>
  <!-- .*表示前面的前缀(包括包名)，意思是updateobject方法--> 
  <value>.*update.*</value> 
  </list> 
 </property> 
 </bean>

 <!-- 代理工厂 -->
 <bean id="proxyfactory" class="org.springframework.aop.framework.proxyfactorybean">
 <!-- 说明调用接口bean名称 -->
 <property name="target"> 
  <ref local="servicemanager" /> 
 </property> 
 <!-- 说明拦截器bean名称 -->
 <property name="interceptornames"> 
  <list> 
  <value>cachepointcut</value> 
  <value>cachepointcutadvice</value> 
  </list> 
 </property> 
 </bean> 
</beans>

各个bean的内容都做了注释说明，值得注意的是，不要忘了代理工厂bean。

4.3 src/ehcache.xml

ehcache.xml中存储ehcache缓存配置的详细信息，内容如下：

<?xml version="1.0" encoding="utf-8"?> 
<ehcache xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:nonamespaceschemalocation="http://ehcache.org/ehcache.xsd">
 <!-- 缓存文件位置 -->
 <diskstore path="d:\\temp\\cache" /> 

 <defaultcache maxelementsinmemory="1000" eternal="false" 
 timetoidleseconds="120" timetoliveseconds="120" overflowtodisk="true" /> 
 <!-- 定义缓存文件信息，其中“com.tt”为缓存文件的名字 --> 
 <cache name="com.tt" maxelementsinmemory="10000" eternal="false" 
 timetoidleseconds="300000" timetoliveseconds="600000" overflowtodisk="true" /> 
</ehcache>

能够看到缓存的存储的存储位置设置为“d:\temp\cache”，缓存名称设置成了“com.tt”，如图：

4.4 webroot/lib

所需的java库，详见开头的系统结构图片，此处略。

5 测试

执行测试类，测试结果如下：

通过执行结果我们能够看出：

第一次查找被拦截后发现是首次拦截，还没有缓存cache，所以先执行一下原有接口类，得到要查询的数据，有可能是通过数据库查询得到的，然后再生成cache，并将查询得到的数据放入cache。

第二次查找被拦截后发现已经存在cache，于是不再执行原有接口类，也就是不再查询数据库啦，直接通过cache得到查询数据。当然这里只是简单打印一下。

然后是第一次更新，被拦截后所做的操作是将cache中的数据全部存入数据库，并将cache删除。

最后是第三次查询，被拦截后又发现系统不存在cache，于是执行原接口类查询数据库，创建cache，并将新查询得到的数据放入cache。同第一次查询的方式是一样的。

至此我们就实现了spring搭配ehcache所需要完成的操作。

6 附件源代码

附件源代码可以从我的github网站上获取。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。