缓存 – 方法注解组件开发

# yml 配置expand-cache-config:    ttl-map: '{"yml-ttl":1000,"hello":2000}'// 引入配置@Value("#{${expand-cache-config.ttl-map:null}}")private Map ttlMap;/** * 注入缓存管理器及处理配置中的缓存时长 */@Bean(BEAN_REDIS_CACHE_MANAGER)public RedisCacheManager expandRedisCacheManager(RedisConnectionFactory factory) {    /*        使用 Jackson 作为值序列化处理器        FastJson 存在部分转换问题如：Set 存储后因为没有对应的类型保存无法转换为 JSONArray（实现 List ） 导致失败    */    ObjectMapper om = JsonUtil.createJacksonObjectMapper();    GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer(om);    // 配置key、value 序列化（解决乱码的问题）    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()            // key 使用 string 序列化方式            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(StringRedisSerializer.UTF_8))            // value 使用 jackson 序列化方式            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer))            // 配置缓存空间名称前缀            .prefixCacheNameWith("spring:cache:")            // 配置全局缓存过期时间            .entryTtl(Duration.ofMinutes(30L));    // 专门指定某些缓存空间的配置，如果过期时间，这里的 key 为缓存空间名称    Map configMap = new HashMap();    // 代码写死示例    configMap.put("world", config.entryTtl(Duration.ofSeconds(60)));    Set<Map.Entry> entrySet =            Optional.ofNullable(ttlMap).map(Map::entrySet).orElse(Collections.emptySet());    for (Map.Entry entry : entrySet) {        // 指定特定缓存空间对应的过期时间        configMap.put(entry.getKey(), config.entryTtl(Duration.ofSeconds(entry.getValue())));    }        RedisCacheWriter redisCacheWriter = RedisCacheWriter.lockingRedisCacheWriter(factory);    // 使用自定义缓存管理器附带自定义参数随机时间，注意此处为全局设定，5-最小随机秒，30-最大随机秒    return new ExpandRedisCacheManager(redisCacheWriter, config, configMap, 5, 30);}

@Overrideprotected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {    String theName = name;    if (name.contains(NAME_SPLIT_SYMBOL)) {        // 名称中存在#标记，修改实际名称，替换默认配置的缓存时长为指定缓存时长        String[] nameArr = name.split(NAME_SPLIT_SYMBOL);        theName = nameArr[0];        Duration duration = TimeUtil.parseDuration(nameArr[1]);        if (duration != null) {            cacheConfig = cacheConfig.entryTtl(duration);        }    }        // 使用自定义缓存处理器附带自定义参数随机时间，将注入的随机时间传递    return new ExpandRedisCache(theName, cacheWriter, cacheConfig, this.minRandomSecond,        this.maxRandomSecond);}

/** * Spring Bean 加载后处理 *  获取所有 @Component 注解的 Bean 判断类中方法是否存在 @SpringCacheable 注解，存在进行过期时间设置 */@PostConstructpublic void init() {    Map beanMap = beanFactory.getBeansWithAnnotation(Component.class);    if (MapUtil.isEmpty(beanMap)) {        return;    }    beanMap.values().forEach(item ->        ReflectionUtils.doWithMethods(item.getClass(), method -> {            ReflectionUtils.makeAccessible(method);            putConfigTtl(method);        })    );    expandRedisCacheManager.initializeCaches();}/** * 利用反射设置方法注解上配置的过期时间 * @param method 注解了自定义缓存的方法 */private void putConfigTtl(Method method) {    ExpandCacheable annotation = method.getAnnotation(ExpandCacheable.class);    if (annotation == null) {        return;    }    String[] cacheNames = annotation.cacheNames();    if (ArrayUtil.isEmpty(cacheNames)) {        cacheNames = annotation.value();    }    // 反射获取缓存管理器初始化配置并设值    Map initialCacheConfiguration =            (Map)                ReflectUtil.getFieldValue(expandRedisCacheManager, "initialCacheConfiguration");    RedisCacheConfiguration defaultCacheConfig =            (RedisCacheConfiguration)                ReflectUtil.getFieldValue(expandRedisCacheManager, "defaultCacheConfig");    Duration ttl = Duration.ofSeconds(annotation.unit().toSeconds(annotation.timeout()));    for (String cacheName : cacheNames) {        initialCacheConfiguration.put(cacheName, defaultCacheConfig.entryTtl(ttl));    }}

@Overridepublic void put(Object key, @Nullable Object value) {    Object cacheValue = preProcessCacheValue(value);    // 替换父类设置缓存时长处理    Duration duration = getDynamicDuration(cacheValue);    cacheWriter.put(name, createAndConvertCacheKey(key),            serializeCacheValue(cacheValue), duration);}/** * 获取动态时长 */private Duration getDynamicDuration(Object cacheValue) {    // 如果缓存值为 null，固定返回时长为 30s 避免缓存穿透    if (NullValue.INSTANCE.equals(cacheValue)) {        return Duration.ofSeconds(30);    }    int randomInt = RandomUtil.randomInt(this.minRandomSecond, this.maxRandomSecond);    return this.cacheConfig.getTtl().plus(Duration.ofSeconds(randomInt));}

/** * 利用 AOP 环绕通知对注解方法返回进行缓存处理 */@Around("@annotation(cn.eastx.practice.demo.cache.config.custom.MethodCacheable)")public Object around(ProceedingJoinPoint joinPoint) throws Throwable {    MethodCacheableOperation operation = MethodCacheableOperation.convert(joinPoint);    if (Objects.isNull(operation)) {        return joinPoint.proceed();    }    Object result = getCacheData(operation);    if (Objects.nonNull(result)) {        return convertCacheData(result);    }    // 加锁处理同步执行    synchronized (operation.getKey().intern()) {        result = getCacheData(operation);        if (Objects.nonNull(result)) {            return convertCacheData(result);        }        result = joinPoint.proceed();        setDataCache(operation, result);    }    return result;}/** * 设置数据缓存 *  特殊值缓存需要转换，特殊值包括 null * @param operation 操作对象 * @param data 数据 */private void setDataCache(MethodCacheableOperation operation, Object data) {    // null缓存处理，固定存储时长，防止缓存穿透    if (Objects.isNull(data)) {        redisUtil.setEx(operation.getKey(), NULL_VALUE, SPECIAL_VALUE_DURATION);        return;    }    // 存在实际数据缓存处理    redisUtil.setEx(operation.getKey(), data, operation.getDuration());    if (Boolean.TRUE.equals(operation.getUseLocal())) {        LocalCacheUtil.put(operation.getKey(), data, operation.getLocalDuration());    }}