// ApiApplication.java
@EnableCaching  // 开启 Spring Cache 注解
@SpringBootApplication(scanBasePackages = {"com.mall"})
public class ApiApplication {
    public static void main(String[] args) {
        SpringApplication.run(ApiApplication.class, args);
    }
}

# application.yml
spring:
  cache:
    cache-names: dict_data              # 缓存区域名称
    type: caffeine                      # 使用 Caffeine 作为缓存实现
    caffeine:
      spec: initialCapacity=50,maximumSize=500,expireAfterWrite=60s
      #   ↑ 初始 50 条，最多 500 条，写入后 60 秒自动过期

// DictCacheKeyGenerator.java
public class DictCacheKeyGenerator implements KeyGenerator {
    @Override
    public Object generate(Object target, Method method, Object... params) {
        // 生成 key 格式：DictService_dictName
        return target.getClass().getSimpleName() + "_"
                + StringUtils.arrayToDelimitedString(params, "_");
    }
}

// DictService.java
@Service
public class DictService {

    private static final String DICT_DATA_KEY = "dictData"; // Redis Hash key

    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private DictDetailMapper dictDetailMapper;

    /**
     * 从缓存中获取数据字典
     * L1: Caffeine（@Cacheable 自动管理）
     * L2: Redis Hash（dictData）
     */
    @Cacheable(value = "dict_data", keyGenerator = "dictCacheKeyGenerator")
    public List<DictDetailEntity> queryDictDetailEntity(String dictName) {
        // 这个方法只在 Caffeine 未命中时才执行
        List<DictDetailEntity> dataList = getDictDataFromRedis(dictName);
        if (CollectionUtils.isEmpty(dataList)) {
            return Collections.emptyList();
        }
        return dataList.stream()
                .sorted(Comparator.comparing(DictDetailEntity::getSort))
                .collect(Collectors.toList());
    }

    private List<DictDetailEntity> getDictDataFromRedis(String hashKey) {
        String json = (String) redisUtil.getHashValue(DICT_DATA_KEY, hashKey);
        if (!StringUtils.hasLength(json)) {
            return Collections.emptyList();
        }
        return JSONUtil.toList(json, DictDetailEntity.class);
    }

    /**
     * 从 MySQL 全量加载字典数据到 Redis Hash
     * 由管理后台的"刷新字典缓存"按钮触发
     */
    public void refreshDict() {
        // 1. 查所有字典定义
        List<DictEntity> dictEntities = dictMapper.searchAll();
        // 2. 查所有字典明细
        List<DictDetailEntity> details = dictDetailMapper.searchByDictIds(
                dictEntities.stream().map(DictEntity::getId).toList());
        // 3. 按 dictName 分组 → 序列化为 JSON
        Map<Long, List<DictDetailEntity>> detailMap = details.stream()
                .collect(Collectors.groupingBy(DictDetailEntity::getDictId));
        Map<Object, Object> dictMap = new HashMap<>();
        for (DictEntity dict : dictEntities) {
            dictMap.put(dict.getDictName(),
                    JSONUtil.toJsonStr(detailMap.getOrDefault(dict.getId(), List.of())));
        }
        // 4. 批量写入 Redis Hash
        redisUtil.putHashMap(DICT_DATA_KEY, dictMap);
    }
}

// DictDetailController.java
@PostMapping("/searchDictDetail")
public List<DictDetailEntity> searchDictDetail(@RequestBody DictDetailQuery query) {
    // 通过 Service → @Cacheable(Caffeine) →(miss)→ Redis Hash
    return dictDetailService.searchDictDetailFromCache(query.getDictName());
}

@Component
@Slf4j
public class MultiLevelCacheManager {

    @Autowired
    private StringRedisTemplate redisTemplate;

    // L1：本地缓存（Caffeine）
    // 每个实例独立存储自己的热点数据
    private final Cache<String, Object> localCache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(5, TimeUnit.MINUTES)       // 本地缓存 5 分钟强制过期
        .refreshAfterWrite(30, TimeUnit.SECONDS)      // 30 秒异步刷新
        .recordStats()
        .build();

    // Redis 可用性标记
    private volatile boolean redisAvailable = true;
    // 上次检查 Redis 的时间
    private volatile long lastRedisCheckTime = 0;
    // Redis 健康检查间隔
    private static final long REDIS_CHECK_INTERVAL_MS = 5000;

