快取 - 方法注解組件開發

# yml 配置
expand-cache-config:
    ttl-map: '{"yml-ttl":1000,"hello":2000}'

// 引入配置
@Value("#{${expand-cache-config.ttl-map:null}}")
private Map<String, Long> 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<String, RedisCacheConfiguration> configMap = new HashMap<>();
    // 代碼寫死示例
    configMap.put("world", config.entryTtl(Duration.ofSeconds(60)));
    Set<Map.Entry<String, Long>> entrySet =
            Optional.ofNullable(ttlMap).map(Map::entrySet).orElse(Collections.emptySet());
    for (Map.Entry<String, Long> 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);
}

@Override
protected 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 注解，存在進行過期時間設定
 */
@PostConstruct
public void init() {
    Map<String, Object> 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<String, RedisCacheConfiguration> initialCacheConfiguration =
            (Map<String, RedisCacheConfiguration>)
                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));
    }
}

@Override
public void put(Object key, @Nullable Object value) {
    Object cacheValue = https://www.cnblogs.com/cnx01/p/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());
    }
}