自定义注解设置缓存有效期的正确姿势

最新推荐文章于 2024-05-08 23:40:17 发布

wind瑞

最新推荐文章于 2024-05-08 23:40:17 发布

阅读量722

点赞数

0?wx_fmt=gif

引言

redis缓存的有效期可以通过xml配置文件设置(默认有效期)，也可以通过编码的方式手动去设置，但是这两种方式都存在缺陷。xml方式设置的是全局的默认有效期，虽然灵活，但不能给某个缓存设置单独的有效期；硬编码方式虽然可以给不同的缓存设置单独的有效期，但是管理上不够灵活。Spring提供的Cache相关注解中并没有提供有效期的配置参数，so，自定义注解实现缓存有效期的灵活设置诞生了。

Redis缓存

如何使用Redis实现数据缓存，请参考上篇《使用Spring-Data-Redis实现数据缓存》。

工具类介绍

1.JedisPoolConfig

jedis连接池配置类，位于jedis包中，用于配置连接池中jedis连接数的个数、是否阻塞、逐出策略等。示例配置如下所示。

<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">



<property name="maxIdle" value="${redis.maxIdle}"/>



<property name="maxTotal" value="${redis.maxActive}"/>



<property name="maxWaitMillis" value="${redis.maxWait}"/>



<property name="testOnBorrow" value="${redis.testOnBorrow}"/>

</bean>

2.JedisConnectionFactory

jedis实例的创建工厂，基于连接池创建jedis实例，位于spring-data-redis包中。示例配置如下所示。

<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">



<property name="hostName" value="${redis.host}"/>



<property name="port" value="${redis.port}"/>



<property name="password" value="${redis.pass}"/>



<property name="database" value="${redis.dbIndex}"/>



<property name="poolConfig" ref="poolConfig"/>

</bean>

3.RedisTemplate

RedisTemplate可以从JedisConnectionFactory中获取jedis实例，封装了jedis的操作，位于spring-data-redis包中，让使用者无需关心连接的获取及释放，集中关注业务处理。示例配置如下所示。

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">

<property name="connectionFactory" ref="jedisConnectionFactory"/>

</bean>

4.RedisCacheManager

使用RedisTemplate对Redis缓存进行管理，位于spring-data-redis包中。示例配置如下所示。

<bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">

<constructor-arg name="redisOperations" ref="redisTemplate"/>

<property name="defaultExpiration" value="${redis.expiration}"/>

</bean>

这里介绍RedisCacheManager中一个重要的方法，void setExpires(Map<String, Long> expires)，该方法的传入参数是一个Map，Map的key值是@Cacheable(或@CacheEvict或@CachePut)注解的value值，Map的value值是缓存的有效期(单位秒)，用于批量设置缓存的有效期。

自定义注解

直接贴代码了，如下。

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.METHOD, ElementType.TYPE})

public @interface CacheDuration {

//Sets the expire time (in seconds).

public long duration() default 60;

}

使用@CacheDuration

@Service("userService")

@CacheDuration(duration = 6)

public class UserService {

@Cacheable(value = "User", key = "'UserId_' + #id", condition = "#id<=110")

@CacheDuration(duration = 16)

public String queryFullNameById(long id) {

System.out.println("execute queryFullNameById method");

return "ZhangSanFeng";

}

}

新RedisCacheManager

新写了一个SpringRedisCacheManager，继承自RedisCacheManager，用于对@CacheDuration解析及有效期的设置，代码如下。

public class SpringRedisCacheManager extends RedisCacheManager implements ApplicationContextAware, InitializingBean {

private ApplicationContext applicationContext;

public SpringRedisCacheManager(RedisOperations redisOperations) {

super(redisOperations);

}

@Override

public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

this.applicationContext = applicationContext;

}

@Override

public void afterPropertiesSet() {

parseCacheDuration(applicationContext);

}

private void parseCacheDuration(ApplicationContext applicationContext) {

final Map<String, Long> cacheExpires = new HashMap<>();

String[] beanNames = applicationContext.getBeanNamesForType(Object.class);

for (String beanName : beanNames) {

final Class clazz = applicationContext.getType(beanName);

Service service = findAnnotation(clazz, Service.class);

if (null == service) {

continue;

}

addCacheExpires(clazz, cacheExpires);

}

//设置有效期

super.setExpires(cacheExpires);

}

