手写redis@Cacheable注解支持过期时间设置

最新推荐文章于 2025-10-30 18:16:09 发布

原创最新推荐文章于 2025-10-30 18:16:09 发布 · 3.2k 阅读

1 ·

CC 4.0 BY-SA版权

Spring 专栏收录该内容

25 篇文章

订阅专栏

本文介绍如何使用Spring AOP及自定义注解@ExtCacheable实现方法级别的Redis缓存功能，包括缓存配置、注解定义及AOP切面处理等关键技术点。

原理解释
友情链接手写redis @ Cacheable注解参数java对象作为键值

@Cacheable注解作用，将带有该注解方法的返回值存放到redis的的中;

使用方法在方法上使用@Cacheable（键=“测试+＃P0 + P1＃...”）

表示键值为测试+方法第一个参数+方法第二个参数，值值为该方法的返回值。

以下源代码表示获取人员列表，Redis的中存放的关键值为'领袖'+ leaderGroupId + UUID + yearDetailId

@Override
   @Cacheable(key="'leader'+#p0+#p1+#p2",value="leader")
   public List<Leader> listLeaders(String leaderGroupId, String uuid, String yearDetailId) {
       return sysIndexMapper.listLeaders(leaderGroupId, uuid, yearDetailId);
   }
等同于

@Override
   public List<Leader> listLeaders(String leaderGroupId, String uuid, String yearDetailId) {
       String key = "leader" + leaderGroupId + uuid + yearDetailId;
       // 判断缓存是否存在redis中
       boolean hasKey = redisUtil.hasKey(key);
       if (hasKey) {
//如果存在返还redis中的值
           Object leadersList = redisUtil.get(key);
           return (List<Leader>) leadersList;
       } else {
           List<Leader> leadersQuotaDetailList = sysIndexMapper.listLeaders(leaderGroupId, uuid, yearDetailId);
//将查询结果存放在redis中
           redisUtil.set(key, leadersQuotaDetailList);
           return leadersQuotaDetailList;
       }
   }
说白了就是在原方法的前面判断的关键值是否存在的Redis的中，如果存在就取内存中的值，如果不存在就查询数据库，将查询结果存放在Redis的的中。

实现方法
使用代理模式，在方法执行前和执行后可以添加其他处理程序，本文采用springAOP +注解方式。
集成redis，封装Redis工具类
原版本不支持关键过期时间设置，本文将实现
源代码
缓存配置类RedisConfig

package com.huajie.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
* Redis缓存配置类
*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

   @Value("${spring.redis.host}")
   private String host;
   @Value("${spring.redis.port}")
   private int port;
   @Value("${spring.redis.timeout}")
   private int timeout;

   // 自定义缓存key生成策略
   @Bean
   public KeyGenerator keyGenerator() {
       return new KeyGenerator() {
           @Override
           public Object generate(Object target, java.lang.reflect.Method method, Object... params) {
               StringBuffer sb = new StringBuffer();
               sb.append(target.getClass().getName());
               sb.append(method.getName());
               for (Object obj : params) {
                   sb.append(obj.toString());
               }
               return sb.toString();
           }
       };
   }

   // 缓存管理器
   @Bean
   public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
       RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
       // 设置缓存过期时间
       cacheManager.setDefaultExpiration(10000);
       return cacheManager;
   }

   @Bean
   public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
       RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
       template.setConnectionFactory(factory);
       Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
       ObjectMapper om = new ObjectMapper();
       om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
       om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
       jackson2JsonRedisSerializer.setObjectMapper(om);
       StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
       // key采用String的序列化方式
       template.setKeySerializer(stringRedisSerializer);
       // hash的key也采用String的序列化方式
       template.setHashKeySerializer(stringRedisSerializer);
       // value序列化方式采用jackson
       template.setValueSerializer(jackson2JsonRedisSerializer);
       // hash的value序列化方式采用jackson
       template.setHashValueSerializer(jackson2JsonRedisSerializer);
       template.afterPropertiesSet();
       return template;
   }

   private void setSerializer(StringRedisTemplate template) {
       @SuppressWarnings({ "rawtypes", "unchecked" })
       Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
       ObjectMapper om = new ObjectMapper();
       om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
       om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
       jackson2JsonRedisSerializer.setObjectMapper(om);
       template.setValueSerializer(jackson2JsonRedisSerializer);
   }
}
Redis的依赖引入，配置文件，工具类RedisUtil，网上几个版本都类似，本文参考以下版本传送门

