SpringCache自定义过期时间及自动刷新
Posted 半天想不出昵称的斌
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了SpringCache自定义过期时间及自动刷新相关的知识,希望对你有一定的参考价值。
背景前提
阅读说明(十分重要)
对于Cache和SpringCache原理不太清楚的朋友,可以看我之前写的文章:Springboot中的缓存Cache和CacheManager原理介绍
可能有人会问为什么要缓存自动更新,我的理解是这样的:
假设缓存没有自动更新,那么当某一时刻过期了,系统重新计算获得缓存值的时候,这段时间的请求都得处于阻塞状态(或者直接给客户端返回失败,稍后重试)
这是不友好的,并且获得新缓存可能还没这么快,需要的时间越久,就越多用户获得差劲的体验,所以需要缓存自动更新
言归正传
能关注SpringCache,想了解过期实现和自动刷新的朋友,肯定有一定Java基础的,所以先了解我的思想,达成共识比直接看代码重要许多
你可能只需要我里面其中一个点而不是原搬照抄
我在实现过程遇到三大坑,先跟大家说下,兴许对你有帮助
坑一:自己造轮子
对SpringCache不怎么了解,直接百度缓存看到Redis后,就直接使用RedisTemple开始工具类的搭建(说白了就是自己撸一个增删查改功能的类,然后到处使用)
自己造轮子不仅重复了前人的工作,还做的没别人好... ,不让Spring帮忙管理就享受不到@Cacheable这些注解等一系列福利
对于管理,扩展,使用方便程度都不友好
结论:不能放弃别人写好的工具类(我用Redis做缓存,那么对应的就是RedisCache、RedisManager和SpringCache注解等一套要用上)
坑二:Cache的设计思想不对(最重要)
在了解了SpringCache后,我十分愉快的用上了RedisCache和RedisCacheManager,真的十分简单方便
但跟看这边文章的你们一样,不满足于此,想着如果一个频繁访问缓存,到时候过期一个或多个过期了,是不是就缓存雪崩了
可当时我纠结的粗粒度太细了:
我希望每个缓存里的每个数据都能控制过期时间
比如:CacheName为systemCache的Cache里有a,b两个数据,我希望a数据5分钟过期,b数据10分钟过期
结论:这是完全没必要的,我们控制过期时间,应该以Cache为最小单位,而不是以里面单个数据
实际中缓存数据是不需要精细到单独处理的,都是一组一组的,如这几个数据在30分钟内失效,那一组数据是在
1小时内失效等等
例如:systemCache的ttl(详见1.2的CacheConfig)设置为半小时,那么它里面所有的数据都为离存入时间间隔30分钟后过期
我希望数据能纯自动刷新(不需要外在的触发条件)
比如:跑个线程,隔断时间自动扫描数据,进行纯自动更新
结论:目前没办法实现缓存纯自动更新,必须要使用到该缓存拿数据才能触发更新检查
纯自动更新没有意义,假设一个数据放了半小时没人访问要过期了,那就过期吧
因为缓存前提是一段时间频繁访问的数据,如果都没人访问了,就不能称之为缓存
不然就是一个系统长期存在的动态变量,不适用于缓存
坑三:对@Cacheble的理解太浅
于是想缓存数据能在过期前的几分钟里自动刷新一下,那就很不错
着手实现就想拦截@Cacheble,因为我们把@Cacheble放在访问数据库的方法上,那么做个切面针对@Cacheble,在调用目标方法前判断一下储存的时间,快过期就重新取数据,不过期就不执行方法不就行了(不得不吐槽SpringCache对于过期设计有点考虑不足,封装的死死的,没向外暴露任何接口)
结果@Cacheble的代理类的逻辑是这样的:
发现系统需要此缓存数据 -> 自动尝试get方法获得缓存 -> 存在则返回
发现系统需要此缓存数据 -> 自动尝试get方法获得缓存 -> 不存在才调用目标方法
所以切面切@Cacheble压根没用,别人是在缓存失效的情况下才进入目标方法,这个过程才会被你写的切面切!!
我的设计
网上有个比较好的自动刷新的实现(参考):https://www.jianshu.com/p/275cb42080d9 但是不太喜欢
原因主要是不喜欢在@Cacheable里面的变量做文章(会对原来已有的注解有影响),关键还会覆盖,以第一个
@Cacheble写的时间为准,代码开发一段时间,天知道这个Cache哪个地方第一次指定
在这阐述下设计逻辑,大家看看下面内容不懂的时候可以回来这里看看
思路:对@Cacheable进行切入,在此期间将缓存相关的数据通通保存到一个地方
设计一个新的Cache,在get方法标记上新的注解@UpdateCache
对@UpdateCache进行切入,在此期间检查缓存是否将要过期,如果是,则更新缓存
GitHub地址:https://github.com/NiceJason/top-housekeeper
[中括号为涉及到的类]
涉及到如下8个类:
系统更新缓存的注解:
@UpdataCache:是缓存自动更新的标志,在Cache的get方法上表明,然后每次get数据时就会在切面判断是否快要过期
系统缓存管理器的接口:
I_SystemCacheMgr:此接口继承CacheManager,自定义缓存管理器需要实现此接口,需要实现里面一些更新缓存相关的方法
Spring中的Cache接口和CacheManager的实现:
RedisCacheEnhance:继承RedisCache,对其增强
RedisCacheMgr:继承RedisManager,对其增强(说白了就是增加些自己的方法,改写方法)
系统缓存管理器的注册类(向Spring注册):
CacheConfig:Spring初始化时,向其注册管理类,里面写自己实现的注册逻辑
目标方法记载类:
CacheInvocation:为了能自动更新,那目标获得数据的方法要记录下来,才能要调用的时候主动调用
系统更新缓存的线程:
UpdateDataTask:实现Callable接口的线程类,负责数据更新时执行目标方法,写入缓存
系统缓存管理:
SystemCacheMgr:缓存数据存储信息在此保存,也负责管理I_SystemCacheMgr的实现类,进行更新操作的调用
系统缓存AOP切面:
CacheAspect:对@Cacheable拦截,进行获取数据的方法注册。对@UpdateCache注解进行拦截,进行自动更新判
断
接下来将依次展示代码,说下关键点
代码展示
@UpdataCache
该注解主要是对Cache的get方法进行标记,然后用AOP切面进行更新检查
1 /** 2 * @author NiceBin 3 * @description: 缓存更新接口,在Cache实现类的get方法上注解即可 4 * @date 2019/11/18 8:56 5 */ 6 @Target({ElementType.METHOD, ElementType.TYPE}) 7 @Retention(RetentionPolicy.RUNTIME) 8 @Inherited 9 public @interface UpdateCache { 10 }
I_SystemCacheMgr
主要是规定了系统缓存管理器应该有的行为
1 /** 2 * 本系统的缓存接口,SystemCacheMgr统一保存数据记录的时间和控制缓存自动刷新流程 3 * 4 * 为了实现数据快过期前的自动刷新,需要以下操作: 5 * 1.实现此接口 6 * 如果用如RedisCacheManager这种写好的类,需要子类继承再实现此接口 7 * 如果Cache是CacheManager内部生成的,还需要重写createCache方法 8 * 使生成的Cache走一遍Spring初始化Bean的过程,交给Spring管理 9 * 这里主要为了Spring帮忙生成代理类,让注解生效 10 * 2.实现了 {@link Cache} 接口的类在get方法上加上注解 {@link UpdateCache} 才有更新效果,所以如果要用如RedisCache 11 * 这种写好的类,需要子类继承,并重写get方法 12 * 然后在get方法上加@UpdateCache 13 */ 14 public interface I_SystemCacheMgr extends CacheManager{ 15 /** 16 * 该数据是否过期 17 * true为已经过期 18 * @param cacheName 缓存名字 19 * @param id 数据id 20 * @param saveTime 该缓存内该数据的存储时间 21 * @return 22 * @throws Exception 23 */ 24 boolean isApproachExpire(String cacheName, Object id, Timestamp saveTime) throws Exception; 25 26 /** 27 * 删除指定Cache里的指定数据 28 * @param cacheName 29 * @param id 30 * @throws Exception 31 */ 32 void remove(String cacheName, Object id) throws Exception; 33 34 /** 35 * 清除所有缓存内容 36 * @throws Exception 37 */ 38 void clearAll() throws Exception; 39 40 /** 41 * 获得所有的Cache 42 * @return 43 */ 44 ConcurrentMap<String, Cache> getAllCaches(); 45 }
RedisCacheEnhance
写上@UpdateCache后,才能被AOP切入
1 /** 2 * @author NiceBin 3 * @description: 增强RedisCache 4 * 为了能在get方法写上@Update注解,实现自动刷新 5 * @date 2019/7/4 13:24 6 */ 7 public class RedisCacheEnhance extends RedisCache { 8 9 /** 10 * Create new {@link RedisCacheEnhance}. 11 * 12 * @param name must not be {@literal null}. 13 * @param cacheWriter must not be {@literal null}. 14 * @param cacheConfig must not be {@literal null}. 15 */ 16 protected RedisCacheEnhance(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig) { 17 super(name, cacheWriter, cacheConfig); 18 } 19 20 @UpdateCache 21 public ValueWrapper get(Object key){ 22 System.out.println("进入get方法"); 23 return super.get(key); 24 } 25 26 @UpdateCache 27 public <T> T get(Object key, @Nullable Class<T> type){ 28 return super.get(key,type); 29 } 30 31 @UpdateCache 32 public <T> T get(Object key, Callable<T> valueLoader){ 33 return super.get(key,valueLoader); 34 }
RedisCacheMgr
RedisManager的增强类,这里涉及的知识点比较多,跟大家简单聊聊
1 /** 2 * @author NiceBin 3 * @description: RedisCacheManager增强类,为了实现本系统缓存自动更新功能 4 * @date 2019/11/25 9:07 5 */ 6 public class RedisCacheMgr extends RedisCacheManager implements I_SystemCacheMgr { 7 8 private final RedisCacheWriter cacheWriter; 9 private ConcurrentMap<String, Cache> caches = new ConcurrentHashMap<>(); 10 11 private DefaultListableBeanFactory defaultListableBeanFactory; 12 13 public RedisCacheMgr(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations, boolean allowInFlightCacheCreation) { 14 super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations, allowInFlightCacheCreation); 15 this.cacheWriter = cacheWriter; 16 17 } 18 19 /** 20 * 重写createRedisCache的方法,生成自己定义的Cache 21 * 这里主要要让Spring来生成代理Cache,不然在Cache上的注解是无效的 22 * @param name 23 * @param cacheConfig 24 * @return 25 */ 26 @Override 27 protected RedisCacheEnhance createRedisCache(String name, @Nullable RedisCacheConfiguration cacheConfig) { 28 //利用Spring生成代理Cache 29 BeanDefinition beanDefinition = new RootBeanDefinition(RedisCacheEnhance.class); 30 //因为只有有参构造方法,所以要添加参数 31 ConstructorArgumentValues constructorArgumentValues = beanDefinition.getConstructorArgumentValues(); 32 constructorArgumentValues.addIndexedArgumentValue(0,name); 33 constructorArgumentValues.addIndexedArgumentValue(1,cacheWriter); 34 constructorArgumentValues.addIndexedArgumentValue(2,cacheConfig); 35 36 //如果有属性需要设置,还能这样做,不过需要有对应属性名的set方法 37 //definition.getPropertyValues().add("propertyName", beanDefinition.getBeanClassName()); 38 39 ApplicationContext applicationContext = SystemContext.getSystemContext() 40 .getApplicationContext(); 41 //需要这样获取的DefaultListableBeanFactory类才能走一遍完整的Bean初始化流程!! 42 //像applicationContext.getBean(DefaultListableBeanFactory.class)都不好使!! 43 DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)applicationContext.getAutowireCapableBeanFactory(); 44 defaultListableBeanFactory.registerBeanDefinition(name,beanDefinition); 45 46 RedisCacheEnhance redisCacheEnhance = (RedisCacheEnhance)applicationContext.getBean(name); 47 caches.put(name, redisCacheEnhance); 48 return redisCacheEnhance; 49 } 50 51 /** 52 * 过期规则为:缓存有效时间-(目前时间-记录时间)<= 随机时间 53 * 随机时间是防止同一时刻过期时间太多,造成缓存雪崩,在SystemStaticValue中缓存项里配置 54 * true为将要过期(可以刷新了) 55 * 56 * @param cacheName 缓存名称 57 * @param id 数据id 58 * @param saveTime 储存时间 59 * @return 60 */ 61 @Override 62 public boolean isApproachExpire(String cacheName, Object id, Timestamp saveTime) throws NoSuchAlgorithmException { 63 long ttl = -1; 64 65 RedisCacheConfiguration configuration = this.getCacheConfigurations().get(cacheName); 66 ttl = configuration.getTtl().getSeconds(); 67 68 if (ttl != -1 && saveTime!=null) { 69 int random = Tool.getSecureRandom(SystemStaticValue.CACHE_MIN_EXPIRE, SystemStaticValue.CACHE_MAX_EXPIRE); 70 Date date = new Date(); 71 long theNowTime = date.getTime() / 1000; 72 long theSaveTime = saveTime.getTime() / 1000; 73 if (ttl - (theNowTime - theSaveTime) <= random) { 74 return true; 75 } 76 } 77 return false; 78 } 79 80 @Override 81 public void remove(String cacheName, Object id) throws Exception { 82 Cache cache = this.getCache(cacheName); 83 cache.evict(id); 84 } 85 86 87 /** 88 * 清除所有缓存内容 89 * 90 * @throws Exception 91 */ 92 @Override 93 public void clearAll() throws Exception { 94 Collection<String> cacheNames = this.getCacheNames(); 95 Iterator<String> iterator = cacheNames.iterator(); 96 while (iterator.hasNext()) { 97 String cacheName = iterator.next(); 98 Cache redisCache = this.getCache(cacheName); 99 redisCache.clear(); 100 } 101 } 102 103 @Override 104 public ConcurrentMap<String, Cache> getAllCaches() { 105 return caches; 106 } 107 }
知识点:如何阅读源码来帮助自己注册目标类
这是个很关键的点,我们想继承RedisManager,那构造函数肯定要super父类的构造函数(而且RedisManager看设计并不太推荐让我们继承它的)
所以父类构造函数的参数,我们怎么获取,怎么模拟就是关键性问题
第一步:百度,继承RedisManager怎么写
不过这类不热门的问题,大多数没完美答案(就是能针对你的问题),可是有很多擦边答案可以给你借鉴,我获取到这样的信息
1 RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory) 2 .cacheDefaults(defaultCacheConfig) // 默认配置(强烈建议配置上)。 比如动态创建出来的都会走此默认配置 3 .withInitialCacheConfigurations(initialCacheConfiguration) // 不同cache的个性化配置 4 .build();
如果我们想配个性化的RedisCacheManager,可以这样创建
可以发现,这个build()方法就是我们的入手点,我们跟进去看看它的参数有什么
1 /** 2 * Create new instance of {@link RedisCacheManager} with configuration options applied. 3 * 4 * @return new instance of {@link RedisCacheManager}. 5 */ 6 public RedisCacheManager build() { 7 8 RedisCacheManager cm = new RedisCacheManager(cacheWriter, defaultCacheConfiguration, initialCaches, 9 allowInFlightCacheCreation); 10 11 cm.setTransactionAware(enableTransactions); 12 13 return cm; 14 }
继续跟踪看RedisCacheManager的方法
1 public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, 2 Map<String, RedisCacheConfiguration> initialCacheConfigurations, boolean allowInFlightCacheCreation) { 3 4 this(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation); 5 6 Assert.notNull(initialCacheConfigurations, "InitialCacheConfigurations must not be null!"); 7 8 this.initialCacheConfiguration.putAll(initialCacheConfigurations); 9 }
这里可发现defaultCacheConfiguration和initialCacheConfigurations是我们传入的参数,allowInFlightCacheCreation就是简单的布尔值,能不能动态创建Cache而已
所以我们想办法得到RedisCacheWriter这就大功告成了呀,怎么找,Ctrl+F,搜索变量,如图:
一个个查找,看cacheWriter是哪里赋值进来的,最后发现
1 private RedisCacheManagerBuilder(RedisCacheWriter cacheWriter) { 2 this.cacheWriter = cacheWriter; 3 }
然后继续搜索RedisCacheManagerBuilder哪里被调用:
重复以上步骤,有变量就搜索变量,有方法就搜索调用的地方,最后发现
1 public static RedisCacheManagerBuilder fromConnectionFactory(RedisConnectionFactory connectionFactory) { 2 3 Assert.notNull(connectionFactory, "ConnectionFactory must not be null!"); 4 5 return builder(new DefaultRedisCacheWriter(connectionFactory)); 6 }
看第5行,我只要有了RedisConnectionFactory,直接new一个就行(事实真的如此吗),进去后发现
这个类不是public,外部是不允许new的,兄弟,还得继续跟代码呀,这个类不是public,所以再看这个类已经无意义了,我们发现它实现了RedisCacheWriter接口,应该从这入手看看
1 public interface RedisCacheWriter { 2 3 /** 4 * Create new {@link RedisCacheWriter} without locking behavior. 5 * 6 * @param connectionFactory must not be {@literal null}. 7 * @return new instance of {@link DefaultRedisCacheWriter}. 8 */ 9 static RedisCacheWriter nonLockingRedisCacheWriter(RedisConnectionFactory connectionFactory) { 10 11 Assert.notNull(connectionFactory, "ConnectionFactory must not be null!"); 12 13 return new DefaultRedisCacheWriter(connectionFactory); 14 } 15 16 /** 17 * Create new {@link RedisCacheWriter} with locking behavior. 18 * 19 * @param connectionFactory must not be {@literal null}. 20 * @return new instance of {@link DefaultRedisCacheWriter}. 21 */ 22 static RedisCacheWriter lockingRedisCacheWriter(RedisConnectionFactory connectionFactory) { 23 24 Assert.notNull(connectionFactory, "ConnectionFactory must not be null!"); 25 26 return new DefaultRedisCacheWriter(connectionFactory, Duration.ofMillis(50)); 27 }
到这问题就彻底解决了,接口定义了两个获取RedisCacheWriter的方法,只需要传参数RedisConnectionFactory即可,而这个类Spring会自动配置(具体Spring中如何配置Redis自行百度,十分简单)
至此super父类所需要的参数,我们都能自己构造了
这个知识点主要是想让大家遇到问题有这个最基本的解决的思路,迎难而上~
知识点:用代码动态向Spring注册Bean
RedisCacheMgr的createRedisCache方法中看到,我们生成的Cache需要像Spring注册,这是为什么呢
因为我们要想@UpdateCache注解,那必须得生成代理类,交给Spring管理,否则注解无效的
具体注册我也没深入研究(今后会写一篇此博文),不过要按照这种方式注册才有效
1 ApplicationContext applicationContext = SystemContext.getSystemContext() 2 .getApplicationContext(); 3 //需要这样获取的DefaultListableBeanFactory类才能走一遍完整的Bean初始化流程!! 4 //像applicationContext.getBean(DefaultListableBeanFactory.class)都不好使!! 5 DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)applicationContext.getAutowireCapableBeanFactory(); 6 defaultListableBeanFactory.registerBeanDefinition(name,beanDefinition);
CacheConfig
这个类是为了加载自定义的CacheManager
1 /** 2 * @author NiceBin 3 * @description: CacheManager初始化 4 * 目前系统只用一个Manager,使用RedisCacheManager 5 * 根据SystemStaticValue中的SystemCache枚举内容进行Cache的注册 6 * 配置启动前需要DefaultListableBeanFactory.class先加载完成 7 * 不然CacheManager或者Cache想用的时候会报错 8 * @date 2019/11/13 17:02 9 */ 10 @Configuration 11 @Import(DefaultListableBeanFactory.class) 12 public class CacheConfig { 13 14 @Autowired 15 RedisConnectionFactory redisConnectionFactory; 16 17 @Bean 18 public RedisCacheMgr cacheManager() { 19 20 //创建Json自定义序列化器 21 FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class); 22 //包装成SerializationPair类型 23 RedisSerializationContext.SerializationPair serializationPair = RedisSerializationContext.SerializationPair.fromSerializer(fastJsonRedisSerializer); 24 25 RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig() 26 .entryTtl(Duration.ofDays(1)) 27 .computePrefixWith(cacheName -> "Cache"+cacheName); 28 // 针对不同cacheName,设置不同的过期时间,用了双括号初始化方法~ 29 Map<String, RedisCacheConfiguration> initialCacheConfiguration = new HashMap<String, RedisCacheConfiguration>() {{ 30 SystemStaticValue.SystemCache[] systemCaches = SystemStaticValue.SystemCache.values(); 31 Arrays.asList(systemCaches).forEach((systemCache)-> 32 put(systemCache.getCacheName(),RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(systemCache.getSurviveTime())) 33 .serializeValuesWith(serializationPair))); 34 }}; 35 RedisCacheMgr redisCacheMgr = new RedisCacheMgr(RedisCacheWriter.lockingRedisCacheWriter(redisConnectionFactory),defaultCacheConfig,initialCacheConfiguration,true); 36 37 //设置白名单---非常重要******** 38 /* 39 使用fastjson的时候:序列化时将class信息写入,反解析的时候, 40 fastjson默认情况下会开启autoType的检查,相当于一个白名单检查, 41 如果序列化信息中的类路径不在autoType中,autoType会默认开启 42 反解析就会报com.alibaba.fastjson.JSONException: autoType is not support的异常 43 */ 44 ParserConfig.getGlobalInstance().addAccept("com.tophousekeeper"); 45 return redisCacheMgr; 46 } 47 }
自定义JSON序列化类
1 /* 2 要实现对象的缓存,定义自己的序列化和反序列化器。使用阿里的fastjson来实现的方便多。 3 */ 4 public class FastJsonRedisSerializer<T> implements RedisSerializer<T> { 5 private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8"); 6 private Class<T> clazz; 7 8 ASP.NET Core Identity Server 3自定义修改Token过期刷新时间CoolViewPager:即刻刷新,自定义边缘效果颜色,双向自动循环,内置垂直切换效果,想要的都在