通过AOP方式实现Service计算结果的缓存

川长思鸟来 2022-08-03 13:54 49阅读 0赞

AOP为Aspect Oriented Programming， 面向切面的编程。意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

Spring框架的AOP基础知识详见：

[Spring实现AOP的4种方式][Spring_AOP_4]

[Spring AOP 详解][Spring AOP]

AOP的应用场景很多。可以作为日志系统的记录拦截，也可以用于缓存的拦截。

以下用我自己的框架项目 [springMVC][] 中实现的Ehcache对Service层计算结果缓存的实现为例子。介绍一下。

## Service缓存实现 ##

主要实现思路通过AOP拦截的方式插入缓存层的操作。

参考:[Spring AOP+ehCache简单缓存系统解决方案][Spring AOP_ehCache]

## 简单的配置以及实现效果 ##

### Ehcache配置 ###

ehcache的配置文件默认在 `classpath:ehcache.xml` MAVEN工程对应 `src/main/resources` 。定义了缓存的配置信息，\* 必须有一个 默认缓存defaultCache \*。在管理器找不到缓存的时候，就会用默认缓存。

<?xml version="1.0" encoding="UTF-8"?>
    
    
    
    
    
    <ehcache mlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
        <diskStore path="java.io.tmpdir" />
        <defaultCache maxElementsInMemory="1000" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="false" />
        <cache name="myCache" maxElementsOnDisk="20000" maxElementsInMemory="2000" eternal="true" overflowToDisk="true" diskPersistent="true" />
    </ehcache>

### AOP拦截 ###

#### 拦截器编写 ####

*  取缓存 `MethodCacheInterceptor`

package org.company.core.common.interceptor;
    
    import java.io.Serializable;
    import java.lang.reflect.Method;
    import java.util.List;
    
    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 MethodCacheInterceptor implements MethodInterceptor, InitializingBean { 
    
        private Cache cache;
    
        /** * 设置缓存名 */
        public void setCache(Cache cache) {
            this.cache = cache;
        }
    
        /** * 检查是否提供必要参数。 */
        public void afterPropertiesSet() throws Exception {
            Assert.notNull(cache,
                    "A cache is required. Use setCache(Cache) to provide one.");
        }
    
        /** * 主方法 如果某方法可被缓存就缓存其结果 方法结果必须是可序列化的(serializable) */
        public Object invoke(MethodInvocation invocation) throws Throwable {
    // String methodName = invocation.getMethod().getName();
    // if(methodName.contains("find")){ 
    // return get(invocation);
    // } else { 
    // return remove(invocation);
    // }
            String targetName = invocation.getThis().getClass().getName();
            String methodName = invocation.getMethod().getName();
            Object[] arguments = invocation.getArguments();
            Object result;
    
            String cacheKey = getCacheKey(targetName, methodName, arguments);
            System.out.println("getting from cache...");
            Element element = cache.get(cacheKey);
            System.out.println("cache Key:" + cacheKey);
            if (element == null) {
                System.out.println("miss");
                result = invocation.proceed();
                element = new Element(cacheKey, (Serializable) result);
                cache.put(element);
                return element.getValue();
            } else {
                System.out.println("hit");
                return element.getValue();
            }
        }
    
    // }
    
        /** * creates cache key: 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();
        }
    }

*  删除缓存

package org.company.core.common.interceptor;
    
    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.transaction.annotation.Transactional;
    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();    
        }    
        @Transactional
        public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {    
            String className = arg3.getClass().getName();    
            List list = cache.getKeys();    
            System.out.println("invoking...");
            System.out.println("removing cache key:"+className+".*");
            for(int i = 0;i<list.size();i++){    
                String cacheKey = String.valueOf(list.get(i));    
                if(cacheKey.startsWith(className)){    
                    System.out.println("remving key:"+cacheKey);
                    cache.remove(cacheKey);    
                }    
            }    
        }    
    
        public void afterPropertiesSet() throws Exception {    
            Assert.notNull(cache, "Need a cache. Please use setCache(Cache) create it.");    
        }      
    }

#### 配置文件 ####

配置详见 `applicationContext-ehcache.xml`

##### 注册拦截器类 #####

声明了拦截器的BEAN

<bean id="methodCacheInterceptor" class="org.company.frame.interceptor.MethodCacheInterceptor">
            <property name="cache">
                <ref local="demoCache" />
            </property>
        </bean>
          
        <bean id="methodCacheAfterAdvice" class="org.company.frame.interceptor.MethodCacheAfterAdvice">  
          <property name="cache">  
            <ref local="demoCache" />  
          </property>  
        </bean>

##### 切入点声明 #####

将拦截器BEAN与方法匹配。

<bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
            <property name="advice">
                <ref local="methodCacheInterceptor" />
            </property>
            <property name="patterns">
                <list>
                    <value>org.company.core.*.service.*find.*</value>
                </list>
            </property>
        </bean>
        
        <bean id="methodCachePointCutAdvice" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  
          <property name="advice">  
            <ref local="methodCacheAfterAdvice"/>  
          </property>  
          <property name="patterns">  
            <list>  
              <value>org.company.core.*.service.*create.*</value>  
              <value>org.company.core.*.service.*update.*</value>  
              <value>org.company.core.*.service.*delete.*</value>  
            </list>  
          </property>  
        </bean>

##### AOP的最终声明 #####

绑定服务BEAN与拦截器切入点。

<bean id="myService" class="org.springframework.aop.framework.ProxyFactoryBean">
            <property name="target">
                <ref local="testTableServiceBean" />
            </property>
            <property name="interceptorNames">
                <list>
                    <value>methodCachePointCut</value>
                    <value>methodCachePointCutAdvice</value>
                </list>
            </property>
        </bean> 
    
    
        
        <bean id="testTableServiceBean" class="org.company.core.moduel.service.TestTableServiceImpl">
        </bean>

缓存的最终实现效果如图:

![这里写图片描述][20150809135458134]

[Spring_AOP_4]: http://blog.csdn.net/udbnny/article/details/5870076
[Spring AOP]: http://pandonix.iteye.com/blog/336873/
[springMVC]: https://github.com/WengShengyuan/springMVC
[Spring AOP_ehCache]: http://blog.csdn.net/linfanhehe/article/details/7690684
[20150809135458134]: /images/20220731/86bee544cbf04dc28df77c69e31effb4.png