https://www.cnblogs.com/zeng1994/p/03303c805731afc9aa9c60dbbd32a323.html

准备工作做好之后开始正式编写注解@Cacheable nextkey（）用做二级缓存本文中不会用到

nextKey用法详情> 设计模式（实战） - 责任链模式 <

创建的Java的注解@ExtCacheable

package com.huajie.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtCacheable {

   String key() default "";

   String nextKey() default "";

   int expireTime() default 1800;//30分钟

}
SpringAop切面CacheableAspect

package com.huajie.aspect;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.huajie.annotation.ExtCacheable;
import com.huajie.utils.RedisUtil;

/**
* redis缓存处理
* 不适用与内部方法调用(this.)或者private
*/
@Component
@Aspect
public class CacheableAspect {

   @Autowired
   private RedisUtil redisUtil;

   @Pointcut("@annotation(com.huajie.annotation.ExtCacheable)")
   public void annotationPointcut() {
   }

   @Around("annotationPointcut()")
   public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
       // 获得当前访问的class
       Class<?> className = joinPoint.getTarget().getClass();
       // 获得访问的方法名
       String methodName = joinPoint.getSignature().getName();
       // 得到方法的参数的类型
       Class<?>[] argClass = ((MethodSignature) joinPoint.getSignature()).getParameterTypes();
       Object[] args = joinPoint.getArgs();
       String key = "";
       int expireTime = 1800;
       try {
           // 得到访问的方法对象
           Method method = className.getMethod(methodName, argClass);
           method.setAccessible(true);
           // 判断是否存在@ExtCacheable注解
           if (method.isAnnotationPresent(ExtCacheable.class)) {
               ExtCacheable annotation = method.getAnnotation(ExtCacheable.class);
               key = getRedisKey(args,annotation);
               expireTime = getExpireTime(annotation);
           }
       } catch (Exception e) {
           throw new RuntimeException("redis缓存注解参数异常", e);
       }
       // 获取缓存是否存在
       boolean hasKey = redisUtil.hasKey(key);
       if (hasKey) {
           return redisUtil.get(key);
       } else {
//执行原方法（java反射执行method获取结果）
           Object res = joinPoint.proceed();
//设置缓存
           redisUtil.set(key, res);
//设置过期时间
           redisUtil.expire(key, expireTime);
           return res;
       }
   }

   private int getExpireTime(ExtCacheable annotation) {
       return annotation.expireTime();
   }

   private String getRedisKey(Object[] args,ExtCacheable annotation) {
       String primalKey = annotation.key();
       //获取#p0...集合
       List<String> keyList = getKeyParsList(primalKey);
       for (String keyName : keyList) {
           int keyIndex = Integer.parseInt(keyName.toLowerCase().replace("#p", ""));
           Object parValue = args[keyIndex];
           primalKey = primalKey.replace(keyName, String.valueOf(parValue));
       }
       return primalKey.replace("+","").replace("'","");
   }

   // 获取key中#p0中的参数名称
   private static List<String> getKeyParsList(String key) {
       List<String> ListPar = new ArrayList<String>();
       if (key.indexOf("#") >= 0) {
           int plusIndex = key.substring(key.indexOf("#")).indexOf("+");
           int indexNext = 0;
           String parName = "";
           int indexPre = key.indexOf("#");
           if(plusIndex>0){
               indexNext = key.indexOf("#") + key.substring(key.indexOf("#")).indexOf("+");
               parName = key.substring(indexPre, indexNext);
           }else{
               parName = key.substring(indexPre);
           }
           ListPar.add(parName.trim());
           key = key.substring(indexNext + 1);
           if (key.indexOf("#") >= 0) {
               ListPar.addAll(getKeyParsList(key));
           }
       }
       return ListPar;
   }

}
业务模块使用方法

@Override
   @ExtCacheable(key = "Leaders+#p0+#p1+#p2")
   // 手机端获取领导人员列表
   public List<Leader> listLeaders(String leaderGroupId, String uuid, String yearDetailId) {
       List<Leader> leadersQuotaDetailList = sysIndexMapper.listLeaders(leaderGroupId, uuid, yearDetailId);
       return leadersQuotaDetailList;
   }
业务模块过期时间使用方法，5分钟过期

@Override
   @ExtCacheable(key = "mobileCacheFlag", expireTime = 60 * 5)
   public int cacheFlag() {
       int mobileCacheFlag = 1;
       mobileCacheFlag = sysIndexMapper.cacheFlag();
       return mobileCacheFlag;
   }

Redis的的截图