fastjson包
 <dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>${com.alibaba.fastjson}</version>
 </dependency>

spring-data-redis
 <dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-redis</artifactId>
  <version>${spring.redis.version}</version>
 </dependency>
 <dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>${jedis.redis.clients.version}</version>
 </dependency>

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;

/**
 * 緩存注解
 * 
 * @author shangdc
 *
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisCache {

 /**
 * 緩存key的名稱
 * @return
 */
 String key();

 /**
 * key是否轉(zhuǎn)換成md5值，有的key是整個(gè)參數(shù)對(duì)象，有的大內(nèi)容的，比如一個(gè)大文本，導(dǎo)致redis的key很長(zhǎng)
 * 需要轉(zhuǎn)換成md5值作為redis的key
 * @return
 */
 boolean keyTransformMd5() default false;

 /**
 * key 過期日期 秒
 * @return
 */
 int expireTime() default 60;

 /**
 * 時(shí)間單位，默認(rèn)為秒
 * @return
 */
 TimeUnit dateUnit() default TimeUnit.SECONDS;
}

/**
 * redis 緩存切面
 * 
 * @author shangdc
 *
 */
public class RedisCacheAspect {

 //由于每個(gè)人的環(huán)境，日志用的不一樣，怕報(bào)錯(cuò)，就直接關(guān)掉了此日志輸出，如有需要可加上
 //private Logger LOG = Logger.getLogger(RedisCacheAspect.class);

 /**
 * 這塊可配置，每個(gè)公司都要自己的緩存配置方式，到時(shí)候可配置自己公司所用的緩存框架和配置方式
 */
 @Resource(name = "redisTemplate")
 private ValueOperations<String, String> valueOperations;

 /**
 * 具體的方法
 * @param jp
 * @return
 * @throws Throwable
 */
 public Object cache(ProceedingJoinPoint jp, RedisCache cacheable) throws Throwable{
 // result是方法的最終返回結(jié)果
 Object result = null;

 // 得到類名、方法名和參數(shù)
 Object[] args = jp.getArgs();

 //獲取實(shí)現(xiàn)類的方法
 Method method = getMethod(jp);

 //注解信息 key
 String key = cacheable.key();

 //是否轉(zhuǎn)換成md5值
 boolean keyTransformMd5 = cacheable.keyTransformMd5();
 //----------------------------------------------------------
 // 用SpEL解釋key值
 //----------------------------------------------------------
 //解析EL表達(dá)式后的的redis的值
 String keyVal = SpringExpressionUtils.parseKey(key, method, jp.getArgs(), keyTransformMd5);

 // 獲取目標(biāo)對(duì)象
 Object target = jp.getTarget();
 //這塊是全路徑包名+目標(biāo)對(duì)象名 ，默認(rèn)的前綴，防止有的開發(fā)人員亂使用key，亂定義key的名稱，導(dǎo)致重復(fù)key，這樣在這加上前綴了，就不會(huì)重復(fù)使用key
 String target_class_name = target.getClass().getName();
 StringBuilder redis_key = new StringBuilder(target_class_name);
 redis_key.append(keyVal);

 //最終的redis的key
 String redis_final_key = redis_key.toString();
 String value = valueOperations.get(redis_final_key);

 if (value == null) { //這塊是判空
  // 緩存未命中，這塊沒用log輸出，可以自定義輸出
  System.out.println(redis_final_key + "緩存未命中緩存");

  // 如果redis沒有數(shù)據(jù)則執(zhí)行攔截的方法體 
  result = jp.proceed(args);

  //存入json格式字符串到redis里
  String result_json_data = JSONObject.toJSONString(result);
  System.out.println(result_json_data);
  // 序列化結(jié)果放入緩存
  valueOperations.set(redis_final_key, result_json_data, getExpireTimeSeconds(cacheable), TimeUnit.SECONDS);
 } else {
  // 緩存命中，這塊沒用log輸出，可以自定義輸出
  System.out.println(redis_final_key + "命中緩存，得到數(shù)據(jù)");

  // 得到被代理方法的返回值類型
  Class<?> returnType = ((MethodSignature) jp.getSignature()).getReturnType();

  //拿到數(shù)據(jù)格式
  result = getData(value, returnType);
 }
 return result;
 }

 /**
 * 根據(jù)不同的class返回?cái)?shù)據(jù)
 * @param value
 * @param clazz
 * @return
 */
 public <T> T getData(String value, Class<T> clazz){
 T result = JSONObject.parseObject(value, clazz);
 return result;
 }

