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的方法，并查找該結(jié)果是否存在，如果存在就返回cache中的值，
 * 否則，返回?cái)?shù)據(jù)庫查詢結(jié)果，并將查詢結(jié)果放入cache
 */
 public Object invoke(MethodInvocation invocation) throws Throwable {
 //獲取要攔截的類
 String targetName = invocation.getThis().getClass().getName();
 //獲取要攔截的類的方法
 String methodName = invocation.getMethod().getName();
 //獲得要攔截的類的方法的參數(shù)
 Object[] arguments = invocation.getArguments();
 Object result;

 //創(chuàng)建一個(gè)字符串，用來做cache中的key
 String cacheKey = getCacheKey(targetName, methodName, arguments);
 //從cache中獲取數(shù)據(jù)
 Element element = cache.get(cacheKey);

 if (element == null) {
 //如果cache中沒有數(shù)據(jù)，則查找非緩存，例如數(shù)據(jù)庫，并將查找到的放入cache

  result = invocation.proceed();
  //生成將存入cache的key和value
  element = new Element(cacheKey, (Serializable) result);
  System.out.println("-----進(jìn)入非緩存中查找，例如直接查找數(shù)據(jù)庫，查找后放入緩存");
  //將key和value存入cache
  cache.put(element);
 } else {
 //如果cache中有數(shù)據(jù)，則查找cache

  System.out.println("-----進(jìn)入緩存中查找，不查找數(shù)據(jù)庫，緩解了數(shù)據(jù)庫的壓力");
 }
 return element.getValue();
 }

 /**
 * 獲得cache的key的方法，cache的key是Cache中一個(gè)Element的唯一標(biāo)識(shí)，
 * 包括包名+類名+方法名，如：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.");
 }

}

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.");
 }

}

package com.test.service;

import java.util.List;

public interface ServiceManager { 
 public List getObject(); 

 public void updateObject(Object Object); 
}

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內(nèi)不存在該element，查找數(shù)據(jù)庫，并放入Cache！");

 return null;
 }

 @Override
 public void updateObject(Object Object) {
 System.out.println("-----ServiceManager：更新了對(duì)象，這個(gè)類產(chǎn)生的cache都將被remove！");
 }

}

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，以便產(chǎn)生攔截效果
 ServiceManager testService = (ServiceManager) context.getBean("proxyFactory");

 // 第一次查找
 System.out.println("=====第一次查找");
 testService.getObject();

 // 第二次查找
 System.out.println("=====第二次查找");
 testService.getObject();

 // 執(zhí)行update方法（應(yīng)該清除緩存）
 System.out.println("=====第一次更新");
 testService.updateObject(null);

 // 第三次查找
 System.out.println("=====第三次查找");
 testService.getObject();
 } 
}

<?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的工廠，并設(shè)置所使用的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> 

 <!-- 創(chuàng)建緩存、查詢緩存的攔截器 --> 
 <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>

 <!-- 調(diào)用接口，被攔截的對(duì)象 -->
 <bean id="serviceManager" class="com.test.service.ServiceManagerImpl" /> 

 <!-- 插入攔截器，確認(rèn)調(diào)用哪個(gè)攔截器，攔截器攔截的方法名特點(diǎn)等，此處調(diào)用攔截器com.test.ehcache.CacheMethodInterceptor -->
 <bean id="cachePointCut" 
 class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> 
 <!-- 加入切面，切面為當(dāng)執(zhí)行完print方法后，在執(zhí)行加入的切面 -->
 <property name="advice"> 
  <ref local="cacheMethodInterceptor" /> 
 </property> 
 <property name="patterns"> 
  <list> 
  <!-- 
   ### .表示符合任何單一字元   
   ### +表示符合前一個(gè)字元一次或多次   
   ### *表示符合前一個(gè)字元零次或多次   
   ### \Escape任何Regular expression使用到的符號(hào)   
  -->   
  <!-- .*表示前面的前綴(包括包名)，意思是表示getObject方法-->
  <value>.*get.*</value> 
  </list> 
 </property> 
 </bean> 

 <!-- 插入攔截器，確認(rèn)調(diào)用哪個(gè)攔截器，攔截器攔截的方法名特點(diǎn)等，此處調(diào)用攔截器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">
 <!-- 說明調(diào)用接口bean名稱 -->
 <property name="target"> 
  <ref local="serviceManager" /> 
 </property> 
 <!-- 說明攔截器bean名稱 -->
 <property name="interceptorNames"> 
  <list> 
  <value>cachePointCut</value> 
  <value>cachePointCutAdvice</value> 
  </list> 
 </property> 
 </bean> 
</beans>

<?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>