Redis缓存系列--(五)自定义Redis缓存注解的使用
自定义Redis缓存注解的实现
我们在Spring的框架中，可以使用注解的形式(@EnableCache和@Cacheable)来实现对查询的数据进行Redis的缓存，我们自己其实也可以自定义一个缓存注解来实现redis缓存的功能。
编写自定义缓存注解
首先，我们要自定义一个Redis缓存注解，之后要将该注解标注到对应的方法上去，代码如下：
/**
* 对方法启用Redis缓存，使其具有方法前判断缓存，方法后如果没有缓存则存储Redis缓存
* 缓存key的格式为：value::key，具体的数值由用户传递的注解参数来提供
* @author young
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRedisCacheable {
/**
* Redis缓存key的前缀
* @return
*/
String value() default "";
/**
* Redis缓存key的后缀
* @return
*/
String key() default "";
}
编写具体AOP代理方法类
注解只是用来标注当前的方法要用来做什么，同时传递相应操作所需要的参数信息。具体要在标注的方法前后实现什么功能，还需要通过Spring AOP的面向切面编程来实现对方法前后所需要进行的处理。具体代码如下：
/**
* MyRedisCacheable注解的具体处理类，实现对标注方法执行前做Redis缓存检查处理，方法执行后执行缓存Redis数据的处理
* @author young
*/
@Component
@Aspect
public class CacheAspect {
private Logger logger = LoggerFactory.getLogger(CacheAspect.class);
@Autowired
private RedisTemplate redisTemplate;
/**
* 设置注解的切入点，即指定切入的方法为
*/
@Pointcut("@annotation(com.young.redis.aop.MyRedisCacheable)")
public void cachePointcut(){
}
/**
* 定义需要进行AOP切面编程的切点是哪个，也即标注MyRedisCacheable注释的方法
* @param proceedingJoinPoint 当前切入方法的上下文
* @return
*/
@Around("cachePointcut()")
public Object doRedisCache(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
Object value = null;
try {
//获取切入方法的标签
MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
//通过该标签来获取修饰的方法和方法参数
Method method = proceedingJoinPoint.getTarget().getClass().
getMethod(signature.getName(),signature.getMethod().getParameterTypes());
//获取当前方法的注解以及注解的参数
MyRedisCacheable myRedisCacheable = method.getAnnotation(MyRedisCacheable.class);
//redis key的EL表达式
String keyEL = myRedisCacheable.key();
//redis key的前缀
String prifix = myRedisCacheable.value();
//解析EL表达式
ExpressionParser expressionParser = new SpelExpressionParser();
Expression expression =expressionParser.parseExpression(keyEL);
//用来组合EL表达式和方法参数的EL上下文对象
EvaluationContext evaluationContext = new StandardEvaluationContext();
//获取方法的参数，将参数放入evaluationContext
Object[] args = proceedingJoinPoint.getArgs();
DefaultParameterNameDiscoverer defaultParameterNameDiscoverer = new DefaultParameterNameDiscoverer();
String[] parameterNames = defaultParameterNameDiscoverer.getParameterNames(method);
for (int i = 0; i < parameterNames.length; i++) {
evaluationContext.setVariable(parameterNames[i],args[i].toString());
}
//使用Expression和EvaluationContext来解析EL表达式
String cacheKey = prifix + "::" + expression.getValue(evaluationContext).toString();
//判断缓存是否存在
value = redisTemplate.opsForValue().get(cacheKey);
if(value != null){
logger.info("从缓存中读取到的key:" + cacheKey +",value:" + value);
return value;
}
//不存在则执行数据库方法进行查询
value = proceedingJoinPoint.proceed();
//将查询到的内容存到Redis
redisTemplate.opsForValue().set(cacheKey,value);
}catch (Throwable throwable){
throwable.printStackTrace();
}
//方法执行后返回查询结果
return value;
}
}
编写配置类
无论是在SpringMvc框架还是Springboot框架中，都可以通过编写配置类的方式来配置需要加载的bean对象，具体的配置类代码如下：
/**
* 通过注解的形式来配置spring中的bean
* 使用自定义注解方式来实现Redis缓存
* @author young
*/
@Configuration
@EnableAspectJAutoProxy //开启AOP自动代理
public class AppConfig {
/**
* 通过注释来获取properties配置文件中的自定义值，引号里边为EL表达式
*/
@Value("${spring.redis.host}")
String host;
@Value("${spring.redis.port}")
int port;
/**
* 通过RedisConnectionFactory来获取RedisTemplate，从而进行Redis的相关操作（注解方式同样需要）
* @return
*/
@Bean
public RedisConnectionFactory redisConnectionFactory(){
//配置Redis的主机和端口
RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setHostName(host);
redisStandaloneConfiguration.setPort(port);
//
RedisConnectionFactory redisConnectionFactory = new JedisConnectionFactory(redisStandaloneConfiguration);
return redisConnectionFactory;
}
/**
* 加载RedisTemplate bean
* @param redisConnectionFactory
* @return
*/
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
RedisTemplate redisTemplate = new RedisTemplate();
redisTemplate.setConnectionFactory(redisConnectionFactory);
//指定Redis序列化的方式
redisTemplate.setKeySerializer(StringRedisSerializer.UTF_8);
return redisTemplate;
}
}
这样，一个自定义Redis缓存注解的实现也就基本完成了，这对于我们了解注解的底层原理也是很有帮助的。
