Spring Cacheable(Redis)扩展实现注解式TTL

最新推荐文章于 2024-05-19 11:08:01 发布
最新推荐文章于 2024-05-19 11:08:01 发布
阅读量2.8w 收藏 7
点赞数 1
分类专栏： java
本文链接：https://blog.csdn.net/liuyanglglg/article/details/102916371
版权

一、背景

我们在项目当中经常要使用redis作为缓存，可选择的方式有：1）编程方式 2）注解方式

1. 编程方式

  1. jedis
  2. redisTempate
  3. redisson
  4. …

2. 注解方式

  1. spring cache系列注解
  2. 通过切面自定义注解实现
    由于spring @Cacheable提供了多种缓存实现，有的缓存是不支持ttl的，因此@Cacheable注解当中是没有设置ttl参数的，Redis实现的Cache，配置ttl必须单独集中配置，如下：
RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory)
    .cacheDefaults(defaultConfig);

Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
// 自定义每个cacheName的配置
RedisCacheConfiguration config = cacheDefault(resourceLoader);
config = config.entryTtl(Duration.ofMinutes(30));
cacheConfigurations.put("store", config);

cacheConfigurations.put("store-nearby", defaultConfig);

return builder.withInitialCacheConfigurations(cacheConfigurations).build();

这样做有spring的道理，但是确实感觉不是很灵活，团队之前也基于切面实现了一套支持ttl的注解。最近项目架构升级到spring-boot，能不能基于spring-boot-data-redis扩展实现注解方式的ttl？

二、思路

1. 增加切面

比如，我们自定义一个@Ttl注解，如果一个方法上面同时有@Cacheable @Ttl注解，我们解析对应Redis Key, 方法执行结束后，给对应的key设置过期时间

2. 找SpringCache扩展点

Debug代码，寻找扩展点进行扩展。

经过比较，我发现spring生成key的策略是比较复杂的，RedisCacheConfiguration可以配置前缀，KeyGenerator又可以自定义配置key的生成策略。实现代码解析key难度较大，并且容易出现bug，直接放弃这种方式。因为我们要通过反射拿到方法上的ttl时间，我们这个扩展点首先要能获取当前执行的Method，奔着目标，debug代码，我把目标放在了RedisCache、CacheAspectSupport、CacheResolver、RedisCacheManager这几个类上。

RedisCache
	@Override
	public void put(Object key, @Nullable Object value) {

		Object cacheValue = preProcessCacheValue(value);

		if (!isAllowNullValues() && cacheValue == null) {

			throw new IllegalArgumentException(String.format(
					"Cache '%s' does not allow 'null' values. Avoid storing null via '@Cacheable(unless=\"#result == null\")' or configure RedisCache to allow 'null' via RedisCacheConfiguration.",
					name));
		}

		cacheWriter.put(name, createAndConvertCacheKey(key), serializeCacheValue(cacheValue), cacheConfig.getTtl());
	}

重点代码

cacheWriter.put(name, createAndConvertCacheKey(key), serializeCacheValue(cacheValue), cacheConfig.getTtl());

这一行代码，我可以看出来，ttl是从全局变量cacheConfig的getTtl()获取的，下一步我要找到RedisCache的实例是什么时候生成并注入cacheConfig的。

CacheAspectSupport
	protected Collection<? extends Cache> getCaches(
			CacheOperationInvocationContext<CacheOperation> context, CacheResolver cacheResolver) {

		Collection<? extends Cache> caches = cacheResolver.resolveCaches(context);
		if (caches.isEmpty()) {
			throw new IllegalStateException("No cache could be resolved for '" +
					context.getOperation() + "' using resolver '" + cacheResolver +
					"'. At least one cache should be provided per cache operation.");
		}
		return caches;
	}

CacheOperationInvocationContext这个类可以获取到Method, 获取Cache的操作又托管给了CacheResolver.resolveCaches方法

CacheResolver
	public Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context) {
		Collection<String> cacheNames = getCacheNames(context);
		if (cacheNames == null) {
			return Collections.emptyList();
		}
		Collection<Cache> result = new ArrayList<>(cacheNames.size());
		for (String cacheName : cacheNames) {
			Cache cache = getCacheManager().getCache(cacheName);
			if (cache == null) {
				throw new IllegalArgumentException("Cannot find cache named '" +
						cacheName + "' for " + context.getOperation());
			}
			result.add(cache);
		}
		return result;
	}

Cache cache = getCacheManager().getCache(cacheName);

getCache最终会调用RedisCacheManager

	protected RedisCache createRedisCache(String name, @Nullable RedisCacheConfiguration cacheConfig) {
		return new RedisCache(name, cacheWriter, cacheConfig != null ? cacheConfig : defaultCacheConfig);
	}