private void addCacheExpires(final Class clazz, final Map<String, Long> cacheExpires) {

ReflectionUtils.doWithMethods(clazz, new ReflectionUtils.MethodCallback() {

@Override

public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {

ReflectionUtils.makeAccessible(method);

CacheDuration cacheDuration = findCacheDuration(clazz, method);

Cacheable cacheable = findAnnotation(method, Cacheable.class);

CacheConfig cacheConfig = findAnnotation(clazz, CacheConfig.class);

Set<String> cacheNames = findCacheNames(cacheConfig, cacheable);

for (String cacheName : cacheNames) {

cacheExpires.put(cacheName, cacheDuration.duration());

}

}

}, new ReflectionUtils.MethodFilter() {

@Override

public boolean matches(Method method) {

return null != findAnnotation(method, Cacheable.class);

}

});

}

/**

* CacheDuration标注的有效期，优先使用方法上标注的有效期

* @param clazz

* @param method

* @return

*/

private CacheDuration findCacheDuration(Class clazz, Method method) {

CacheDuration methodCacheDuration = findAnnotation(method, CacheDuration.class);

if (null != methodCacheDuration) {

return methodCacheDuration;

}

CacheDuration classCacheDuration = findAnnotation(clazz, CacheDuration.class);

if (null != classCacheDuration) {

return classCacheDuration;

}

throw new IllegalStateException("No CacheDuration config on Class " + clazz.getName() + " and method " + method.toString());

}

private Set<String> findCacheNames(CacheConfig cacheConfig, Cacheable cacheable) {

return isEmpty(cacheable.value()) ?

newHashSet(cacheConfig.cacheNames()) : newHashSet(cacheable.value());

}

}

Spring的xml配置

完整配置redisCacheContext.xml如下所示。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:cache="http://www.springframework.org/schema/cache"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">

<context:component-scan base-package="redis.cache"/>

<context:annotation-config/>

<cache:annotation-driven cache-manager="redisCacheManager"/>

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="locations">

<list>

<value>classpath:redis.properties</value>

</list>

</property>

</bean>



<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">



<property name="maxIdle" value="${redis.maxIdle}"/>



<property name="maxTotal" value="${redis.maxActive}"/>



<property name="maxWaitMillis" value="${redis.maxWait}"/>



<property name="testOnBorrow" value="${redis.testOnBorrow}"/>

</bean>



<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">



<property name="hostName" value="${redis.host}"/>



<property name="port" value="${redis.port}"/>



<property name="password" value="${redis.pass}"/>



<property name="database" value="${redis.dbIndex}"/>



<property name="poolConfig" ref="poolConfig"/>

</bean>



<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">

<property name="connectionFactory" ref="jedisConnectionFactory"/>

</bean>



<bean id="redisCacheManager" class="redis.cache.SpringRedisCacheManager">

<constructor-arg name="redisOperations" ref="redisTemplate"/>

<property name="defaultExpiration" value="${redis.expiration}"/>

</bean>

</beans>

Redis连接配置

完整配置如下。

redis.host=127.0.0.1

redis.port=6379

redis.pass=

redis.dbIndex=0

redis.expiration=3000

redis.maxIdle=300

redis.maxActive=600

redis.maxWait=1000

redis.testOnBorrow=true

测试代码

@Test

public void testRedisCacheManager() {

ApplicationContext context = new ClassPathXmlApplicationContext("redisCacheContext.xml");

UserService userService = (UserService) context.getBean("userService");

RedisTemplate redisTemplate = (RedisTemplate) context.getBean("redisTemplate");

System.out.println("第一次执行查询：" + userService.queryFullNameById(100L));

System.out.println("----------------------------------");

System.out.println("第二次执行查询：" + userService.queryFullNameById(100L));

System.out.println("----------------------------------");

System.out.println("UserId_100有效期(单位秒)：" + redisTemplate.getExpire("UserId_100", TimeUnit.SECONDS));

System.out.println("----------------------------------");

try {

Thread.sleep(3000);

System.out.println("主线程休眠3秒后");

System.out.println("----------------------------------");

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("UserId_100有效期(单位秒)：" + redisTemplate.getExpire("UserId_100", TimeUnit.SECONDS));

System.out.println("----------------------------------");

System.out.println("第三次执行查询：" + userService.queryFullNameById(100l));

}

测试结果

execute queryFullNameById method

第一次执行查询：ZhangSanFeng

----------------------------------

第二次执行查询：ZhangSanFeng

----------------------------------

UserId_100有效期(单位秒)：15

----------------------------------

主线程休眠3秒后

----------------------------------

UserId_100有效期(单位秒)：12

----------------------------------

第三次执行查询：ZhangSanFeng