基于Annotation与SpringAOP的缓存简单解决方案

前言：

　　由于项目的原因，需要对项目中大量访问多修改少的数据进行缓存并管理，为达到开发过程中通过Annotation简单的配置既可以完成对缓存的设置与更新的需求，故而设计的该简易的解决方案。

涉及技术：

1.Spring AOP

2.Java Annotation

3.Memcache （项目中使用的缓存组件）

4.JVM基础（Class文件结构，用于解析出方法中的形参名称，动态生成缓存key，目测效率不高0.0）

5.Ognl （用于动态解析缓存的key）

实现细节：

Annotation：LoadFromMemcached 用于method之上的注解，作用是使带有该注解的method在调用的时候先经过缓存查询，缓存中查询不到再去数据库查询并将结果缓存至缓存服务器Memcache中，

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LoadFromMemcached {
   String value();//缓存的key     
   int timeScope() default 600;//默认过期时间，单位秒
   String condition() default "";//执行缓存查询的条件
}

　Annotation：UpdateForMemcached 类似于LoadFromMemcached，作用是使带有该注解的method在调用的时候更新缓存服务器中的缓存，

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface UpdateForMemcached {
  String[] value();//可能有多个key需要更新
  String condition() default "";//执行缓存的条件
}

　　AOP：MemcachedCacheInterceptor 缓存AOP实现的核心类，用于对Annotation注解了的method进行拦截并进行相应的操作，

  1 import java.lang.annotation.Annotation;
  2 import java.lang.reflect.Method;
  3 import java.util.ArrayList;
  4 import java.util.HashMap;
  5 import java.util.List;
  6 import java.util.Map;
  7 import java.util.concurrent.TimeoutException;
  8 import java.util.regex.Matcher;
  9 import java.util.regex.Pattern;
 10 import javax.annotation.Resource;
 11 import net.rubyeye.xmemcached.MemcachedClient;
 12 import net.rubyeye.xmemcached.exception.MemcachedException;
 13 import ognl.Ognl;
 14 import ognl.OgnlException;
 15 import org.aspectj.lang.ProceedingJoinPoint;
 16 import org.aspectj.lang.annotation.Around;
 17 import org.aspectj.lang.annotation.Aspect;
 18 import org.aspectj.lang.reflect.MethodSignature;
 19 import org.slf4j.Logger;
 20 import org.slf4j.LoggerFactory;
 21 import org.springframework.stereotype.Component;
 22 @Component
 23 @Aspect
 24 public class MemcachedCacheInterceptor {
 25   private final String GET = "@annotation(LoadFromMemcached)";
 26   private final String UPDATE = "@annotation(UpdateForMemcached)";
 27   // 替换为其他缓存组件即可切换为其他缓存系统，这里是使用的Memcached。如果再抽象一层缓存系统管理，则可以动态的更换缓存系统。
 28   @Resource
 29   private MemcachedClient cache;
 30   private Logger log = LoggerFactory
 31       .getLogger(MemcachedCacheInterceptor.class);
 32   /**
 33    * 
 34    * @Title: get
 35    * @Description: 首先从缓存中加载数据，缓存命中则返回数据，未命中则从数据库查找，并加入缓存
 36    * @param @param call
 37    * @param @return
 38    * @param @throws Throwable
 39    * @return Object
 40    * @throws
 41    */
 42   @Around(GET)
 43   public Object get(ProceedingJoinPoint call) throws Throwable {
 44     LoadFromMemcached anno = getAnnotation(call, LoadFromMemcached.class);
 45     String key = anno.value();
 46     int timeSocpe = anno.timeScope();
 47     if (!executeCondition(anno.condition(), call)) {// 不满足条件,直接调用方法，不进行缓存AOP操作
 48       return call.proceed();
 49     }
 50     key = getKeyNameFromParam(key, call);
 51     Object value = null;
 52     try {
 53       value = cache.get(key);
 54     } catch (TimeoutException e) {
 55       log.error("Get Data From Memcached TimeOut!About Key:" + key, e);
 56       e.printStackTrace();
 57     } catch (InterruptedException e) {
 58       log.error(
 59           "Get Data From Memcached TimeOut And Interrupted!About Key:"
 60               + key, e);
 61       e.printStackTrace();
 62     } catch (MemcachedException e) {
 63       log.error(
 64           "Get Data From Memcached And Happend A Unexpected Error!About Key:"
 65               + key, e);
 66       e.printStackTrace();
 67     }
 68     if (value == null) {
 69       value = call.proceed();
 70       if (value != null) {
 71         try {
 72           cache.add(key, timeSocpe, value);
 73           log.info("Add Data For Memcached Success!About Key:" + key);
 74         } catch (TimeoutException e) {
 75           log.error(
 76               "Add Data For Memcached TimeOut!About Key:" + key,
 77               e);
 78           e.printStackTrace();
 79         } catch (InterruptedException e) {
 80           log.error(
 81               "Add Data For Memcached TimeOut And Interrupted!About Key:"
 82                   + key, e);
 83           e.printStackTrace();
 84         } catch (MemcachedException e) {
 85           log.error(
 86               "Add Data For Memcached And Happend A Unexpected Error!About Key:"
 87                   + key, e);
 88           e.printStackTrace();
 89         }
 90       }
 91     }
 92     return value;
 93   }
 94   /**
 95    * 
 96    * @Title: update
 97    * @Description: 执行方法的同时更新缓存中的数据
 98    * @param @param call
 99    * @param @return
100    * @param @throws Throwable
101    * @return Object
102    * @throws
103    */
104   @Around(UPDATE)
105   public Object update(ProceedingJoinPoint call) throws Throwable {
106     UpdateForMemcached anno = getAnnotation(call, UpdateForMemcached.class);
107     String[] key = anno.value();// 可能需要更新多个key
108     Object value = call.proceed();
109     if (!executeCondition(anno.condition(), call)) {// 不满足条件,直接调用方法，不进行缓存AOP操作
110       return value;
111     }
112     if (value != null) {
113       try {
114         for (String singleKey : key) {// 循环处理所有需要更新的key
115           String tempKey = getKeyNameFromParam(singleKey, call);
116           cache.delete(tempKey);
117         }
118         log.info("Update Data For Memcached Success!About Key:" + key);
119       } catch (TimeoutException e) {
120         log.error("Update Data For Memcached TimeOut!About Key:" + key,
121             e);
122         e.printStackTrace();
123       } catch (InterruptedException e) {
124         log.error(
125             "Update Data For Memcached TimeOut And Interrupted!About Key:"
126                 + key, e);
127         e.printStackTrace();
128       } catch (MemcachedException e) {
129         log.error(
130             "Update Data For Memcached And Happend A Unexpected Error!About Key:"
131                 + key, e);
132         e.printStackTrace();
133       }
134     }
135     return value;
136   }
137   /**
138    * 
139    * @Title: getAnnotation
140    * @Description: 获得Annotation对象
141    * @param @param <T>
142    * @param @param jp
143    * @param @param clazz
144    * @param @return
145    * @return T
146    * @throws
147    */
148   private <T extends Annotation> T getAnnotation(ProceedingJoinPoint jp,
149       Class<T> clazz) {
150     MethodSignature joinPointObject = (MethodSignature) jp.getSignature();
151     Method method = joinPointObject.getMethod();
152     return method.getAnnotation(clazz);
153   }
154   /**
155    * 
156    * @Title: getKeyNameFromParam
157    * @Description: 获得组合后的KEY值
158    * @param @param key
159    * @param @param jp
160    * @param @return
161    * @return String
162    * @throws
163    */
164   private String getKeyNameFromParam(String key, ProceedingJoinPoint jp) {
165     if (!key.contains("$")) {
166       return key;
167     }
168     String regexp = "\$\{[^\}]+\}";
169     Pattern pattern = Pattern.compile(regexp);
170     Matcher matcher = pattern.matcher(key);
171     List<String> names = new ArrayList<String>();
172     try {
173       while (matcher.find()) {
174         names.add(matcher.group());
175       }
176       key = executeNames(key, names, jp);
177     } catch (Exception e) {
178       log.error("Regex Parse Error!", e);
179     }
180     return key;
181   }
182   /**
183    * 
184    * @Title: executeNames
185    * @Description: 对KEY中的参数进行替换
186    * @param @param key
187    * @param @param names
188    * @param @param jp
189    * @param @return
190    * @param @throws OgnlException
191    * @return String
192    * @throws
193    */
194   private String executeNames(String key, List<String> names,
195       ProceedingJoinPoint jp) throws OgnlException {
196     Method method = ((MethodSignature) jp.getSignature()).getMethod();
197     // 形参列表
198     List<String> param = MethodParamNamesScaner.getParamNames(method);
199     if (names == null || names.size() == 0) {
200       return key;
201     }
202     Object[] params = jp.getArgs();
203     Map<String, Object> map = new HashMap<String, Object>();
204     for (int i = 0; i < param.size(); i++) {
205       map.put(param.get(i), params[i]);
206     }
207     for (String name : names) {
208       String temp = name.substring(2);
209       temp = temp.substring(0, temp.length() - 1);
210       key = myReplace(key, name, (String) Ognl.getValue(temp, map));
211     }
212     return key;
213   }
214   /**
215    * 
216    * @Title: myReplace
217    * @Description: 不依赖Regex的替换，避免$符号、{}等在String.replaceAll方法中当做Regex处理时候的问题。
218    * @param @param src
219    * @param @param from
220    * @param @param to
221    * @param @return
222    * @return String
223    * @throws
224    */
225   private String myReplace(String src, String from, String to) {
226     int index = src.indexOf(from);
227     if (index == -1) {
228       return src;
229     }
230     return src.substring(0, index) + to
231         + src.substring(index + from.length());
232   }
233   /**
234    * 
235    * @Title: executeCondition
236    * @Description: 判断是否需要进行缓存操作
237    * @param @param condition parm
238    * @param @return
239    * @return boolean true:需要 false：不需要
240    * @throws
241    */
242   private boolean executeCondition(String condition, ProceedingJoinPoint jp) {
243     if ("".equals(condition)) {
244       return true;
245     }
246     Method method = ((MethodSignature) jp.getSignature()).getMethod();
247     // 形参列表
248     List<String> param = MethodParamNamesScaner.getParamNames(method);
249     if (param == null || param.size() == 0) {
250       return true;
251     }
252     Object[] params = jp.getArgs();
253     Map<String, Object> map = new HashMap<String, Object>();
254     for (int i = 0; i < param.size(); i++) {
255       map.put(param.get(i), params[i]);
256     }
257     boolean returnVal = false;
258     try {
259       returnVal = (Boolean) Ognl.getValue(condition, map);
260     } catch (OgnlException e) {
261       e.printStackTrace();
262     }
263     return returnVal;
264   }
265   public void setCache(MemcachedClient cache) {
266     this.cache = cache;
267   }
268 }