这个方法是protected，我们在CacheResolver无法调用，只能自定义一个RedisCacheManager子类，实现一个createRedisCache方法。

三、实现

1. 注解

@CacheableTtl
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Cacheable(cacheResolver = "ttlCacheResolver")
public @interface CacheableTtl {

    @AliasFor("cacheNames")
    String[] value() default {};

    @AliasFor("value")
    String[] cacheNames() default {};

    String key() default "";

    String keyGenerator() default "";

    String condition() default "";

    String unless() default "";

    boolean sync() default false;

    long ttl();
}

这里使用@Inherited特性，使spring能解析到我们的CacheableTtl注解。

2. TtlRedisCacheManager

TtlRedisCacheManager extends RedisCacheManager
private final RedisCacheConfiguration defaultCacheConfiguration;

    public TtlRedisCacheManager(RedisCacheWriter cacheWriter,
        RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter, defaultCacheConfiguration);
        Objects.requireNonNull(defaultCacheConfiguration);
        this.defaultCacheConfiguration = defaultCacheConfiguration;
    }

    public TtlRedisCacheManager(RedisCacheWriter cacheWriter,
        RedisCacheConfiguration defaultCacheConfiguration,
        String... initialCacheNames) {
        super(cacheWriter, defaultCacheConfiguration, initialCacheNames);
        Objects.requireNonNull(defaultCacheConfiguration);
        this.defaultCacheConfiguration = defaultCacheConfiguration;
    }

    public TtlRedisCacheManager(RedisCacheWriter cacheWriter,
        RedisCacheConfiguration defaultCacheConfiguration,
        boolean allowInFlightCacheCreation, String... initialCacheNames) {
        super(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation, initialCacheNames);
        Objects.requireNonNull(defaultCacheConfiguration);
        this.defaultCacheConfiguration = defaultCacheConfiguration;
    }

    public TtlRedisCacheManager(RedisCacheWriter cacheWriter,
        RedisCacheConfiguration defaultCacheConfiguration,
        Map<String, RedisCacheConfiguration> initialCacheConfigurations) {
        super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations);
        Objects.requireNonNull(defaultCacheConfiguration);
        this.defaultCacheConfiguration = defaultCacheConfiguration;
    }

    public TtlRedisCacheManager(RedisCacheWriter cacheWriter,
        RedisCacheConfiguration defaultCacheConfiguration,
        Map<String, RedisCacheConfiguration> initialCacheConfigurations,
        boolean allowInFlightCacheCreation) {
        super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations, allowInFlightCacheCreation);
        Objects.requireNonNull(defaultCacheConfiguration);
        this.defaultCacheConfiguration = defaultCacheConfiguration;
    }

    /**
     * 这个方法尤为重要，加入自定义RedisCacheManager的原因就是RedisCacheManager
     * 的createCache为protected的，导致自定义的CacheResolver无法调用，因此重写此方法，
     * 使其在CacheResolver可以被调用
     *
     * @param cacheName
     * @param config
     * @return
     */
    public RedisCache createCache(String cacheName, RedisCacheConfiguration config) {
        return super.createRedisCache(cacheName, config);
    }

    public RedisCacheConfiguration getCacheConfigurationCopy() {
        return RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(defaultCacheConfiguration.getTtl())
            .serializeKeysWith(defaultCacheConfiguration.getKeySerializationPair())
            .serializeValuesWith(defaultCacheConfiguration.getValueSerializationPair())
            .withConversionService(defaultCacheConfiguration.getConversionService())
            .computePrefixWith(cacheName -> defaultCacheConfiguration.getKeyPrefixFor(cacheName));
    }

3. TtlCacheResolver

TtlCacheResolver extends SimpleCacheResolver

    @Override
    public Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context) {
        Collection<String> cacheNames = this.getCacheNames(context);
        if (cacheNames == null) {
            return Collections.emptyList();
        } else {
            Collection<Cache> result = new ArrayList(cacheNames.size());
            Iterator iterator = cacheNames.iterator();

            while (iterator.hasNext()) {
                String cacheName = (String) iterator.next();
                Cache cache = getCacheFromMem(context, cacheName);
                if (cache == null) {
                    cache = this.getCacheManager().getCache(cacheName);
                }
                if (cache == null) {
                    throw new IllegalArgumentException(
                        "Cannot find cache named '" + cacheName + "' for " + context.getOperation());
                }
                result.add(cache);
            }

            return result;
        }
    }

    private Cache getCacheFromMem(CacheOperationInvocationContext<?> context, String cacheName) {
        Method method = context.getMethod();
        CacheableTtl cacheableTtl = method.getAnnotation(CacheableTtl.class);
        if (cacheableTtl != null && cacheableTtl.ttl() > 0) {
            long ttl = cacheableTtl.ttl();
            String cacheKey = cacheName + "-" + ttl;
            RedisCache cache = cacheMap.get(cacheKey);
            this.clearIfOverload();
            if (cache == null) {
                cache = this.createRedisCache(cacheName, ttl);
                if (cache != null) {
                    cacheMap.putIfAbsent(cacheKey, cache);
                }
            }
            return cache;
        }
        return null;
    }

    private RedisCache createRedisCache(String cacheName, Long ttl) {
        CacheManager cacheManager = super.getCacheManager();
        if (cacheManager instanceof TtlRedisCacheManager) {
            TtlRedisCacheManager manager = (TtlRedisCacheManager) cacheManager;
            RedisCacheConfiguration configuration = manager.getCacheConfigurationCopy();
            return manager.createCache(cacheName, configuration.entryTtl(Duration.ofSeconds(ttl)));
        }
        return null;
    }

    private void clearIfOverload() {
        if (cacheMap.size() > MAX_CACHE_SIZE) {
            cacheMap.clear();
        }
    }

