增强Spring - 改造@CacheEvict支持缓存批量模糊删除

看到这里，我们就知道是怎么回事了。我们继续调试和跟进。我们看到doClear和doEvict最终会调用RedisCache

@Override
 public void evict（对象键）  {
  cacheWriter.remove(name, createAndConvertCacheKey （关键））;
 }
 
 /*
  * （非javadoc） 
  * @see org.springframework.cache.Cache#清除（）
  */
 @Override
 public void  清除() {
    //支持模糊删除
  byte[] pattern = conversionService.convert(createCacheKey("*" ),字节[] .类);
  cacheWriter.clean(名称, 模式);
 }

我们看到如果allEntries为ture的时候最终执行的是clear()这个方法，其实他也是模糊删除的，只是他的关键规则是namespace:: *，看到这里就看到希望我们稀疏一个办法在namespace *中插入我们的telnetID就可以变成namespace ::telnetID:*这种格式，也就达到了我们的目的了。

重点需要重写RedisCache的evict方法，新建一个RedisCacheResolver集成RedisCache，重写evict方法

public class RedisCacheResolver 扩展  RedisCache {
 
    私有 final 字符串名称；
    私有 final RedisCacheWriter cacheWriter;
    private finalConversionService conversionService;
 
    受保护 RedisCacheResolver（字符串名称，RedisCacheWritercacheWriter，RedisCacheConfiguration缓存配置） {
        超级（名称，cacheWriter，cacheConfig);
        这个.name =名称;
        这个 .cacheWriter = cacheWriter;
        这个.conversionService = cacheConfig.getConversionService();
    }
 
    /**
     * 
      * @Title：驱逐
      * @Description: 重写删除的方法
      * @param  @param key       * @throws 
      *
     */ 
    @Override
 public void evict（对象键）   {
 //如果按键包含“ noCacheable :"关键字不会被缓存
    if (key.toString().contains(www.sychzs.cn_CACHEABLE)) {
    返回;
 { 
                                         keyString                                             key.toString ();               if (StringUtils.endsWith(keyString, "*")) {
           evictLikeSuffix(keyString);
                                                                         evictLikeSuffix(key)                               
                                                                                                                                                                                                                                                             我被驱逐(键）;
 }
 
 /**
 * * 后缀匹配匹配
 * *
 *  私人 空 evictLikeSuffix（字符串键） {
 byte[] 模式 = 这个 .conversionService.convert(这个.createCacheKey(key), byte[].class);
               这个.cacheWriter。 clean(this.name,pattern);
}
}

现在我们需要制作这个Redis CacheResolver生效，所以我们需要改变我们的RedisCacheResolver被注入到RedisCacheManager，所以我们需要定义自己的RedisCacheManagerResolver与z集成

public class RedisCacheManagerResolver 扩展  RedisCacheManager {
    私有 finalRedisCacheWritercacheWriter;
    私有 finalRe disCacheConfiguration defaultCacheConfig;
 
    public RedisCacheManagerResolver（ RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter, defaultCacheConfiguration);
        这个.cacheWriter = cacheWriter;
        这个.defaultCacheConfig = defaultCacheConfiguration;
    }
 
    public  RedisCacheManagerResolver（RedisCacheWritercacheWriter，RedisCacheConfigurationdefaultCacheConfiguration，String...initialCacheNames）{
        super（cacheWriter，defaultCacheConfiguration，initialCacheNames）;
        这个.cacheWriter=cacheWriter;
        这个.defaultCacheConfig = defaultCacheConfiguration;
    }
 
    public RedisCacheManagerResolver（RedisCacheWriter cacheWriter、 RedisCacheConfiguration defaultCacheConfiguration、布尔值allowInFlightCacheCreation，字符串...初始CacheNames）{
        超级 （cacheWriter，defaultCacheConfiguration，allowInFlightCacheCreation，initialCacheNames）；
        这个 .cacheWriter = cacheWriter;
        这个.defaultCacheConfig = defaultCacheConfiguration;
    }
      public RedisCacheManagerResolver（RedisCacheWriter cacheWriter， RedisCacheConfiguration defaultCacheConfiguration , Map 初始缓存配置) {
        super(cacheWriter, defaultCacheConfiguration , initialCacheConfigurations);
        这个.cacheWriter = cacheWriter;
 这个.defailureCacheConfig = defaultCacheConfiguration;
    }
 
    public RedisCacheManagerResolver（RedisCacheWritercacheWriter、RedisCacheConfigurationdefaultCacheConfiguration、MapinitialCacheConfigurations、booleanallowInFlightCacheCreation）  {
        超级（cacheWriter、defaultCacheConfiguration、initialCacheConfigurations、allowInFlightCacheCreation）；         这个.cacheWriter = cacheWriter;
        这个.defaultCacheConfig = defaultCacheConfiguration;
    }
 
    public RedisCacheManagerResolver（RedisConnectionFactory redisConnectionFactory， RedisCacheConfiguration cacheConfiguration） {
        这个(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),cacheConfiguration);
    }
 
    /** 
     *覆盖父类创建RedisCache，采用自定义的RedisCacheResolver
 * @标题：createRedisCache 
      * @Description：TODO
      * @param  @param 姓名
      * @param  @paramcacheConfig
      * @param  @return        * @扔 
      *
     */
    @Override
    受保护 RedisCache createRedisCache（字符串名称，@Nullable RedisCacheConfig缓存配置） {
        返回 newRedisCacheResolver（名称，cacheWriter，cacheConfig！=null？cacheConfig：defaultCacheConfig）;
    }
 
    @Override
     public 地图 getCacheConfigurations() {
        Map configurationMap = new HashMap<>(getCacheNames( ).size());
        getCacheNames().forEach(it -> {
            RedisCache缓存= RedisCacheResolver.类.演员（） LookupCache(它？ null);
            });
      返回 Collections.unmodifyingMap(configurationMap);
   }
}

此时我们关键步骤都完成了，最后我们只需要在RedisConfig RedisCacheManagerResolver中管理自己的就

 public CacheManager cacheManager（RedisConnectionFactory redisConnectionFactory） { 
 //设置全局过期时间，单位为秒
 Duration timeToLive = www.sychzs.cn;
 timeToLive = Duration.ofSeconds(timeOut);
// RedisCacheManager cacheManager = new RedisCacheManager(
// RedisCacheWriter.nonLockingRedisCacheWriter(re disConnectionFactory),
// this.getRedisCacheConfig urationWithTtl(生存时间), // 默认策略，未配置的值就使用这个 
// this.getRedisCacheConfigurationMap() // 指定值策略 
// );
 RedisCacheManagerResolver cacheManager =
 new RedisCacheManagerResolver(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
       这个.getRedisCacheConfigurationWithTtl(timeToLive),  //默认策略，未配置的值就使用这个 
 .getRedisCacheConfigurationMap()  // 指定取值策略 
 );
 
// RedisCacheManager cacheManager=RedisCacheManager.builder(factory).cacheDefaults(config).build();
 returncacheManager;
 }

通过在上面的步骤中，我们有实现重写 evict 方法，用于模糊删除缓存

@CacheEvict(value = "BASE_CACHE, key = "#modelClassName + #telenetId+ '*'", allEntries =假）