辅助类：借用MethodParamNamesScaner类与Ognl结合完成对缓存key的动态解析功能，

  1 //引用至：https://gist.github.com/wendal/2011728，用于解析方法的形参名称
  2 import java.io.BufferedInputStream;
  3 import java.io.DataInputStream;
  4 import java.io.IOException;
  5 import java.io.InputStream;
  6 import java.lang.reflect.Constructor;
  7 import java.lang.reflect.Method;
  8 import java.util.ArrayList;
  9 import java.util.HashMap;
 10 import java.util.List;
 11 import java.util.Map;
 12 /**
 13  * 通过读取Class文件,获得方法形参名称列表
 14  * 
 15  * @author wendal(wendal1985@gmail.com)
 16  * 
 17  */
 18 public class MethodParamNamesScaner {
 19   /**
 20    * 获取Method的形参名称列表
 21    * 
 22    * @param method
 23    *            需要解析的方法
 24    * @return 形参名称列表,如果没有调试信息,将返回null
 25    */
 26   public static List<String> getParamNames(Method method) {
 27     try {
 28       int size = method.getParameterTypes().length;
 29       if (size == 0)
 30         return new ArrayList<String>(0);
 31       List<String> list = getParamNames(method.getDeclaringClass()).get(
 32           getKey(method));
 33       if (list != null && list.size() != size)
 34         return list.subList(0, size);
 35       return list;
 36     } catch (Throwable e) {
 37       throw new RuntimeException(e);
 38     }
 39   }
 40   /**
 41    * 获取Constructor的形参名称列表
 42    * 
 43    * @param constructor
 44    *            需要解析的构造函数
 45    * @return 形参名称列表,如果没有调试信息,将返回null
 46    */
 47   public static List<String> getParamNames(Constructor<?> constructor) {
 48     try {
 49       int size = constructor.getParameterTypes().length;
 50       if (size == 0)
 51         return new ArrayList<String>(0);
 52       List<String> list = getParamNames(constructor.getDeclaringClass())
 53           .get(getKey(constructor));
 54       if (list != null && list.size() != size)
 55         return list.subList(0, size);
 56       return list;
 57     } catch (Throwable e) {
 58       throw new RuntimeException(e);
 59     }
 60   }
 61   // ---------------------------------------------------------------------------------------------------
 62   /**
 63    * 获取一个类的所有方法/构造方法的形参名称Map
 64    * 
 65    * @param klass
 66    *            需要解析的类
 67    * @return 所有方法/构造方法的形参名称Map
 68    * @throws IOException
 69    *             如果有任何IO异常,不应该有,如果是本地文件,那100%遇到bug了
 70    */
 71   public static Map<String, List<String>> getParamNames(Class<?> klass)
 72       throws IOException {
 73     InputStream in = klass.getResourceAsStream("/"
 74         + klass.getName().replace('.', '/') + ".class");
 75     return getParamNames(in);
 76   }
 77   public static Map<String, List<String>> getParamNames(InputStream in)
 78       throws IOException {
 79     DataInputStream dis = new DataInputStream(new BufferedInputStream(in));
 80     Map<String, List<String>> names = new HashMap<String, List<String>>();
 81     Map<Integer, String> strs = new HashMap<Integer, String>();
 82     dis.skipBytes(4);// Magic
 83     dis.skipBytes(2);// 副版本号
 84     dis.skipBytes(2);// 主版本号
 85     // 读取常量池
 86     int constant_pool_count = dis.readUnsignedShort();
 87     for (int i = 0; i < (constant_pool_count - 1); i++) {
 88       byte flag = dis.readByte();
 89       switch (flag) {
 90       case 7:// CONSTANT_Class:
 91         dis.skipBytes(2);
 92         break;
 93       case 9:// CONSTANT_Fieldref:
 94       case 10:// CONSTANT_Methodref:
 95       case 11:// CONSTANT_InterfaceMethodref:
 96         dis.skipBytes(2);
 97         dis.skipBytes(2);
 98         break;
 99       case 8:// CONSTANT_String:
100         dis.skipBytes(2);
101         break;
102       case 3:// CONSTANT_Integer:
103       case 4:// CONSTANT_Float:
104         dis.skipBytes(4);
105         break;
106       case 5:// CONSTANT_Long:
107       case 6:// CONSTANT_Double:
108         dis.skipBytes(8);
109         i++;// 必须跳过一个,这是class文件设计的一个缺陷,历史遗留问题
110         break;
111       case 12:// CONSTANT_NameAndType:
112         dis.skipBytes(2);
113         dis.skipBytes(2);
114         break;
115       case 1:// CONSTANT_Utf8:
116         int len = dis.readUnsignedShort();
117         byte[] data = new byte[len];
118         dis.read(data);
119         strs.put(i + 1, new String(data, "UTF-8"));// 必然是UTF8的
120         break;
121       case 15:// CONSTANT_MethodHandle:
122         dis.skipBytes(1);
123         dis.skipBytes(2);
124         break;
125       case 16:// CONSTANT_MethodType:
126         dis.skipBytes(2);
127         break;
128       case 18:// CONSTANT_InvokeDynamic:
129         dis.skipBytes(2);
130         dis.skipBytes(2);
131         break;
132       default:
133         throw new RuntimeException("Impossible!! flag=" + flag);
134       }
135     }
136     dis.skipBytes(2);// 版本控制符
137     dis.skipBytes(2);// 类名
138     dis.skipBytes(2);// 超类
139     // 跳过接口定义
140     int interfaces_count = dis.readUnsignedShort();
141     dis.skipBytes(2 * interfaces_count);// 每个接口数据,是2个字节
142     // 跳过字段定义
143     int fields_count = dis.readUnsignedShort();
144     for (int i = 0; i < fields_count; i++) {
145       dis.skipBytes(2);
146       dis.skipBytes(2);
147       dis.skipBytes(2);
148       int attributes_count = dis.readUnsignedShort();
149       for (int j = 0; j < attributes_count; j++) {
150         dis.skipBytes(2);// 跳过访问控制符
151         int attribute_length = dis.readInt();
152         dis.skipBytes(attribute_length);
153       }
154     }
155     // 开始读取方法
156     int methods_count = dis.readUnsignedShort();
157     for (int i = 0; i < methods_count; i++) {
158       dis.skipBytes(2); // 跳过访问控制符
159       String methodName = strs.get(dis.readUnsignedShort());
160       String descriptor = strs.get(dis.readUnsignedShort());
161       short attributes_count = dis.readShort();
162       for (int j = 0; j < attributes_count; j++) {
163         String attrName = strs.get(dis.readUnsignedShort());
164         int attribute_length = dis.readInt();
165         if ("Code".equals(attrName)) { // 形参只在Code属性中
166           dis.skipBytes(2);
167           dis.skipBytes(2);
168           int code_len = dis.readInt();
169           dis.skipBytes(code_len); // 跳过具体代码
170           int exception_table_length = dis.readUnsignedShort();
171           dis.skipBytes(8 * exception_table_length); // 跳过异常表
172           int code_attributes_count = dis.readUnsignedShort();
173           for (int k = 0; k < code_attributes_count; k++) {
174             int str_index = dis.readUnsignedShort();
175             String codeAttrName = strs.get(str_index);
176             int code_attribute_length = dis.readInt();
177             if ("LocalVariableTable".equals(codeAttrName)) {// 形参在LocalVariableTable属性中
178               int local_variable_table_length = dis
179                   .readUnsignedShort();
180               List<String> varNames = new ArrayList<String>(
181                   local_variable_table_length);
182               for (int l = 0; l < local_variable_table_length; l++) {
183                 dis.skipBytes(2);
184                 dis.skipBytes(2);
185                 String varName = strs.get(dis
186                     .readUnsignedShort());
187                 dis.skipBytes(2);
188                 dis.skipBytes(2);
189                 if (!"this".equals(varName)) // 非静态方法,第一个参数是this
190                   varNames.add(varName);
191               }
192               names.put(methodName + "," + descriptor, varNames);
193             } else
194               dis.skipBytes(code_attribute_length);
195           }
196         } else
197           dis.skipBytes(attribute_length);
198       }
199     }
200     dis.close();
201     return names;
202   }
203   /**
204    * 传入Method或Constructor,获取getParamNames方法返回的Map所对应的key
205    */
206   public static String getKey(Object obj) {
207     StringBuilder sb = new StringBuilder();
208     if (obj instanceof Method) {
209       sb.append(((Method) obj).getName()).append(',');
210       getDescriptor(sb, (Method) obj);
211     } else if (obj instanceof Constructor) {
212       sb.append("<init>,"); // 只有非静态构造方法才能用有方法参数的,而且通过反射API拿不到静态构造方法
213       getDescriptor(sb, (Constructor<?>) obj);
214     } else
215       throw new RuntimeException("Not Method or Constructor!");
216     return sb.toString();
217   }
218   public static void getDescriptor(StringBuilder sb, Method method) {
219     sb.append('(');
220     for (Class<?> klass : method.getParameterTypes())
221       getDescriptor(sb, klass);
222     sb.append(')');
223     getDescriptor(sb, method.getReturnType());
224   }
225   public static void getDescriptor(StringBuilder sb,
226       Constructor<?> constructor) {
227     sb.append('(');
228     for (Class<?> klass : constructor.getParameterTypes())
229       getDescriptor(sb, klass);
230     sb.append(')');
231     sb.append('V');
232   }
233   /** 本方法来源于ow2的asm库的Type类 */
234   public static void getDescriptor(final StringBuilder buf, final Class<?> c) {
235     Class<?> d = c;
236     while (true) {
237       if (d.isPrimitive()) {
238         char car;
239         if (d == Integer.TYPE) {
240           car = 'I';
241         } else if (d == Void.TYPE) {
242           car = 'V';
243         } else if (d == Boolean.TYPE) {
244           car = 'Z';
245         } else if (d == Byte.TYPE) {
246           car = 'B';
247         } else if (d == Character.TYPE) {
248           car = 'C';
249         } else if (d == Short.TYPE) {
250           car = 'S';
251         } else if (d == Double.TYPE) {
252           car = 'D';
253         } else if (d == Float.TYPE) {
254           car = 'F';
255         } else /* if (d == Long.TYPE) */{
256           car = 'J';
257         }
258         buf.append(car);
259         return;
260       } else if (d.isArray()) {
261         buf.append('[');
262         d = d.getComponentType();
263       } else {
264         buf.append('L');
265         String name = d.getName();
266         int len = name.length();
267         for (int i = 0; i < len; ++i) {
268           char car = name.charAt(i);
269           buf.append(car == '.' ? '/' : car);
270         }
271         buf.append(';');
272         return;
273       }
274     }
275   }
276 }

