import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
@Configuration
@EnableCaching // 開啟緩存注解支持
public class RedisConfig {
    /**
     * 自定義 RedisCacheConfiguration
     * 作用：定制 Key/Value 的序列化方式、過期時(shí)間、Key 前綴格式
     */
    @Bean
    public RedisCacheConfiguration redisCacheConfiguration() {
        // 1. 構(gòu)造 JSON 序列化器
        // 使用 GenericJackson2JsonRedisSerializer 替換默認(rèn)序列化
        GenericJackson2JsonRedisSerializer jsonSerializer = buildJsonSerializer();
        // 2. 構(gòu)建配置
        return RedisCacheConfiguration.defaultCacheConfig()
                // 【核心 1】設(shè)置默認(rèn)過期時(shí)間：1 小時(shí)
                .entryTtl(Duration.ofHours(1))
                // 【核心 2】定制 Key 的序列化：使用 String (默認(rèn)就是 String，顯式指定更清晰)
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 【核心 3】定制 Value 的序列化：使用 JSON
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jsonSerializer))
                // 【核心 4】定制 Key 前綴策略：CacheName + ":" + Key
                // 默認(rèn)是 "::"，這里改為 ":"，避免 RDM 工具出現(xiàn)空目錄
                .computePrefixWith(name -> name + ":")
                // 【可選】禁止緩存 Null 值 (根據(jù)業(yè)務(wù)需求決定是否開啟)
                // .disableCachingNullValues()
                ;
    }
    /**
     * 輔助方法：構(gòu)建支持 Java8 時(shí)間和類型信息的 JSON 序列化器
     */
    private GenericJackson2JsonRedisSerializer buildJsonSerializer() {
        ObjectMapper objectMapper = new ObjectMapper();
        // 1. 注冊 JavaTimeModule，解決 LocalDateTime 等時(shí)間類序列化問題
        objectMapper.registerModule(new JavaTimeModule());
        // 2. 啟用多態(tài)類型驗(yàn)證，將類信息 (@class) 寫入 JSON
        // 這樣從 Redis 讀出來時(shí)，才能自動(dòng)轉(zhuǎn)回具體的 Java 對象，而不僅僅是 Map
        objectMapper.activateDefaultTyping(
                LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL,
                JsonTypeInfo.As.PROPERTY
        );
        return new GenericJackson2JsonRedisSerializer(objectMapper);
    }
}

{
  "@class": "com.example.User",
  "id": 1001,
  "username": "admin",
  "createTime": [2023, 10, 1, 12, 0, 0]
}

import cn.hutool.core.util.StrUtil; // 示例使用了 Hutool 工具類，也可使用原生 String 方法
import org.springframework.data.redis.cache.RedisCache;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import java.time.Duration;
public class TimeoutRedisCacheManager extends RedisCacheManager {
    private static final String SPLIT_FLAG = "#";
    public TimeoutRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter, defaultCacheConfiguration);
    }
    /**
     * 核心重寫方法：在創(chuàng)建 Cache 對象時(shí)介入
     */
    @Override
    protected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {
        // 1. 如果名稱為空或不包含分隔符，直接使用父類邏輯（應(yīng)用全局默認(rèn)配置）
        if (StrUtil.isEmpty(name) || !name.contains(SPLIT_FLAG)) {
            return super.createRedisCache(name, cacheConfig);
        }
        // 2. 切割字符串
        // 格式約定：cacheName#ttl，例如 "system_users#30m"
        String[] parts = name.split(SPLIT_FLAG);
        if (parts.length != 2) {
            return super.createRedisCache(name, cacheConfig);
        }
        // 3. 提取真實(shí)緩存名和時(shí)間字符串
        String realName = parts[0]; // "system_users"
        String ttlStr = parts[1];   // "30m"
        // 4. 解析時(shí)間，并修改配置
        // 注意：RedisCacheConfiguration 是不可變的，entryTtl 會(huì)返回新實(shí)例
        Duration duration = parseDuration(ttlStr);
        if (cacheConfig != null) {
            cacheConfig = cacheConfig.entryTtl(duration);
        }
        // 5. 使用真實(shí)的名稱和定制后的配置創(chuàng)建緩存
        // 這樣 Redis 中的 Key 就是 "prefix:system_users:key"，不會(huì)帶上 "#30m"
        return super.createRedisCache(realName, cacheConfig);
    }
    /**
     * 輔助方法：解析時(shí)間字符串
     * 支持格式：1d, 4h, 30m, 60s
     */
    private Duration parseDuration(String ttlStr) {
        String timeUnit = StrUtil.subSuf(ttlStr, -1).toLowerCase(); // 獲取最后一位單位
        long timeValue = Long.parseLong(StrUtil.sub(ttlStr, 0, ttlStr.length() - 1)); // 獲取數(shù)值
        switch (timeUnit) {
            case "d":
                return Duration.ofDays(timeValue);
            case "h":
                return Duration.ofHours(timeValue);
            case "m":
                return Duration.ofMinutes(timeValue);
            case "s":
                return Duration.ofSeconds(timeValue);
            default:
                // 默認(rèn)單位為秒，或者根據(jù)業(yè)務(wù)需求拋出異常
                return Duration.ofSeconds(Long.parseLong(ttlStr));
        }
    }
}