 /**
 * 獲取方法
 * @param pjp
 * @return
 * @throws NoSuchMethodException
 */
 public static Method getMethod(ProceedingJoinPoint pjp) throws NoSuchMethodException {
 // --------------------------------------------------------------------------
 // 獲取參數(shù)的類型
 // --------------------------------------------------------------------------
 Object[] args = pjp.getArgs();
 Class[] argTypes = new Class[pjp.getArgs().length];
 for (int i = 0; i < args.length; i++) {
  argTypes[i] = args[i].getClass();
 }

 String methodName = pjp.getSignature().getName();
 Class<?> targetClass = pjp.getTarget().getClass();
 Method[] methods = targetClass.getMethods();

 // --------------------------------------------------------------------------
 // 查找Class<?>里函數(shù)名稱、參數(shù)數(shù)量、參數(shù)類型（相同或子類）都和攔截的method相同的Method
 // --------------------------------------------------------------------------
 Method method = null;
 for (int i = 0; i < methods.length; i++) {
  if (methods[i].getName() == methodName) {
  Class<?>[] parameterTypes = methods[i].getParameterTypes();
  boolean isSameMethod = true;

  // 如果相比較的兩個(gè)method的參數(shù)長(zhǎng)度不一樣，則結(jié)束本次循環(huán)，與下一個(gè)method比較
  if (args.length != parameterTypes.length) {
   continue;
  }

  // --------------------------------------------------------------------------
  // 比較兩個(gè)method的每個(gè)參數(shù)，是不是同一類型或者傳入對(duì)象的類型是形參的子類
  // --------------------------------------------------------------------------
  for (int j = 0; parameterTypes != null && j < parameterTypes.length; j++) {
   if (parameterTypes[j] != argTypes[j] && !parameterTypes[j].isAssignableFrom(argTypes[j])) {
   isSameMethod = false;
   break;
   }
  }
  if (isSameMethod) {
   method = methods[i];
   break;
  }
  }
 }
 return method;
 }

 /**
 * 計(jì)算根據(jù)Cacheable注解的expire和DateUnit計(jì)算要緩存的秒數(shù)
 * @param cacheable
 * @return
 */
 public int getExpireTimeSeconds(RedisCache redisCache) {
 int expire = redisCache.expireTime();
 TimeUnit unit = redisCache.dateUnit();
 if (expire <= 0) {//傳入非法值，默認(rèn)一分鐘,60秒
  return 60;
 }
 if (unit == TimeUnit.MINUTES) {
  return expire * 60;
 } else if(unit == TimeUnit.HOURS) {
  return expire * 60 * 60;
 } else if(unit == TimeUnit.DAYS) {
  return expire * 60 * 60 * 24;
 }else {//什么都不是，默認(rèn)一分鐘,60秒
  return 60;
 }
 }
}

 <!-- aop配置，切面類 .RedisCacheAspect類 bean-->
 <bean id="redisCacheAspect" class="包.RedisCacheAspect">
 </bean>

 <!-- 攔截所有指定 包和指定類型下的 下所有的方法 ，你是想這個(gè)在哪些包下可以實(shí)現(xiàn)-->
 <aop:config proxy-target-class="true">
  <aop:aspect ref="redisCacheAspect">
   <aop:pointcut id="redisCacheAopPointcut" 
     expression="(execution(* 包.business.web.service.*.*(..)) and @annotation(cacheable))"/>

   <!-- 環(huán)繞 ，命中緩存則直接放回緩存數(shù)據(jù)，不會(huì)往下走，未命中直接放行，直接執(zhí)行對(duì)應(yīng)的方法-->
   <aop:around pointcut-ref="redisCacheAopPointcut" method="cache"/>
  </aop:aspect>
 </aop:config>

/**
 * spring EL表達(dá)式
 * 
 * @author shangdc
 *
 */
public class SpringExpressionUtils {