    /**
     * 双层缓存读取 —— 核心方法
     *
     * @param key        缓存 key
     * @param clazz      返回类型
     * @param dbLoader   数据库加载回调
     * @param redisTtl   Redis 过期时间（秒）
     * @return 数据
     */
    @SuppressWarnings("unchecked")
    public <T> T get(String key, Class<T> clazz,
                     Supplier<T> dbLoader, long redisTtl) {

        // ═══════════════════════
        // 第 1 层：本地缓存 Caffeine
        // ═══════════════════════
        T localValue = (T) localCache.getIfPresent(key);
        if (localValue != null) {
            log.debug("L1 命中: {}", key);
            return localValue;
        }

        // ═══════════════════════
        // 第 2 层：远程缓存 Redis
        // ═══════════════════════
        if (redisAvailable) {
            try {
                String redisValue = redisTemplate.opsForValue().get(key);
                if (redisValue != null) {
                    T value = deserialize(redisValue, clazz);
                    // 回填 L1（Redis 有但 Caffeine 没有 → Caffeine 缓存满了被淘汰了）
                    localCache.put(key, value);
                    log.debug("L2 命中 → 回填 L1: {}", key);
                    return value;
                }
            } catch (Exception e) {
                // Redis 挂了——标记不可用，走降级逻辑
                log.warn("Redis 访问异常，触发降级: key={}, error={}", key, e.getMessage());
                redisAvailable = false;

                // 尝试用 L1 的旧数据（即使过期了也不管——降级模式优先保可用性）
                // 注意：Caffeine 的 getIfPresent 只返回未过期的数据
                // 如果需要"过期了也继续用"，需要用另外的 API
            }
        } else {
            // Redis 标记为不可用，定时检查是否恢复
            checkRedisRecovery();
        }

        // ═══════════════════════
        // 第 3 层：数据库 MySQL
        // ═══════════════════════
        T dbValue = dbLoader.get();
        if (dbValue != null) {
            // 回填 L1
            localCache.put(key, dbValue);

            // 尝试回填 L2（Redis 挂了就跳过，不让回填阻塞主流程）
            if (redisAvailable) {
                try {
                    redisTemplate.opsForValue().set(key, serialize(dbValue),
                        redisTtl, TimeUnit.SECONDS);
                } catch (Exception e) {
                    log.warn("L2 回填失败: key={}", key);
                    redisAvailable = false;
                }
            }
        }
        return dbValue;
    }

    // 检查 Redis 是否恢复
    private void checkRedisRecovery() {
        long now = System.currentTimeMillis();
        if (now - lastRedisCheckTime < REDIS_CHECK_INTERVAL_MS) {
            return;   // 5 秒内不重复检查
        }
        lastRedisCheckTime = now;

        try {
            String pong = redisTemplate.getConnectionFactory()
                .getConnection().ping();
            if ("PONG".equals(pong)) {
                redisAvailable = true;
                log.info("Redis 已恢复，恢复正常读写路径");
            }
        } catch (Exception ignored) {
            // 还没恢复，继续降级
        }
    }
}

// === 发布方：更新用户信息 ===
@Service
public class UserService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    public void updateUser(User user) {
        // 1. 更新 DB
        userMapper.updateById(user);

        // 2. 删除 Redis 缓存
        redisTemplate.delete("user:" + user.getId());

        // 3. 删除本地缓存
        localCache.invalidate("user:" + user.getId());

        // 4. 广播通知其他实例也删本地缓存
        redisTemplate.convertAndSend("cache:invalidate:user", user.getId().toString());
    }
}

// === 订阅方：接收删除通知 ===
@Component
public class CacheInvalidateListener implements MessageListener {

    @Override
    public void onMessage(Message message, byte[] pattern) {
        String key = new String(message.getBody());
        localCache.invalidate("user:" + key);
        log.debug("收到缓存失效通知: user:{}", key);
    }
}

// 配置订阅
@Configuration
public class PubSubConfig {

    @Bean
    public RedisMessageListenerContainer container(
            RedisConnectionFactory factory,
            CacheInvalidateListener listener) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(factory);
        container.addMessageListener(listener,
            new ChannelTopic("cache:invalidate:user"));
        return container;
    }
}

