半天想不出昵称的斌
半天想不出昵称的斌

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哪个地方第一次指定

在这阐述下设计逻辑，大家看看下面内容不懂的时候可以回来这里看看

 [中括号为涉及到的类]

 SpringCache自定义过期时间及自动刷新_第1张图片

涉及到如下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 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 get(Object key, @Nullable Class type){
28         return super.get(key,type);
29     }
30 
31     @UpdateCache
32     public  T get(Object key, Callable 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 caches = new ConcurrentHashMap<>();
 10 
 11     private DefaultListableBeanFactory defaultListableBeanFactory;
 12 
 13     public RedisCacheMgr(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map 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 cacheNames = this.getCacheNames();
 95         Iterator 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 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 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，搜索变量，如图：SpringCache自定义过期时间及自动刷新_第2张图片

一个个查找，看cacheWriter是哪里赋值进来的，最后发现

1 private RedisCacheManagerBuilder(RedisCacheWriter cacheWriter) {
2             this.cacheWriter = cacheWriter;
3         }

然后继续搜索RedisCacheManagerBuilder哪里被调用：

SpringCache自定义过期时间及自动刷新_第3张图片

 

 重复以上步骤，有变量就搜索变量，有方法就搜索调用的地方，最后发现

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一个就行（事实真的如此吗），进去后发现

SpringCache自定义过期时间及自动刷新_第4张图片

 

 这个类不是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 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 initialCacheConfiguration = new HashMap() {{
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 implements RedisSerializer {
 5     private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
 6     private Class clazz;
 7 
 8     public FastJsonRedisSerializer(Class clazz) {
 9         super();
10         this.clazz = clazz;
11     }
12 
13     @Override
14     public byte[] serialize(T t) throws SerializationException {
15         if (null == t) {
16             return new byte[0];
17         }
18         return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
19     }
20 
21     @Override
22     public T deserialize(byte[] bytes) throws SerializationException {
23         if (null == bytes || bytes.length <= 0) {
24             return null;
25         }
26         String str = new String(bytes, DEFAULT_CHARSET);
27         return (T) JSON.parseObject(str, clazz);
28     }
29 }
 
 
 
 
29-34行就是根据配置加载系统默认的几个缓存（涉及到Lambda表达式的循环知识）
 
 
 
  
 1 public class SystemStaticValue {
 2    .....
 3 //以下为缓存信息的配置(CACHE开头)--------------------------------------------------------
 4     //系统缓存名称及过期时间（秒）
 5     public enum SystemCache{
 6         //每日缓存,有效时间24小时
 7         DAY("dailyCache",60),
 8         //半日缓存，有效时间12小时
 9         HALF_DAY("halfDayCache",12*60*60),
10         //1小时缓存
11         ONE_HOUR("oneHour",1*60*60),
12         //半小时缓存
13         HALF_HOUR("halfHour",30*60);
14         private String cacheName;
15         private long surviveTime;
16 
17         SystemCache(String cacheName,long surviveTime){
18             this.cacheName = cacheName;
19             this.surviveTime = surviveTime;
20         }
21 
22         public String getCacheName() {
23             return cacheName;
24         }
25 
26         public void setCacheName(String cacheName) {
27             this.cacheName = cacheName;
28         }
29 
30         public long getSurviveTime() {
31             return surviveTime;
32         }
33 
34         public void setSurviveTime(long surviveTime) {
35             this.surviveTime = surviveTime;
36         }
37     }
38 }
 
 
 
 
知识点：@Import的重要性
 
 
在35行，创建RedisCacheMgr 的时候，就会调用里面的CreateCache的方法，里面会把Cache向Spring注册，需要用到DefaultListableBeanFactory类
 
 
所以在这里必须要@import，保证其已经加载，不然到时候创建会报类不存在
 
 
知识点：自定义序列化
 
 
因为不自定义成JSON格式序列化，那么存在Redis的内容不可直观的看出来（都是乱七八糟的东西，不知道存的对不对），所以在21-23行要换成JSON序列化格式
 
 
大家有兴趣可以看下这篇博文：https://blog.csdn.net/u010928589/article/details/84313987  这是一篇说Redis序列化如何自定义的思考过程，跟我上面的RedisCacheMgr实现思想类似
 
 
知识点：Lambda表达式
 
 
之前我也觉得不好用，不便于理解（其实就是我不会），然后这次下定决心弄懂，发现还是很不错的（真香），给大家推荐这篇博文理解：https://blog.csdn.net/qq_25955145/article/details/82670160
 
 
CacheInvocation：
 
 
这个类主要是为了记录调用的获得缓存数据的方法信息，以便于自动更新时主动调用（下面这个Task就用到了）
 
 
 
  
 1 /**
 2  * @author NiceBin
 3  * @description: 记录被 {@link Cacheable} 注解过的方法信息，为了主动更新缓存去调用对应方法
 4  * @date 2019/11/26 16:28
 5  */
 6 public class CacheInvocation {
 7     private Object key;
 8     private final Object targetBean;
 9     private final Method targetMethod;
10     private Object[] arguments;
11 
12     public CacheInvocation(Object key, Object targetBean, Method targetMethod, Object[] arguments) {
13         this.key = key;
14         this.targetBean = targetBean;
15         this.targetMethod = targetMethod;
16         //反射时不用检查修饰符，略微提高性能
17         this.targetMethod.setAccessible(true);
18         if (arguments != null && arguments.length != 0) {
19             this.arguments = Arrays.copyOf(arguments, arguments.length);
20         }
21     }
22 
23     public Object[] getArguments() {
24         return arguments;
25     }
26 
27     public Object getTargetBean() {
28         return targetBean;
29     }
30 
31     public Method getTargetMethod() {
32         return targetMethod;
33     }
34 
35     public Object getKey() {
36         return key;
37     }
38 }
 
 
 
 
UpdateDataTask：
 
 
这里就是主动更新数据的地方啦
 
 
 
  
 1 /**
 2  * @author NiceBin
 3  * @description: 刷新缓存某个数据的任务
 4  * @date 2019/11/29 15:29
 5  */
 6 public class UpdateDataTask implements Callable {
 7     //将要执行的方法信息
 8     private CacheInvocation cacheInvocation;
 9     //对应要操作的缓存
10     private Cache cache;
11     //对应要更新的数据id
12     private Object id;
13 
14     /**
15      * 初始化任务
16      * @param cacheInvocation
17      * @param cache
18      * @param id
19      */
20     public UpdateDataTask(CacheInvocation cacheInvocation,Cache cache,Object id){
21         this.cacheInvocation = cacheInvocation;
22         this.cache = cache;
23         this.id = id;
24     }
25 
26     @Override
27     public Object call() throws Exception {
28         if(cacheInvocation == null){
29             throw new SystemException(SystemStaticValue.CACHE_EXCEPTION_CODE,"更新数据线程方法信息不能为null");
30         }
31         cache.put(id,methodInvoke());
32         return true;
33     }
34 
35     /**
36      * 代理方法的调用
37      * @return
38      */
39     private Object methodInvoke() throws Exception{
40         MethodInvoker methodInvoker = new MethodInvoker();
41         methodInvoker.setArguments(cacheInvocation.getArguments());
42         methodInvoker.setTargetMethod(cacheInvocation.getTargetMethod().getName());
43         methodInvoker.setTargetObject(cacheInvocation.getTargetBean());
44         methodInvoker.prepare();
45         return methodInvoker.invoke();
46     }
47 }
 
 
 
 
SystemCacheMgr：
 
 
系统缓存管理的核心类，统筹全局
 
 
 
  
  1 /**
  2  * @author NiceBin
  3  * @description: 本系统的缓存管理器
  4  * 数据自动刷新功能，要配合 {@link UpdateCache}才能实现
  5  *
  6  * 目前没办法实现缓存纯自动更新，必须要使用到该缓存拿数据进行触发
  7  * 纯自动更新没有意义，假设一个数据放了半小时没人访问要过期了，那就过期吧
  8  * 因为缓存前提是一段时间频繁访问的数据，如果都没人访问了，就不能称之为缓存
  9  * 不然就是一个系统长期存在的动态变量，不适用于缓存
 10  * @date 2019/11/14 16:18
 11  */
 12 @Component
 13 public class SystemCacheMgr {
 14     //目前系统只考虑一个CacheManager
 15     //必须有一个I_SystemCache的实现类，多个实现类用@Primary注解，类似于Spring的缓存管理器
 16     @Autowired
 17     private I_SystemCacheMgr defaultCacheMgr;
 18     //系统的线程池类
 19     @Autowired
 20     private SystemThreadPool systemThreadPool;
 21     //所有缓存的所有数据记录Map
 22     //外部Map中，key为缓存名称，value为该缓存内的数据储存信息Map
 23     //内部Map中，key为数据的id，value为记录该数据的储存信息
 24     private ConcurrentHashMap> dataInfoMaps = new ConcurrentHashMap<>();
 25 
 26     /**
 27      * 储存信息内部类，用于记录
 28      * 获取要调用获取方法，因为加锁了线程才安全
 29      */
 30     class DataInfo {
 31         //记录该数据的时间
 32         private Timestamp saveTime;
 33         //获得此数据的方法信息
 34         private CacheInvocation cacheInvocation;
 35         //保证只有一个线程提前更新此数据
 36         private ReentrantLock lock;
 37 
 38         public synchronized void setSaveTime(Timestamp saveTime) {
 39             this.saveTime = saveTime;
 40         }
 41 
 42 
 43         public synchronized void setCacheInvocation(CacheInvocation cacheInvocation) {
 44             this.cacheInvocation = cacheInvocation;
 45         }
 46 
 47         public synchronized void setLock(ReentrantLock lock) {
 48             this.lock = lock;
 49         }
 50     }
 51 
 52     /**
 53      * 获得DataInfo类，如果为空则创建一个
 54      * @param cacheName
 55      * @param id
 56      * @return
 57      */
 58     private DataInfo getDataInfo(String cacheName, Object id) {
 59         ConcurrentHashMap dateInfoMap = dataInfoMaps.get((cacheName));
 60         DataInfo dataInfo;
 61         if (dateInfoMap == null) {
 62             //简单的锁住了，因为创建这个对象挺快的
 63             synchronized (this) {
 64                 //重新获取一次进行判断，因为dateInfoMap是局部变量，不能保证同步
 65                 dateInfoMap = dataInfoMaps.get((cacheName));
 66                 if (dateInfoMap == null) {
 67                     dateInfoMap = new ConcurrentHashMap<>();
 68                     dataInfo = new DataInfo();
 69                     dataInfo.setLock(new ReentrantLock(true));
 70                     dateInfoMap.put(id, dataInfo);
 71                     dataInfoMaps.put(cacheName, dateInfoMap);
 72                 }
 73             }
 74         }
 75         //这里不能用else，因为多线程同时进入if，后面进的dataInfo会是null
 76         dataInfo = dateInfoMap.get(id);
 77 
 78         return dataInfo;
 79     }
 80 
 81     /**
 82      * 为该数据放入缓存的时间记录
 83      *
 84      * @param id 数据id
 85      */
 86     public void recordDataSaveTime(String cacheName, Object id) {
 87         Date date = new Date();
 88         Timestamp nowtime = new Timestamp(date.getTime());
 89         DataInfo dataInfo = getDataInfo(cacheName, id);
 90         dataInfo.setSaveTime(nowtime);
 91     }
 92 
 93     /**
 94      * 记录获得此数据的方法信息，为了主动更新缓存时的调用
 95      *
 96      * @param cacheName    缓存名称
 97      * @param id           数据id
 98      * @param targetBean   目标类
 99      * @param targetMethod 目标方法
100      * @param arguments    目标方法的参数
101      */
102     public void recordCacheInvocation(String cacheName, String id, Object targetBean, Method targetMethod, Object[] arguments) {
103         DataInfo dataInfo = getDataInfo(cacheName, id);
104         CacheInvocation cacheInvocation = new CacheInvocation(id, targetBean, targetMethod, arguments);
105         //锁在这方法里面有
106         dataInfo.setCacheInvocation(cacheInvocation);
107     }
108 
109     /**
110      * 数据自动刷新功能，要配合 {@link UpdateCache}才能实现
111      * 原理：先判断数据是否过期，如果数据过期则从缓存删除。
112      *
113      * @param cacheName 缓存名称
114      * @param id        数据id
115      * @return
116      */
117     public void autoUpdate(String cacheName, Object id) throws Exception {
118         DataInfo dataInfo = getDataInfo(cacheName, id);
119         Cache cache = defaultCacheMgr.getCache(cacheName);
120 
121 
122         //如果没有保存的时间，说明该数据还从未载入过
123         if (dataInfo.saveTime == null) {
124             return;
125         }
126         if (defaultCacheMgr.isApproachExpire(cacheName, id, dataInfo.saveTime)) {
127             if (dataInfo.lock.tryLock()) {
128                 //获取锁后再次判断数据是否过期
129                 if (defaultCacheMgr.isApproachExpire(cacheName, id, dataInfo.saveTime)) {
130                     ThreadPoolExecutor threadPoolExecutor = systemThreadPool.getThreadPoolExecutor();
131                     UpdateDataTask updateDataTask = new UpdateDataTask(dataInfo.cacheInvocation, cache, id);
132                     FutureTask futureTask = new FutureTask(updateDataTask);
133 
134                     try {
135                         threadPoolExecutor.submit(futureTask);
136                         futureTask.get(1, TimeUnit.MINUTES);
137                         //如果上一步执行完成没报错，那么重新记录保存时间
138                         recordDataSaveTime(cacheName,id);
139                     } catch (TimeoutException ex) {
140                         //如果访问数据库超时
141                         throw new SystemException(SystemStaticValue.CACHE_EXCEPTION_CODE, "系统繁忙，稍后再试");
142                     } catch (RejectedExecutionException ex) {
143                         //如果被线程池拒绝了
144                         throw new SystemException(SystemStaticValue.CACHE_EXCEPTION_CODE, "系统繁忙，稍后再试");
145                     } finally {
146                         dataInfo.lock.unlock();
147                     }
148                 }
149             }
150         }
151     }
152 
153     /**
154      * 清除所有缓存内容
155      */
156     public void clearAll() throws Exception {
157         defaultCacheMgr.clearAll();
158     }
159 
160     //以下为Set和Get
161     public I_SystemCacheMgr getDefaultCacheMgr() {
162         return defaultCacheMgr;
163     }
164 
165     public void setDefaultCacheMgr(I_SystemCacheMgr defaultCacheMgr) {
166         this.defaultCacheMgr = defaultCacheMgr;
167     }
168 
169     public ConcurrentHashMap> getDataInfoMaps() {
170         return dataInfoMaps;
171     }
172 
173     public void setDataInfoMaps(ConcurrentHashMap> dataInfoMaps) {
174         this.dataInfoMaps = dataInfoMaps;
175     }
176 }
 
 
 
 
知识点：再次说下接口的重要性
 
 
17行直接让Spring注入实现了I_SystemCacheMgr的类，直接使用实现的方法而不用关心具体的实现细节（对于SystemCacheMgr类来说，你换了它的实现逻辑也丝毫不影响它原来的代码调用）
 
 
 CacheAspect
 
 
CacheAspect是注册和触发更新的核心类，Tool是用到的工具类的方法
 
 
 
  
 1 /**
 2  * @author NiceBin
 3  * @description: 处理缓存注解的地方：包括@UpdateCache，@Cacheable
 4  *
 5  * @date 2019/11/18 14:57
 6  */
 7 @Aspect
 8 @Component
 9 public class CacheAspect {
10     @Autowired
11     SystemCacheMgr systemCacheMgr;
12 
13     /**
14      * 数据注册到SystemCacheMgr
15      * 为数据自动更新做准备
16      */
17     @Before("@annotation(org.springframework.cache.annotation.Cacheable)")
18     public void registerCache(JoinPoint joinPoint){
19         System.out.println("拦截了@Cacheable");
20         //获取到该方法前的@Cacheable注解，来获取CacheName和key的信息
21         Method method = Tool.getSpecificMethod(joinPoint);
22         Cacheable cacleable = method.getAnnotation(Cacheable.class);
23         String[] cacheNames = cacleable.value()!=null?cacleable.value():cacleable.cacheNames();
24         String theKey = cacleable.key();
25         //取出来的字符串是'key'，需要去掉''
26         String key = theKey.substring(1,theKey.length()-1);
27         Arrays.stream(cacheNames).forEach(cacheName ->{
28             //记录数据保存时间
29             systemCacheMgr.recordDataSaveTime(cacheName,key);
30             //记录数据对应的方法信息
31             systemCacheMgr.recordCacheInvocation(cacheName,key,joinPoint.getTarget(),method,joinPoint.getArgs());
32         });
33     }
34 
35     /**
36      * 检测该键是否快过期了
37      * 如果快过期则进行自动更新
38      * @param joinPoint
39      */
40     @Before(value = "@annotation(com.tophousekeeper.system.annotation.UpdateCache)&&args(id)")
41     public void checkExpire(JoinPoint joinPoint,String id) throws Exception {
42         System.out.println("拦截了@UpdateCache");
43         RedisCacheEnhance redisCacheEnhance = (RedisCacheEnhance) joinPoint.getTarget();
44         systemCacheMgr.autoUpdate(redisCacheEnhance.getName(),id);
45     }
46 }
 
 
 
 
 
  
 1 public class Tool {
 2 
 3     /**
 4      * 获得代理类方法中真实的方法
 5      * 小知识：
 6      * ClassUtils.getMostSpecificMethod(Method method, Class targetClass)
 7      * 该方法是一个有趣的方法，他能从代理对象上的一个方法，找到真实对象上对应的方法。
 8      * 举个例子，MyComponent代理之后的对象上的someLogic方法，肯定是属于cglib代理之后的类上的method，
 9      * 使用这个method是没法去执行目标MyComponent的someLogic方法，
10      * 这种情况下，就可以使用getMostSpecificMethod，
11      * 找到真实对象上的someLogic方法，并执行真实方法
12      *
13      * BridgeMethodResolver.findBridgedMethod(Method bridgeMethod)
14      * 如果当前方法是一个泛型方法，则会找Class文件中实际实现的方法
15      * @param poxyMethod 代理的方法
16      * @param targetclass 真实的目标类
17      * @return
18      */
19     public static Method getSpecificMethod(Method poxyMethod,Class targetclass){
20         Method specificMethod = ClassUtils.getMostSpecificMethod(poxyMethod,targetclass);
21         specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
22         return specificMethod;
23     }
24 
25     /**
26      * 获得代理类方法中真实的方法
27      * 小知识：
28      * AopProxyUtils.ultimateTargetClass()
29      * 获取一个代理对象的最终对象类型
30      * @param joinPoint 切面的切点类
31      * @return
32      */
33     public static Method getSpecificMethod(JoinPoint joinPoint){
34         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
35         Method poxyMethod = methodSignature.getMethod();
36         Class targetClass = AopProxyUtils.ultimateTargetClass(joinPoint.getTarget());
37         return Tool.getSpecificMethod(poxyMethod,targetClass);
38     }
39 }
 
 
 
 
总结
 
 
 整套流程在磕磕碰碰中弄出来了，最后简单的用了jmeter测试了一下，感觉还不错
 
 
收获最多的不只是新知识的学习，更多是解决问题的能力，在碰到这种并不是很热门的问题，网上的答案没有完全针对你问的，只能从中获取你需要的小部分知识（就像现在你看这篇博文一样）
 
 
然后自己再尝试拼凑起来，有些问题百度无果之后，不妨自己跟跟源码，或者搜索XXX源码解析，看看流程，没准就有新发现
 
 
有什么想法或问题欢迎评论区留言，一起探讨~
 
 
尽我最大努力分享给大家，欢迎大家转载（写作不易，请标明出处）或者给我点个赞呀（右下角），谢啦！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(SpringCache自定义过期时间及自动刷新)

        

            

                
    
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动
                        李蕾1229

                        
    为促进我校教师专业发展，发挥骨干教师的引领带头作用，11月6日下午，我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动。图片发自App会议由教师发展处李蕾主任主持，首先，由范校长宣读新老教师结对名单及双方承担职责。随后，两位新调入教师陈玉萍、莫正杰分别和他们的师傅鲍元美、刘召彬老师签订了师徒结对协议书。图片发自App图片发自App师徒拥抱、握手。有了师傅就有了目标有了方向，相信两位新教师在师
    
                    
    • 
                    
  • 向内而求
                        陈陈_19b4

                        
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    
                    
    • 
                    
  • Python中os.environ基本介绍及使用方法
                        鹤冲天Pro
#Pythonpython服务器开发语言
                        
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
    
                    
    • 
                    
  • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    
                    
    • 
                    
  • 509. 斐波那契数(每日一题)
                        lzyprime

                        
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
    
                    
    • 
                    
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
    
                    
    • 
                    
  • 春季养肝正当时
                        dxn悟

                        
    重温快乐2023年2月4日立春。春天来了，春暖花开，小鸟欢唱，那在这样的季节我们如何养肝呢？自然界的春季对应中医五行的木，人体五脏肝属木，“木曰曲直”，是以树干曲曲直直地向上、向外伸长舒展的生发姿态，来形容具有生长、升发、条达、舒畅等特征的食物及现象。根据中医天人相应的理念，肝五行属木，喜条达，主疏泄，与春天相应，所以春天最适合养肝。养肝首先要少生气，因为肝喜条达恶抑郁。人体五志肝为怒，生气发怒最
    
                    
    • 
                    
  • python八股文面试题分享及解析(1)
                        Shawn________
python
                        
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
    
                    
    • 
                    
  • MYSQL面试系列-04
                        king01299
面试mysql面试
                        
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南）
                        诚芯微科技
社交电子
                        
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
    
                    
    • 
                    
  • Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
    
                    
    • 
                    
  • 高级 ECharts 技巧：自定义图表主题与样式
                        SnowMan1993
echarts信息可视化数据分析
                        
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
    
                    
    • 
                    
  • Rust基础知识
                        GRKF15
rust开发语言后端
                        
    1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
    
                    
    • 
                    
  • 简介Shell、zsh、bash
                        zhaosuningsn
Shellzshbashshelllinuxbash
                        
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
    
                    
    • 
                    
  • 舜公郑金锋书辛丑自剪扇面书法作品（四O六）
                        舜公郑金锋

                        
    辛丑小阳春，新自剪扇面400品，大多为各色撒金、撒银、描金、描银、水印、彩绘、荧光等亚粉、色宣纸，以及域外包装填充纸等；王一品长锋羊毫秃笔；一得阁云头艳墨、宿墨、水等。书体有甲骨文，金文(商周金文、春秋战国金文、中山王厝器金文、汉金文……)，楚简帛书，侯马盟书，温县盟书，小篆，果蝙书等，隶书(秦简、汉简帛书、汉碑……)，草书(章草、小草、大草……)，行书(行楷、行草)，楷书(魏碑及北朝墓志、隋朝墓
    
                    
    • 
                    
  • Xinference如何注册自定义模型
                        玩人工智能的辣条哥
人工智能AI大模型Xinference
                        
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
    
                    
    • 
                    
  • [Python] 数据结构 详解及代码
                        AIAdvocate
算法python数据结构链表
                        
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
    
                    
    • 
                    
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    
                    
    • 
                    
  • 一分钟学会刷牙，受用终生！
                        好易康

                        
    讲真，刷了十几二十年牙，没刷对过一次......来来来，划重点，更重要的是执行：①每天刷牙2次，②每次刷牙2~3分钟，③每3个月更换牙刷。最后，请使用正确的刷牙方法：巴氏（BASS）刷牙法undefined_腾讯视频视频来源ADA美国牙医协会巴氏刷牙法又称龈沟清扫法或水平颤动法。是由美国牙科协会推荐的一种有效去除龈缘附近及龈沟内菌斑的方法。刷牙不仅是刷牙齿，同时也要刷牙龈。因为口腔与细菌的战场就在
    
                    
    • 
                    
  • Python入门之Lesson2:Python基础语法
                        小熊同学哦
Python入门课程python开发语言算法数据结构青少年编程
                        
    目录前言一.介绍1.变量和数据类型2.常见运算符3.输入输出4.条件语句5.循环结构二.练习三.总结前言欢迎来到《Python入门》系列博客的第二课。在上一课中，我们了解了Python的安装及运行环境的配置。在这一课中，我们将深入学习Python的基础语法，这是编写Python代码的根基。通过本节内容的学习，你将掌握变量、数据类型、运算符、输入输出、条件语句等Python编程的基础知识。一.介绍1
    
                    
    • 
                    
  • 光盘文件系统 (iso9660) 格式解析
                        穷人小水滴
光盘文件系统iso9660denoGNU/Linuxjavascript
                        
    越简单的系统,越可靠,越不容易出问题.光盘文件系统(iso9660)十分简单,只需不到200行代码,即可实现定位读取其中的文件.参考资料:https://wiki.osdev.org/ISO_9660相关文章:《光盘防水嘛?DVD+R刻录光盘泡水实验》https://blog.csdn.net/secext2022/article/details/140583910《光驱的内部结构及日常使用》ht
    
                    
    • 
                    
  • 逻辑思维的过程与力量
                        解晓萱

                        
    之前我对逻辑思维的了解停留在，讲话时有逻辑，辩论时条理清晰。今天看了《开讲了》里面关于大学生质疑易中天老师的视频，听到易中天老师的回答，忽然对逻辑思维有了稍微深刻的理解。图片发自App逻辑学对我们太重要了，不仅仅是学习备考，更重要的是生活和事业及交流的选择及过程。偏激的起点和性格有关，更和逻辑思维水平有关。视频里，易中天老师评价北大学生逻辑时讲到：“他的逻辑环节是没问题的，但是逻辑起点错了，所以他
    
                    
    • 
                    
  • uniapp map组件自定义markers标记点
                        以对_
uni-app学习记录uni-appjavascript前端
                        
    需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
    
                    
    • 
                    
  • 阅读《认知觉醒》读书笔记
                        就看看书

                        
    本周阅读了周岭的《认知觉醒开启自我改变的原动力》，启发较多，故做读书笔记一则，留待学习。全书共八章，讲述了大脑、潜意识、元认知、专注力、学习力、行动力、情绪力及成本最低的成长之道。具体描述了大脑、焦虑、耐心、模糊、感性、元认知、自控力、专注力、情绪专注、学习专注、匹配、深度、关联、体系、打卡、反馈、休息、清晰、傻瓜、行动、心智宽带、单一视角、游戏心态、早起、冥想、阅读、写作、运动等相关知识点。大脑
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧
                        Lenyiin
C++修炼全景指南技术指南c++算法stl
                        
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
    
                    
    • 
                                
  • ASM系列四 利用Method 组件动态注入方法逻辑
                                    lijingyao8206
字节码技术jvmAOP动态代理ASM
                                    
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
    
                                
    • 
                                
  • java编程思想 --内部类
                                    百合不是茶
java内部类匿名内部类
                                    
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅 
  
1,内部类的创建  内部类是创建在类中的 
 
package com.wj.InsideClass;

/*
 * 内部类的创建
 */
public class CreateInsideClass {

	public CreateInsideClass(
    
                                
    • 
                                
  • web.xml报错
                                    crabdave
web.xml
                                    
    web.xml报错 
  
The content of element type "web-app" must match "(icon?,display- 
 name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
    
                                
    • 
                                
  • 泛型类的自定义
                                    麦田的设计者
javaandroid泛型
                                    
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 
采用泛型类，完成扩展。 
  例如有一个学生类 
    
Student{
  Student(){
   System.out.println("I'm a student.....");
  }
} 
 有一个老师类 
  

    
                                
    • 
                                
  • CSS清除浮动的4中方法
                                    IT独行者
JavaScriptUIcss
                                    
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 
1、结尾处加空div标签 clear:both      1   2   3   4      
.div 
1 
{ 
background 
: 
#000080 
; 
border 
: 
1px   
s
    
                                
    • 
                                
  • Cygwin使用windows的jdk 配置方法
                                    _wy_
jdkwindowscygwin
                                    
    1.[vim /etc/profile] 
   JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43) 
   PATH="$JAVA_HOME/bin:${PATH}" 
   CLAS
    
                                
    • 
                                
  • linux下安装maven
                                    无量
mavenlinux安装
                                    
    Linux下安装maven(转)  1.首先到Maven官网 
下载安装文件，目前最新版本为3.0.3，下载文件为 
apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 
 
2.进入下载文件夹，找到下载的文件，运行如下命令解压 
  tar -xvf  apache-maven-2.2.1-bin.tar.gz  
解压后的文件夹
    
                                
    • 
                                
  • tomcat的https 配置,syslog-ng配置
                                    aichenglong
tomcathttp跳转到httpssyslong-ng配置syslog配置
                                    
    1) tomcat配置https,以及http自动跳转到https的配置 
    1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令) 
     keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
    
                                
    • 
                                
  • 关于领号活动总结
                                    alafqq
活动
                                    
    关于某彩票活动的总结 
具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 
活动要求 
1，随机性，一定要有随机性； 
2，最少中奖概率，如果注数为3200注，则最多中4注 
3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 
4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 
 
解决方案 
1，事先产生随机数1000个，并打
    
                                
    • 
                                
  • java数据结构 冒泡排序的遍历与排序
                                    百合不是茶
java
                                    
    java的冒泡排序是一种简单的排序规则 
  
冒泡排序的原理：  
         比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样； 
        针对所有的元素重复以上的步骤，除了最后一个 
  
  
例题；将int array[] 
    
                                
    • 
                                
  • JS检查输入框输入的是否是数字的一种校验方法
                                    bijian1013
js
                                    
    如下是JS检查输入框输入的是否是数字的一种校验方法： 
<form method=post target="_blank">
   数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br>
</form>

    
                                
    • 
                                
  • Test注解的两个属性：expected和timeout
                                    bijian1013
javaJUnitexpectedtimeout
                                    
    JUnit4：Test文档中的解释： 
　　The Test annotation supports two optional parameters. 
　　The first, expected, declares that a test method should throw an exception. 
　　If it doesn't throw an exception or if it 
    
                                
    • 
                                
  • [Gson二]继承关系的POJO的反序列化
                                    bit1129
POJO
                                    
    父类 
  
  
package inheritance.test2;

import java.util.Map;

public class Model {
    private String field1;
    private String field2;

    private Map<String, String> infoMap
    
                                
    • 
                                
  • 【Spark八十四】Spark零碎知识点记录
                                    bit1129
spark
                                    
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 
ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中 
  
   
    
                                
    • 
                                
  • WAS各种脚本作用大全
                                    ronin47
WAS 脚本
                                    
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 
　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 
　　　 
获取下载 
这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
    
                                
    • 
                                
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句
                                    bylijinnan
switch
                                    
    借鉴网上的思路，用java实现： 
 




public class NoIfWhile {

	/**
	 * @param args
	 * 
	 * find x=1+2+3+....n
	 */
	public static void main(String[] args) {
		int n=10;
		int re=find(n);
		System.o
    
                                
    • 
                                
  • Netty源码学习-ObjectEncoder和ObjectDecoder
                                    bylijinnan
javanetty
                                    
    Netty中传递对象的思路很直观： 
Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 
那把对象序列化为字节流，就可以在Netty中传递对象了 
相应的从ChannelBuffer恢复对象，就是反序列化的过程 
 
Netty已经封装好ObjectEncoder和ObjectDecoder 
 
先看ObjectEncoder 
ObjectEncoder是往外发送
    
                                
    • 
                                
  • spring 定时任务中cronExpression表达式含义
                                    chicony
cronExpression
                                    
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 
代表含义            是否必须 允许的取值范围         &nb
    
                                
    • 
                                
  • Nutz配置Jndi
                                    ctrain
JNDI
                                    
    1、使用JNDI获取指定资源： 
 

var ioc = {
    dao : {
        type :"org.nutz.dao.impl.NutDao",
        args : [ {jndi :"jdbc/dataSource"} ]
    }
}
 
以上方法,仅需要在容器中配置好数据源,注入到NutDao即可. 
    
                                
    • 
                                
  • 解决 /bin/sh^M: bad interpreter: No such file or directory
                                    daizj
shell
                                    
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。 
  
分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 
解决： 
1）在windows下转换： 
利用一些编辑器如UltraEdit或EditPlus等工具
    
                                
    • 
                                
  • [转]for 循环为何可恨？
                                    dcj3sjt126com
程序员读书
                                    
      
Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 
不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
    
                                
    • 
                                
  • Android实用小技巧
                                    dcj3sjt126com
android
                                    
    1、去掉所有Activity界面的标题栏 
　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar" 
  
2、去掉所有Activity界面的TitleBar 和StatusBar  
　　修改AndroidManifes
    
                                
    • 
                                
  • Oracle 复习笔记之序列
                                    eksliang
Oracle 序列sequenceOracle sequence
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 
1.序列的作用 
 
 序列是用于生成唯一、连续序号的对象 
 一般用序列来充当数据库表的主键值 
 
2.创建序列语法如下： 
  
create sequence s_emp
start with 1      --开始值
increment by 1    --増长值
maxval
    
                                
    • 
                                
  • 有“品”的程序员
                                    gongmeitao
工作
                                    
    完美程序员的10种品质　　 
  
 完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的 
  
完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 
　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强 
  
（范围：用简单方式解决复杂问题）　　 
 
    
                                
    • 
                                
  • 使用KeleyiSQLHelper类进行分页查询
                                    hvt
sql.netC#asp.nethovertree
                                    
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
    
                                
    • 
                                
  • SVG 教程 （三）圆形，椭圆，直线
                                    天梯梦
svg
                                    
    SVG <circle>   SVG 圆形 - <circle> 
<circle> 标签可用来创建一个圆： 
下面是SVG代码： 
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
  <circle cx="100" c
    
                                
    • 
                                
  • 链表栈
                                    luyulong
java数据结构
                                    
    
public class Node {
	private Object object;
	private Node next;

	public Node() {
		this.next = null;
		this.object = null;
	}

	public Object getObject() {
		return object;
	}

	public
    
                                
    • 
                                
  • 基础数据结构和算法十：2-3 search tree
                                    sunwinner
Algorithm2-3 search tree
                                    
      
Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
    
                                
    • 
                                
  • spring配置定时任务
                                    stunizhengjia
springtimer
                                    
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到： 
  
  
//------------------------定时任务调用的方法------------------------------
    /**
     * 存储过程定时器
    */
    publi
    
                                
    • 
                                
  • ITeye 8月技术图书有奖试读获奖名单公布
                                    ITeye管理员
活动
                                    
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 
 
 
8月试读活动回顾： 
http://webmaster.iteye.com/blog/2102830 
 
 
本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 
 
 
《跨终端Web》 
 
 
 
 gleams：http
    
                                
    •