 /**
  * 獲取緩存的key key 定義在注解上，支持SPEL表達(dá)式 注： method的參數(shù)支持Javabean和Map
  * method的基本類型要定義為對(duì)象，否則沒法讀取到名稱
  *
  * example1: Phone phone = new Phone(); "#{phone.cpu}" 為對(duì)象的取值 、
  * example2: Map apple = new HashMap(); apple.put("name","good apple"); "#{apple[name]}" 為map的取值 
  * example3: "#{phone.cpu}_#{apple[name]}"
  * 
  *
  * @param key
  * @param method
  * @param args
  * @return
  */
 public static String parseKey(String key, Method method, Object[] args, boolean keyTransformMd5) {
  // 獲取被攔截方法參數(shù)名列表(使用Spring支持類庫)
  LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
  String[] paraNameArr = u.getParameterNames(method);

  // 使用SPEL進(jìn)行key的解析
  ExpressionParser parser = new SpelExpressionParser();
  // SPEL上下文
  StandardEvaluationContext context = new StandardEvaluationContext();
  // 把方法參數(shù)放入SPEL上下文中
  for (int i = 0; i < paraNameArr.length; i++) {
   context.setVariable(paraNameArr[i], args[i]);
  }
  ParserContext parserContext = new TemplateParserContext();

  // ----------------------------------------------------------
  // 把 #{ 替換成 #{# ,以適配SpEl模板的格式
  // ----------------------------------------------------------
  //例如，@注解名稱(key="#{player.userName}",expire = 200)
  //#{phone[cpu]}_#{phone[ram]}
  //#{player.userName}_#{phone[cpu]}_#{phone[ram]}_#{pageNo}_#{pageSize}
  Object returnVal = parser.parseExpression(key.replace("#{", "#{#"), parserContext).getValue(context, Object.class);

  //這塊這么做，是為了Object和String都可以轉(zhuǎn)成String類型的，可以作為key
  String return_data_key = JSONObject.toJSONString(returnVal);
  //轉(zhuǎn)換成md5，是因?yàn)閞edis的key過長(zhǎng)，并且這種大key的數(shù)量過多，就會(huì)占用內(nèi)存，影響性能
  if(keyTransformMd5) {
   return_data_key = MD5Util.digest(return_data_key);
  }

  return returnVal == null ? null : return_data_key;
 }
}

  <!-- redisTemplate defination -->
 <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
  <property name="connectionFactory" ref="jedisConnectionFactory" />
 </bean>

public class RedisCacheTest {

 @Test
 public void test() {

  ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-applicationContext.xml");

  RedisCacheAopService redisCacheAopService = (RedisCacheAopService) context.getBean("redisCacheAopService");
  Api api = redisCacheAopService.getApi(1l);
  System.out.println(api.getClass());
  System.out.println(JSONObject.toJSONString(api));

  ApiParam param = new ApiParam();
  param.setId(2l);
  param.setApiName("短信服務(wù)接口數(shù)據(jù)");
//  System.out.println("toString:" + param.toString());
//  System.out.println(MD5Util.digest(param.toString()));
  Api api_1 = redisCacheAopService.getApiByParam(param);
  System.out.println(api_1.getClass());
  System.out.println(JSONObject.toJSONString(api_1));

 }
}

public class Api implements Serializable {

 private static final long serialVersionUID = 1L;
 /**
  * 
  * 自增主鍵id
  */
 private Long id;
 /**
  * 
  * api名稱
  */
 private String apiName;
 /**
  * 
  * api描述
  */
 private String apiDescription;
 /**
  * 
  * 有效時(shí)間
  */
 private Integer valid;
 /**
  * 處理類
  */
 private String handlerClass;
 /** 
  * 
  * 
  */
 private Date updateTime;
 /** 
  * 
  * 
  */
 private Date createTime;

 public Api() {
 }

 public String toString() {
  return "id:" + id + ", apiName:" + apiName + ", apiDescription:" + apiDescription + ", valid:" + valid + ", updateTime:" + updateTime + ", createTime:" + createTime;
 }

 public Long getId() {
  return this.id;
 }

 public void setId(Long id) {
  this.id = id;
 }

 public String getApiName() {
  return this.apiName;
 }

 public void setApiName(String apiName) {
  this.apiName = apiName;
 }

 public String getApiDescription() {
  return this.apiDescription;
 }

 public void setApiDescription(String apiDescription) {
  this.apiDescription = apiDescription;
 }

 public Integer getValid() {
  return this.valid;
 }

 public void setValid(Integer valid) {
  this.valid = valid;
 }

 public Date getUpdateTime() {
  return this.updateTime;
 }

 public void setUpdateTime(Date updateTime) {
  this.updateTime = updateTime;
 }

 public Date getCreateTime() {
  return this.createTime;
 }

 public void setCreateTime(Date createTime) {
  this.createTime = createTime;
 }

 public String getHandlerClass() {
  return handlerClass;
 }

 public void setHandlerClass(String handlerClass) {
  this.handlerClass = handlerClass;
 }
}

public class ApiParam {

 /**
  * 
  */
 private static final long serialVersionUID = 1L;

 /**
  * api表主鍵id
  */
 private Long id;

 /**
  * 
  * api名稱
  */
 private String apiName;

 /**
  * 
  * 有效OR無效
  */
 private Integer valid;

 public String getApiName() {
  return apiName;
 }

 public void setApiName(String apiName) {
  this.apiName = apiName;
 }

 public Integer getValid() {
  return valid;
 }

 public void setValid(Integer valid) {
  this.valid = valid;
 }

 public Long getId() {
  return id;
 }

 public void setId(Long id) {
  this.id = id;
 }

 /*@Override
 public String toString() {
  return "ApiParam [id=" + id + ", apiName=" + apiName + ", valid=" + valid + "]";
 }
*/
}