// 发布方
public void updateUser(User user) {
    userMapper.updateById(user);
    redisTemplate.delete("user:" + user.getId());
    localCache.invalidate("user:" + user.getId());

    // 发送到 MQ（持久化，可靠性比 PubSub 高）
    rocketMQTemplate.send("cache-invalidate-topic",
        MessageBuilder.withPayload(new CacheInvalidateMsg("user", user.getId())));
}

// 消费方（每个实例都是消费者）
@RocketMQMessageListener(topic = "cache-invalidate-topic", consumerGroup = "${spring.application.name}")
public class CacheInvalidateConsumer implements RocketMQListener<CacheInvalidateMsg> {
    @Override
    public void onMessage(CacheInvalidateMsg msg) {
        localCache.invalidate(msg.getType() + ":" + msg.getId());
    }
}

public <T> T get(String key, Class<T> clazz, Supplier<T> dbLoader, long ttl) {
    T value = /* ... L1 / L2 查询 ... */;

    if (value != null) return value;

    // 查 DB
    T dbValue = dbLoader.get();

    if (dbValue == null) {
        // 缓存空值——防止穿透。TTL 短一点（1-2 分钟），避免占用太多空间
        String nullMarker = "NULL_MARKER";
        localCache.put(key, nullMarker);
        if (redisAvailable) {
            try {
                redisTemplate.opsForValue().set(key, nullMarker, 120, TimeUnit.SECONDS);
            } catch (Exception ignored) { }
        }
        return null;
    }

    // 正常回填...
    return dbValue;
}

// 读取时检查空值标记
private boolean isNullMarker(Object value) {
    return "NULL_MARKER".equals(value);
}

// 启动时把数据库里存在的 ID 都加载到布隆过滤器
BloomFilter<String> bloomFilter = BloomFilter.create(
    Funnels.stringFunnel(StandardCharsets.UTF_8),
    1_000_000,     // 预期元素数量
    0.01           // 误判率 1%
);
// 所有存在的 user ID 加载进去
users.forEach(u -> bloomFilter.put("user:" + u.getId()));

// Caffeine 的 get 自动防击穿（源码级保证）
User user = cache.get("user:1001", key -> userMapper.selectById(1001L));
// 100 个线程同时调这行，只有 1 个执行 selectById，另外 99 个等着用同一份结果

