springboot 自定义RedisCache注解

springboot提供的Cache注解

当我们在编写查询数据库Service时，需要现在redis中查询是否有所需数据的缓存，如果有，则无需去查询数据库，这无疑提高了查询速度同时减轻了数据库的压力。 在使用springboot整合redis时，相信大家都对@Cacheable这个注解不陌生吧 例如我们需要在Service查询数据库前先去缓存中查询，如果没有在查询数据库，有则不去查询，我们只需要在redisTemplate配置类中加入@EnableCaching注解，并配置Spring Cache注解功能，如下：

package com.sunyuqi.config; import org.springframework.cache.CacheManager; import org.springframework.cache.annotation.EnableCaching; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.cache.RedisCacheConfiguration; import org.springframework.data.redis.cache.RedisCacheManager; import org.springframework.data.redis.cache.RedisCacheWriter; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.connection.RedisStandaloneConfiguration; import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer; import org.springframework.data.redis.serializer.StringRedisSerializer; @Configuration @EnableCaching class RedisTemplateConfig { @Bean public LettuceConnectionFactory redisConnectionFactory() { return new LettuceConnectionFactory(new RedisStandaloneConfiguration("127.0.0.1", 6379)); } @Bean public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate redisTemplate = new RedisTemplate(); redisTemplate.setConnectionFactory(redisConnectionFactory); redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer()); return redisTemplate; } // 配置Spring Cache注解功能 @Bean public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory); RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig(); RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, redisCacheConfiguration); return cacheManager; } }

然后在service方法上加上注解即可

@Cacheable(cacheManager = "cacheManager", value = "testcache", key = "#userId") public User findUserById(String userId) throws Exception { //此处编写查询数据库代码 User user = .... return user; }

该方法执行前会先从redis缓存中查询，如果查询到结果，则该方法不会执行，如果没有结果，该方法才会执行。

---

当我们需要自定义缓存查询逻辑时，就需要定义注解了。

自定义Cache注解

导入相关依赖

<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> <version>1.8.9</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.8.9</version> </dependency>

首先我们需要定义一个注解

package com.sunyuqi.mycache.annotations; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * cache注解 */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface Cache { String key(); }

该注解定义在方法上，并且需要传入一个参数key。 定义AOP

package com.sunyuqi.mycache.aop; import com.sunyuqi.mycache.annotations.Cache; 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.core.DefaultParameterNameDiscoverer; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.expression.EvaluationContext; import org.springframework.expression.Expression; import org.springframework.expression.ExpressionParser; import org.springframework.expression.spel.standard.SpelExpressionParser; import org.springframework.expression.spel.support.StandardEvaluationContext; import org.springframework.stereotype.Component; import java.lang.reflect.Method; @Component @Aspect public class CacheAspect { @Autowired private RedisTemplate redisTemplate; @Pointcut("@annotation(com.sunyuqi.mycache.annotations.Cache)") public void cachePointcut() { } // 定义相应的事件 @Around("cachePointcut()") public Object doCache(ProceedingJoinPoint joinPoint) { Object value = null; try { // 获取当前方法上注解的内容 MethodSignature signature = (MethodSignature) joinPoint.getSignature(); // 获取被注解的方法 Method method = joinPoint.getTarget().getClass().getMethod(signature.getName(), signature.getMethod().getParameterTypes()); Cache cacheAnnotation = method.getAnnotation(Cache.class); // 获取到传入注解中的key的值 即"#userID"（我们需要EL解析） String keyEl = cacheAnnotation.key(); // 创建解析器 ExpressionParser parser = new SpelExpressionParser(); Expression expression = parser.parseExpression(keyEl); EvaluationContext context = new StandardEvaluationContext(); // 添加参数 Object[] args = joinPoint.getArgs(); DefaultParameterNameDiscoverer discover = new DefaultParameterNameDiscoverer(); String[] parameterNames = discover.getParameterNames(method); for (int i = 0; i < parameterNames.length; i++) { context.setVariable(parameterNames[i], args[i].toString()); } // 解析EL表达式 String key = expression.getValue(context).toString(); // 查询缓存，并判定缓存中是否存在 value = redisTemplate.opsForValue().get(key); if (value != null) { System.out.println("从缓存中查询到结果：" + value); return value; } // 缓存中没有结果，执行被注解的方法 value = joinPoint.proceed(); // 将结果存入缓存 redisTemplate.opsForValue().set(key, value); } catch (Throwable throwable) { throwable.printStackTrace(); } return value; } }

在方法上使用自定义注解

@Cache(key = "#userId") public User findUserById(String userId) throws Exception { //此处编写查询数据库代码 User user = .... return user; }

使用方法是不是很简单？ 当然别忘了配置redistemplate

package com.sunyuqi.mycache.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.EnableAspectJAutoProxy; import org.springframework.context.annotation.Profile; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.connection.RedisStandaloneConfiguration; import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer; import org.springframework.data.redis.serializer.StringRedisSerializer; @Configuration @EnableAspectJAutoProxy class MyRedisConfig { @Bean public LettuceConnectionFactory redisConnectionFactory() { return new LettuceConnectionFactory(new RedisStandaloneConfiguration("127.0.0.1", 6379)); } @Bean public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate redisTemplate = new RedisTemplate(); redisTemplate.setConnectionFactory(redisConnectionFactory); redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer()); return redisTemplate; } }

这里有一个点要提醒大家： 我们存入redis的对象实际上是序列化后的字符串。 在反序列化的过程中，也就是我们在从redis中查询缓存，并转化为对象时，如果当前该对象所在的包路径与存入时对象的包路径不同，则会反序列化失败。