getCacheFromMem主要做的事情就是：通过反射获取ttl, 并动态生成一个RedisCacheConfiguration注入到RedisCache实例当中，这样RedisCache实例就是我们声明式注解配置的ttl时间了。

3. 配合Spring Boot

CacheableTtlAutoConfiguration

我们可以封装成一个spring boot starter jar包，实现自动化配置

@Configuration
public class CacheableTtlAutoConfiguration {

    @Bean("redisSerializer")
    @ConditionalOnMissingBean
    public RedisSerializer redisSerializer() {
        return new GenericFastJsonRedisSerializer();
    }

    @Bean("defaultRedisCacheConfiguration")
    @ConditionalOnMissingBean
    public RedisCacheConfiguration defaultRedisCacheConfiguration(RedisSerializer redisSerializer) {
        return RedisCacheConfiguration.defaultCacheConfig()
            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer));
    }

    @Bean
    @ConditionalOnMissingBean
    public RedisCacheWriter redisCacheWriter(RedisConnectionFactory redisConnectionFactory) {
        return RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
    }

    @Bean("redisCacheConfigurationMap")
    @ConditionalOnMissingBean
    public Map<String, RedisCacheConfiguration> redisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        return redisCacheConfigurationMap;
    }

    @Bean("ttlRedisCacheManager")
    @ConditionalOnMissingBean
    public TtlRedisCacheManager ttlRedisCacheManager(RedisCacheWriter redisCacheWriter,
        RedisCacheConfiguration defaultRedisCacheConfiguration,
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap) {
        return new TtlRedisCacheManager(
            redisCacheWriter,
            defaultRedisCacheConfiguration,
            redisCacheConfigurationMap);
    }

    @Bean("ttlCacheResolver")
    @ConditionalOnMissingBean
    public TtlCacheResolver ttlCacheResolver(TtlRedisCacheManager ttlRedisCacheManager) {
        return new TtlCacheResolver(ttlRedisCacheManager);
    }
}

附件

Gitee:https://gitee.com/liuyangrxy/carp.git