// 如果是自己 put/get，需要手动互斥
public User getUserWithMutex(Long id) {
    String key = "user:" + id;
    User user = localCache.getIfPresent(key);
    if (user != null) return user;

    // 互斥锁——防止击穿
    String lockKey = "lock:" + key;
    boolean locked = false;
    try {
        locked = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
        if (locked) {
            // 拿到锁的线程：双重检查后查 DB
            user = localCache.getIfPresent(key);
            if (user != null) return user;

            user = userMapper.selectById(id);
            if (user != null) {
                localCache.put(key, user);
                redisTemplate.opsForValue().set(key, serialize(user), 1800, TimeUnit.SECONDS);
            }
            return user;
        } else {
            // 没拿到锁的线程：等一会儿再查缓存（别的线程正在加载）
            Thread.sleep(50);
            return getUserWithMutex(id);       // 递归重试
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return null;
    } finally {
        if (locked) redisTemplate.delete(lockKey);
    }
}

// 方案一（推荐）：随机化过期时间
long baseTtl = 30 * 60;                        // 基础 30 分钟
long randomTtl = ThreadLocalRandom.current()
    .nextLong(baseTtl / 10);                   // ±10% 随机浮动
long ttl = baseTtl + randomTtl;                // 实际 27-33 分钟

// 方案二：refreshAfterWrite 异步刷新
// Caffeine 的 refreshAfterWrite 不会让热点 key 同时过期——
// 访问时异步刷新，永远返回一个可用的旧值
Cache<String, User> cache = Caffeine.newBuilder()
    .expireAfterWrite(30, TimeUnit.MINUTES)
    .refreshAfterWrite(25, TimeUnit.MINUTES)    // 提前 5 分钟开始异步刷新
    .build();

@Component
@Slf4j
public class TieredCacheManager {

    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    // ═══════════════════════════════════
    // L1: Caffeine 本地缓存
    // ═══════════════════════════════════
    private final Cache<String, Object> l1Cache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(3, TimeUnit.MINUTES)
        .refreshAfterWrite(30, TimeUnit.SECONDS)
        .recordStats()
        .build();

    // ═══════════════════════════════════
    // Redis 状态
    // ═══════════════════════════════════
    private volatile boolean redisAvailable = true;
    private volatile long lastRedisCheck = 0;
    private static final long REDIS_CHECK_INTERVAL = 5000;

    /**
     * 双层读取 —— 带完整容错
     */
    @SuppressWarnings("unchecked")
    public <T> T get(String key, Class<T> clazz,
                     Supplier<T> dbLoader, long redisTtlSeconds) {

        // L1
        T val = (T) l1Cache.getIfPresent(key);
        if (val != null) {
            if (isNullMarker(val)) return null;     // 缓存的空值标记
            return val;
        }

        // L2: Redis（带降级）
        if (redisAvailable) {
            try {
                String json = redisTemplate.opsForValue().get(key);
                if (json != null) {
                    if (NULL_MARKER.equals(json))   return null;
                    T redisVal = deserialize(json, clazz);
                    l1Cache.put(key, redisVal);
                    return redisVal;
                }
            } catch (Exception e) {
                log.warn("Redis 不可用，触发降级: {}", e.getMessage());
                redisAvailable = false;
            }
        } else {
            checkRedisRecovery();
        }

        // L3: MySQL
        T dbVal = dbLoader.get();
        if (dbVal != null) {
            l1Cache.put(key, dbVal);
            writeToRedisAsync(key, dbVal, redisTtlSeconds);    // 异步写 Redis
        } else {
            // 缓存空值防穿透
            l1Cache.put(key, NULL_OBJECT);
            writeToRedisAsync(key, NULL_OBJECT, 120);          // 空值短 TTL
        }
        return dbVal;
    }

    /**
     * 写操作：更新 DB → 删 Redis → 删本地 → 通知其他实例
     */
    public void evict(String cacheType, Object id) {
        String key = cacheType + ":" + id;

        // 删本地
        l1Cache.invalidate(key);

        // 删 Redis
        if (redisAvailable) {
            try {
                redisTemplate.delete(key);
            } catch (Exception ignored) { }
        }

        // 通知其他实例（MQ 可靠投递，比 PubSub 更可靠）
        try {
            rocketMQTemplate.send("cache-invalidate-topic",
                MessageBuilder.withPayload(new CacheInvalidateMsg(cacheType, id.toString()))
                    .build());
        } catch (Exception e) {
            log.warn("缓存失效通知发送失败，靠 TTL 兜底: {}", key);
        }
    }

    /**
     * 监听其他实例的失效通知
     */
    @RocketMQMessageListener(
        topic = "cache-invalidate-topic",
        consumerGroup = "${spring.application.name:default}"
    )
    class InvalidationListener implements RocketMQListener<CacheInvalidateMsg> {
        @Override
        public void onMessage(CacheInvalidateMsg msg) {
            String key = msg.getType() + ":" + msg.getId();
            l1Cache.invalidate(key);
        }
    }

    // === 内部方法 ===

    private static final String NULL_MARKER = "__NULL__";
    private static final Object NULL_OBJECT = new Object();

    private boolean isNullMarker(Object val) {
        return NULL_OBJECT == val || NULL_MARKER.equals(val);
    }

    private void checkRedisRecovery() {
        long now = System.currentTimeMillis();
        if (now - lastRedisCheck < REDIS_CHECK_INTERVAL) return;
        lastRedisCheck = now;
        try {
            String pong = redisTemplate.getConnectionFactory()
                .getConnection().ping();
            if ("PONG".equals(pong)) {
                redisAvailable = true;
                log.info("Redis 已恢复");
            }
        } catch (Exception ignored) { }
    }

    private void writeToRedisAsync(String key, Object value, long ttl) {
        if (!redisAvailable) return;
        CompletableFuture.runAsync(() -> {
            try {
                String data = value == NULL_OBJECT ? NULL_MARKER : serialize(value);
                redisTemplate.opsForValue().set(key, data, ttl, TimeUnit.SECONDS);
            } catch (Exception e) {
                log.warn("异步写 Redis 失败: key={}", key);
                redisAvailable = false;
            }
        });
    }
}

@Service
public class UserService {

    @Autowired
    private TieredCacheManager cacheManager;

    public User getUserById(Long id) {
        return cacheManager.get("user:" + id, User.class,
            () -> userMapper.selectById(id),   // DB 回调
            1800                                 // Redis TTL 30 分钟
        );
    }

    public void updateUser(User user) {
        userMapper.updateById(user);
        cacheManager.evict("user", user.getId());
    }
}