使用案例：

1.使用缓存：

 1 /*
 2  * value:缓存中的键，${map.name}会动态替换为传入参数map里面的key为name的值。
 3  * comdition：缓存执行条件：!map.containsKey('execute')表示map中不包含execute这个key的时候才进行缓存操作。
 4  * 这里面的map是传入的参数名称。
 5  * 执行到该方法会自动去缓存里面查找该key，有就直接返回，没有就执行该方法，如果返回值不为空则同时存入缓存并返回结果。
 6  */
 7 @LoadFromMemcached(value="Resource_selectByMap_${map.name}",condition="!map.containsKey('execute')" )
 8 public List<Resource> selectByMap(Object map) {
 9      return super.selectByMap(map);
10 }

表示执行该method(selectByMap)的时候会首先去缓存组件中查找数据，如果查找到数据就直接返回，如果找不到数据就执行方法体，并将返回值记录入缓存中。

2.更新缓存：

1 /*
2  * 同样value为缓存中的key，${t.name}会动态替换为update方法传入参数Resource的name字段
3  * comdition：字段作用同上，不演示了
4  */
5 @UpdateForMemcached(value="Resource_selectByMap_${t.name}")
6 public int update(Resource t) {
7         return super.update(t);
8 }

表示执行该method(update)的时候会同步将缓存中的key置为过期(并不是把该方法的返回值放入缓存，只是将对应的缓存设为过期，下次再执行selectByMap的时候获取的就是最新的数据了)。

扩展：

本文只是简单的解决方案，可能有很多不足的地方，欢迎交流，以此简单的结构为基础进行扩展，将MemcachedClient以及相关的缓存操作方法提取出来并完善细节即可完成基本通用的缓存组件。