Young~^_^
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
优雅的缓存框架：SpringCache增强支持自定义过期时间TTL
weixin_42973338的博客
09-10 427
基于SpringCache缓存框架下动态设置TTL缓存过期时间
Spring(7) @Cacheable缓存注解
ACGkaka的博客
12-28 6816
Spring(7) @Cacheable缓存注解
SpringCache+redis实现缓存
最新发布
蓝天it（让亿万孩子在蓝天下共享优质教育）
05-19 953
Spring Cache是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能，大大简化我们在业务中操作缓存的代码。Spring Cache只是提供了一层抽象，底层可以切换不同的cache实现。具体就是通过CacheManager接口来统一不同的缓存技术。CacheManager是Spring提供的各种缓存技术抽象接口。
Springboot2.x AOP 实现 @Cacheable自定义TTL和自动刷新 防止缓存雪崩
Doub1's Blog
04-17 2042
Springboot2.x AOP 实现 Cacheable自定义TTL和自动刷新CacheManager个性化设置自定义每个缓存的TTL和自动刷新自己写TTL注解AOP实现使用 CacheManager个性化设置 可以根据需要，让某些key，默认TTL与基础设置不同，直接看代码 这不是重点，只是可以提前DIY一些东西 @Bean public CacheManager cach...
springboot缓存@Cacheable的使用，及设置过期时间
lpping90的专栏
06-03 1万+
1，
Spring声明式基于注解的缓存（3-精进篇）
lingbomanbu_lyl的博客
09-29 2326
在实例化时，我们可以指定key过期的entryTtl/*** 自定义CacheManager，具体配置参考{@link org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration}* @param redisConnectionFactory 自动配置会注入} }备注：这种方式有一个很明显的缺点，所有key都会共享配置，比如这里会设置所有key的过期时间都为1秒。Spring。
Spring Cache + Redis 实现缓存
weixin_51476582的博客
06-12 699
Spring Boot 缓存 几个重要概念&缓存注解 Cache 缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、ConcurrentMapCache等 CacheManager 缓存管理器，管理各种缓存（Cache）组件 @Cacheable 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存 @CacheEvict 清空缓存 @CachePut 保证方法被调用，又希望结果被缓存 @EnableCaching 开启基于注解的缓存
springboot增加注解缓存@Cacheable
zhy的博客
08-17 2680
业务层使用： @Cacheable(value = "dictionary#1800", key = "#root.targetClass.simpleName +':'+ #root.methodName +':'+ #code") public Object findByCode(String code) { //业务 } 配置： import org...
史上最全面的Spring-Boot-Cache使用与整合
weixin_34198797的博客
07-15 3365
一：Spring缓存抽象 Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术；并支持使用JCache（JSR-107）注解简化我们开发； Cache接口为缓存的组件规范定义，包含缓存的各种操作集合； Ca...
使用spring自带的Cacheable注解处理Redis缓存
一屁小肥羊的专栏
09-13 1万+
本文不为Redis安装和使用范畴,有兴趣的朋友可以联系我,也可以自行百度:Redis安装和使用 Redis实现缓存添加,更新和删除的方法有很多. 1:较为笨拙的方法,也是最稳定的方法,也是一些自动化缓存更新的原理但是代码就多了点,在需要用到缓存的地方,去判断, 先从缓存取,取不到,去数据库查找,找到返回该数据,并写入缓存 2:使用aop的思想,在需要用到缓存的地方左...
Spring Cache 注解用法
舒哥的blog
01-12 7376
缓存策略 Eviction policy 移除策略，即如果缓存满了，从缓存中移除数据的策略；常见的有LFU、LRU、FIFO： FIFO（First In First Out）：先进先出算法，即先放入缓存的先被移除； LRU（Least Recently Used）：最久未使用算法，使用时间距离现在最久的那个被移除； LFU（Least Frequently Used）：最近最少使用算法
java cache过期_Spring Cache 实现失效时间设置
weixin_39636609的博客
02-23 1861
Spring cache 注解式缓存用起来非常方便，但是却没有ttl 失效时间设置。这就很让人头疼了。虽然在@Cacheable 没有ttl注解时间的设置，但是我发现在注解上有cacheManage 的参数设置。然后查看源码:public class RedisCacheConfiguration {private final Duration ttl;private final boolean...
FixedTTLCache实现
binling的专栏
10-28 587
所有item的TTL都一样，比如所有的http session的过期时间默认30分钟，idle超过30分钟就失效。相对的是每个item指定TTL的缓存。 实现和LRU类似，都是map + list，不同的是触发机制不是容量满，而是idle时间。专门一个线程check，这里也利用了队列能维护先后顺序的性质，对头是最老的，如果队头都没过期，其他的都不可能过期，而且check线程会wait这个时间差再
springboot2+spring cache+redis缓存
LOOPY_Y的博客
11-14 1220
@JsonIgnore1 项目场景2 问题描述3 解决过程4 nginx的root、alias指令区别4.1 区别对照4.2 示例 参考文章： https://zhuanlan.zhihu.com/p/131009164 https://www.nginx.cn/4658.html 1 项目场景 配置nginx访问静态资源文件。 2 问题描述 在测试环境配置完成后访问正常，在另一个环境配置后访问失败 3 解决过程 对比了一下两个环境nginx的配置信息，发现指定文件路径的指令不太一样，测试环境是a
Redis TTL命令
极品小肥羊的博客
07-25 1万+
Redis TTL命令用于获取键到期的剩余时间(秒)。 返回值 以毫秒为单位的整数值TTL或负值 TTL以毫秒为单位。 -1, 如果key没有到期超时。 -2, 如果键不存在。 语法 Redis TTL命令的基本语法如下所示： redis 127.0.0.1:6379> TTL KEY_NAME 例子
lru cache和ttl cache缓存写法，装饰器写法
qq_41509057的博客
04-23 1072
lru cache 缓存 def lru_cache(maxsize): cache = {} keys = [] def inner(func): def wrapper(*arg, **kwd): key = arg for item in kwd.items(): key += item if key in keys: keys
SpringBoot 2.x 整合 redis 做缓存并对每个缓存空间设置过期时间
qq_32814555的博客
06-28 8103
点击打开链接
@Cacheable设置过期时间
热门推荐
weixin_41860719的博客
06-10 1万+
@Cacheable设置过期时间
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值