@Bean
public RedisCacheManager redisCacheManager(RedisTemplate<String, Object> redisTemplate,
                                           RedisCacheConfiguration redisCacheConfiguration) {
    // 1. 獲取連接工廠
    RedisConnectionFactory factory = Objects.requireNonNull(redisTemplate.getConnectionFactory());
    // 2. 創(chuàng)建無鎖的 CacheWriter
    // BatchStrategies.scan(1000) 是為了在使用 evict(allEntries=true) 時(shí)
    // 使用 SCAN 命令代替 KEYS 命令，防止阻塞 Redis 主線程
    RedisCacheWriter cacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(factory,
            BatchStrategies.scan(1000));
    // 3. 返回自定義的 TimeoutRedisCacheManager
    return new TimeoutRedisCacheManager(cacheWriter, redisCacheConfiguration);
}

// 不帶后綴，使用 RedisCacheConfiguration 配置的全局默認(rèn)時(shí)間（如 1 小時(shí)）
@Cacheable(value = "system_dict", key = "#type")
public List<Dict> getDictByType(String type) { ... }

// 后綴 #60s，指定 60 秒過期
@Cacheable(value = "sms_code#60s", key = "#mobile")
public String getVerifyCode(String mobile) { ... }

// 后綴 #1d，指定 1 天過期
@Cacheable(value = "daily_ranking#1d", key = "#date")
public Ranking getDailyRanking(String date) { ... }

import org.springframework.data.redis.cache.RedisCache;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheWriter;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
 * 自定義二級緩存實(shí)現(xiàn)
 * L1: JVM 本地內(nèi)存 (使用 ConcurrentHashMap 模擬，生產(chǎn)建議使用 Caffeine)
 * L2: Redis (使用父類邏輯)
 */
public class Level2RedisCache extends RedisCache {
    // 一級緩存容器
    private final Map<Object, Object> localCache = new ConcurrentHashMap<>();
    // 統(tǒng)計(jì)指標(biāo)（可選）
    private final String name;
    public Level2RedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig) {
        super(name, cacheWriter, cacheConfig);
        this.name = name;
    }
    /**
     * 重寫查詢邏輯 (核心)
     * 對應(yīng) @Cacheable 注解的讀取操作
     */
    @Override
    protected Object lookup(Object key) {
        // 1. 【L1】先檢查本地內(nèi)存
        Object localValue = localCache.get(key);
        if (localValue != null) {
            // log.debug("L1 緩存命中: key={}", key);
            return localValue;
        }
        // 2. 【L2】本地沒有，調(diào)用父類方法查 Redis
        // super.lookup() 內(nèi)部會(huì)處理序列化和反序列化
        Object redisValue = super.lookup(key);
        // 3. 【回填】如果 Redis 查到了，回寫到本地內(nèi)存
        if (redisValue != null) {
            // log.debug("L2 緩存命中并回填 L1: key={}", key);
            localCache.put(key, redisValue);
        }
        return redisValue;
    }
    /**
     * 重寫寫入邏輯
     * 對應(yīng) @Cacheable 的寫入和 @CachePut
     */
    @Override
    public void put(Object key, Object value) {
        // 1. 【L2】先寫 Redis (保證遠(yuǎn)程數(shù)據(jù)的強(qiáng)一致性)
        super.put(key, value);
        // 2. 【L1】再寫本地內(nèi)存
        // 注意：如果是集群環(huán)境，這里只更新了當(dāng)前節(jié)點(diǎn)的 L1。
        // 生產(chǎn)環(huán)境通常需要結(jié)合 Redis Pub/Sub 通知其他節(jié)點(diǎn)失效 L1。
        if (value != null) {
            localCache.put(key, value);
        }
    }
    /**
     * 重寫刪除邏輯
     * 對應(yīng) @CacheEvict
     */
    @Override
    public void evict(Object key) {
        // 1. 【L2】刪 Redis
        super.evict(key);
        // 2. 【L1】刪本地
        localCache.remove(key);
    }
    /**
     * 重寫清空邏輯
     * 對應(yīng) @CacheEvict(allEntries = true)
     */
    @Override
    public void clear() {
        super.clear();
        localCache.clear();
    }
}

public class MultiLevelCacheManager extends RedisCacheManager {
    public MultiLevelCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter, defaultCacheConfiguration);
    }
    @Override
    protected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {
        // 這里可以結(jié)合上一章的邏輯，先處理 cacheConfig 的 TTL
        // ... (省略 TTL 解析邏輯) ...
        // 【關(guān)鍵】返回自定義的 Level2RedisCache 實(shí)例
        // 這里的 super.createRedisCache 只是為了復(fù)用父類的一些初始化檢查，
        // 但我們直接 new 自己的對象是最直接的。
        return new Level2RedisCache(name, getCacheWriter(), cacheConfig);
    }
}

@Override
protected Object lookup(Object key) {
    long start = System.nanoTime();
    try {
        Object value = super.lookup(key);
        recordMetrics(key, value != null, System.nanoTime() - start);
        return value;
    } catch (Exception e) {
        // 容錯(cuò)降級：如果 Redis 掛了，記錄日志，返回 null 讓業(yè)務(wù)查庫
        // log.error("Redis 異常", e);
        return null; 
    }
}
private void recordMetrics(Object key, boolean hit, long durationNs) {
    // 偽代碼：上報(bào)給 Prometheus 或 Micrometer
    // Metrics.counter("cache.requests", "name", this.name, "hit", String.valueOf(hit)).increment();
    // Metrics.timer("cache.latency", "name", this.name).record(durationNs, TimeUnit.NANOSECONDS);
}

@Bean("md5KeyGenerator")
public KeyGenerator keyGenerator() {
    return (target, method, params) -> {
        // 自定義邏輯：拼接類名+方法名+參數(shù)MD5
        return method.getName() + "_" + Arrays.toString(params);
    };
}
// 使用：@Cacheable(keyGenerator = "md5KeyGenerator")

@Configuration
public class CacheConfig extends CachingConfigurerSupport {
    @Override
    public CacheErrorHandler errorHandler() {
        return new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
                // 僅打印日志，不拋出異常 -> 視為未命中，自動(dòng)穿透到數(shù)據(jù)庫
                log.error("Redis get failed, key: {}", key, exception);
            }
            // ... handlePutError, handleEvictError, handleClearError
        };
    }
}

@Bean
public LettuceConnectionFactory redisConnectionFactory() {
    LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
            // 優(yōu)先從從節(jié)點(diǎn)讀取，如果沒有從節(jié)點(diǎn)則讀主節(jié)點(diǎn)
            .readFrom(ReadFrom.REPLICA_PREFERRED) 
            .build();
    return new LettuceConnectionFactory(new RedisStandaloneConfiguration(), clientConfig);
}

@Bean
RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    return container;
}
// 然后監(jiān)聽 __keyevent@0__:expired 頻道