// 一个典型的"查缓存 → 查 DB → 写缓存"逻辑
public User getUserById(Long userId) {
    String cacheKey = "user:" + userId;
    // 1. 先查 Redis 缓存
    User user = (User) redisTemplate.opsForValue().get(cacheKey);
    if (user != null) {
        return user;
    }
    // 2. 缓存未命中，查 MySQL
    user = userMapper.selectById(userId);
    if (user != null) {
        // 3. 写入 Redis 缓存，设置 30 分钟过期
        redisTemplate.opsForValue().set(cacheKey, user, 30, TimeUnit.MINUTES);
    }
    return user;
}

public void updateUser(User user) {
    // 更新 DB
    userMapper.updateById(user);
    // 删除缓存（而非更新缓存）
    redisTemplate.delete("user:" + user.getId());
}

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // Key 序列化：String，可读性好
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);

        // Value 序列化：Jackson JSON，支持复杂对象
        Jackson2JsonRedisSerializer<Object> jsonSerializer =
                new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(
                LaissezFaireSubTypeValidator.instance,
                DefaultTyping.NON_FINAL
        );
        jsonSerializer.setObjectMapper(mapper);

        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(30))
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .disableCachingNullValues();
        return RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
    }
}

/**
 * Cache-Aside 读模板：查缓存 → 未命中查 DB → 回填缓存
 *
 * @param cacheKey   缓存 key
 * @param ttl        缓存过期时间
 * @param timeUnit   时间单位
 * @param dbLoader   DB 查询回调（缓存未命中时调用）
 * @param <T>        返回值类型
 * @return 查询结果
 */
public <T> T cacheAsideRead(
        String cacheKey,
        long ttl,
        TimeUnit timeUnit,
        Class<T> clazz,
        Supplier<T> dbLoader) {

    // 1. 查缓存
    T cachedValue = (T) redisTemplate.opsForValue().get(cacheKey);
    if (cachedValue != null) {
        return cachedValue;
    }

    // 2. 缓存未命中，加分布式锁防止缓存击穿（可选）
    String lockKey = "lock:" + cacheKey;
    Boolean locked = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
    if (Boolean.TRUE.equals(locked)) {
        try {
            // 双重检查：获取锁后再次查缓存
            cachedValue = (T) redisTemplate.opsForValue().get(cacheKey);
            if (cachedValue != null) {
                return cachedValue;
            }
            // 3. 查 DB
            T dbValue = dbLoader.get();
            if (dbValue != null) {
                // 4. 回填缓存
                redisTemplate.opsForValue().set(cacheKey, dbValue, ttl, timeUnit);
            }
            return dbValue;
        } finally {
            redisTemplate.delete(lockKey);
        }
    } else {
        // 未获取到锁，短暂等待后递归重试
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return cacheAsideRead(cacheKey, ttl, timeUnit, clazz, dbLoader);
    }
}

/**
 * Cache-Aside 写模板：先更新 DB → 再删除缓存
 * 采用"删缓存"而非"更新缓存"：避免双写并发导致的数据不一致
 *
 * @param cacheKey   缓存 key
 * @param dbUpdater  DB 更新回调
 */
public void cacheAsideWrite(String cacheKey, Runnable dbUpdater) {
    // 1. 先更新 DB
    dbUpdater.run();

    // 2. 再删除缓存（延迟双删增强一致性）
    redisTemplate.delete(cacheKey);

    // 3. 延迟双删：异步再次删除，覆盖"读请求在删缓存前读到旧值并回填"的窗口
    CompletableFuture.runAsync(() -> {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        redisTemplate.delete(cacheKey);
    });
}

/**
 * Read-Through 缓存读取器 —— 缓存层自动加载 DB
 * 应用只调 get()，缓存未命中时由 CacheLoader 自动查 DB 并填充
 */
public class ReadThroughCache {

    private final RedisTemplate<String, Object> redisTemplate;

    /**
     * CacheLoader 映射表：每种数据类型注册一个加载函数
     * key 前缀 → DB 加载函数
     */
    private final Map<String, Function<String, Object>> loaders = new ConcurrentHashMap<>();

    public ReadThroughCache(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 注册 CacheLoader：告诉缓存层"未命中时怎样查 DB"
     *
     * @param prefix 缓存 key 前缀，用于路由到对应的 loader
     * @param loader 数据库加载函数，入参是去掉前缀后的业务 ID，返回 DB 数据
     */
    public void registerLoader(String prefix, Function<String, Object> loader) {
        loaders.put(prefix, loader);
    }

    /**
     * Read-Through 读操作 —— 应用只需调这一个方法
     *
     * @param key      完整缓存 key（如 "user:1001"）
     * @param ttl      过期时间（秒）
     * @param clazz    返回值类型
     * @param <T>      泛型
     * @return 数据（来自缓存或 DB）
     */
    @SuppressWarnings("unchecked")
    public <T> T get(String key, long ttl, Class<T> clazz) {
        // 1. 查缓存
        T cached = (T) redisTemplate.opsForValue().get(key);
        if (cached != null) {
            return cached;
        }

        // 2. 根据 key 前缀查找对应的 CacheLoader
        String prefix = extractPrefix(key);
        Function<String, Object> loader = loaders.get(prefix);
        if (loader == null) {
            throw new IllegalStateException(
                    "No CacheLoader registered for prefix: " + prefix);
        }

        // 3. 缓存层自动查 DB 并回填（这一步对应用透明）
        String bizId = extractBizId(key);
        Object dbValue = loader.apply(bizId);
        if (dbValue != null) {
            redisTemplate.opsForValue().set(key, dbValue, ttl, TimeUnit.SECONDS);
        }
        return (T) dbValue;
    }

    private String extractPrefix(String key) {
        int idx = key.indexOf(':');
        return idx > 0 ? key.substring(0, idx) : key;
    }

    private String extractBizId(String key) {
        int idx = key.indexOf(':');
        return idx > 0 ? key.substring(idx + 1) : key;
    }
}

// 1. 初始化 ReadThroughCache 并注册 CacheLoader
ReadThroughCache cache = new ReadThroughCache(redisTemplate);

// 注册 user 前缀的 CacheLoader：告诉缓存层如何查 DB
cache.registerLoader("user", bizId -> {
    Long userId = Long.valueOf(bizId);
    return userMapper.selectById(userId);
});

// 注册 product 前缀的 CacheLoader
cache.registerLoader("product", bizId -> {
    Long productId = Long.valueOf(bizId);
    return productMapper.selectById(productId);
});

// 2. 业务代码：只调 get()，不关心缓存命中/未命中/回填逻辑
User user = cache.get("user:1001", 1800, User.class);
Product product = cache.get("product:5001", 3600, Product.class);

@Service
public class UserService {

    // Read-Through：缓存未命中 → 自动执行方法体查 DB → 自动缓存结果
    @Cacheable(value = "user", key = "#userId", unless = "#result == null")
    public User getUserById(Long userId) {
        return userMapper.selectById(userId);
    }

    // 缓存更新：方法执行后自动更新缓存（Write-Through 语义）
    @CachePut(value = "user", key = "#user.id")
    public User updateUser(User user) {
        userMapper.updateById(user);
        return user;
    }

    // 缓存删除：方法执行后自动删缓存（Cache-Aside 语义）
    @CacheEvict(value = "user", key = "#userId")
    public void deleteUser(Long userId) {
        userMapper.deleteById(userId);
    }
}

/**
 * Write-Through 写模板：同步写缓存 + DB，保证强一致性
 * 使用 Redis 事务（MULTI/EXEC）或 Lua 脚本保证原子性
 */
public class WriteThroughCache {

    private final RedisTemplate<String, Object> redisTemplate;

    public WriteThroughCache(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * Write-Through 写操作
     *
     * @param key        缓存 key
     * @param value      待写入的值
     * @param ttl        过期时间（秒）
     * @param dbWriter   DB 写入回调
     * @param <T>        值类型
     */
    public <T> void writeThrough(String key, T value, long ttl, Consumer<T> dbWriter) {
        try {
            // 1. 先写缓存（读请求立即生效）
            redisTemplate.opsForValue().set(key, value, ttl, TimeUnit.SECONDS);

            // 2. 同步写 DB
            dbWriter.accept(value);

            // 3. 两者都成功：返回
        } catch (Exception e) {
            // 4. DB 写入失败：回滚缓存
            redisTemplate.delete(key);
            throw new RuntimeException("Write-Through failed, cache rolled back", e);
        }
    }

    /**
     * 使用 Lua 脚本保证"写缓存 + 写 DB 标记"的原子性
     * 写 DB 本身无法与 Redis 事务绑定，这里用 Lua 脚本保证缓存侧的原子操作
     */
    public <T> void writeThroughWithLog(String key, T value, long ttl,
                                         Consumer<T> dbWriter) {
        // 先在缓存中设置数据 + 一个"持久化中"标记
        String logKey = key + ":pending";
        redisTemplate.opsForValue().set(key, value, ttl, TimeUnit.SECONDS);
        redisTemplate.opsForValue().set(logKey, "1", 60, TimeUnit.SECONDS);

        try {
            dbWriter.accept(value);
            // DB 写入成功，清除 pending 标记
            redisTemplate.delete(logKey);
        } catch (Exception e) {
            // DB 写入失败：清除数据和标记，由补偿任务重试
            redisTemplate.delete(key);
            redisTemplate.delete(logKey);
            throw e;
        }
    }
}

WriteThroughCache writeThroughCache = new WriteThroughCache(redisTemplate);

// 商品库存扣减：需要缓存和 DB 同时反映最新库存
writeThroughCache.writeThrough("product:stock:5001", 99, 3600, newStock -> {
    productStockMapper.updateStock(5001L, (Integer) newStock);
});

/**
 * Write-Behind 异步写缓存引擎
 *
 * 核心设计：
 * 1. 写请求只写 Redis，同时将变更记录放入内存队列
 * 2. 后台线程批量从队列取出变更，聚合后批量写 DB
 * 3. Redis Sorted Set 做兜底：防止内存队列丢失导致数据永久不同步
 */
public class WriteBehindEngine {

    private final RedisTemplate<String, Object> redisTemplate;
    private final BlockingQueue<WriteCommand> pendingQueue;
    private final ScheduledExecutorService flushScheduler;
    private final int batchSize;
    private final long flushIntervalMs;

    public WriteBehindEngine(RedisTemplate<String, Object> redisTemplate,
                              int batchSize, long flushIntervalMs) {
        this.redisTemplate = redisTemplate;
        this.batchSize = batchSize;
        this.flushIntervalMs = flushIntervalMs;
        this.pendingQueue = new LinkedBlockingQueue<>(10000);
        this.flushScheduler = Executors.newSingleThreadScheduledExecutor(r -> {
            Thread t = new Thread(r, "write-behind-flush");
            t.setDaemon(true);
            return t;
        });
        startFlushTask();
    }

    /**
     * 应用调用入口：只写 Redis，立即返回
     */
    public <T> void writeBehind(String key, T value, long ttl,
                                 Consumer<T> dbWriter) {
        // 1. 写 Redis（亚毫秒级）
        redisTemplate.opsForValue().set(key, value, ttl, TimeUnit.SECONDS);

        // 2. 将变更命令放入内存队列（不阻塞）
        WriteCommand cmd = new WriteCommand(key, value, dbWriter,
                                             System.currentTimeMillis());
        if (!pendingQueue.offer(cmd)) {
            // 队列满：写入 Redis 的"待刷盘 Sorted Set"做兜底
            redisTemplate.opsForZSet().add(
                    "write-behind:pending", key, System.currentTimeMillis());
        }
    }

    /**
     * 后台定时批量刷盘
     */
    private void startFlushTask() {
        flushScheduler.scheduleWithFixedDelay(() -> {
            List<WriteCommand> batch = new ArrayList<>(batchSize);
            pendingQueue.drainTo(batch, batchSize);
            if (batch.isEmpty()) return;

            // 按 DB 写入函数分组，同组可批量合并
            Map<Consumer, List<WriteCommand>> groups = batch.stream()
                    .collect(Collectors.groupingBy(cmd -> cmd.dbWriter));

            for (Map.Entry<Consumer, List<WriteCommand>> entry : groups.entrySet()) {
                try {
                    for (WriteCommand cmd : entry.getValue()) {
                        entry.getKey().accept(cmd.value);
                    }
                } catch (Exception e) {
                    // 刷盘失败：重新放回 Redis Sorted Set 兜底
                    for (WriteCommand cmd : entry.getValue()) {
                        redisTemplate.opsForZSet().add(
                                "write-behind:pending",
                                cmd.key,
                                cmd.timestamp);
                    }
                }
            }
        }, flushIntervalMs, flushIntervalMs, TimeUnit.MILLISECONDS);
    }

    @Data
    @AllArgsConstructor
    private static class WriteCommand {
        private String key;
        private Object value;
        private Consumer dbWriter;
        private long timestamp;
    }
}

WriteBehindEngine engine = new WriteBehindEngine(redisTemplate, 100, 200);

// 秒杀场景：扣减库存请求只写 Redis，200ms 后批量刷入 DB
engine.writeBehind("seckill:stock:10001", 99, 7200, newStock -> {
    productStockMapper.updateStock(10001L, (Integer) newStock);
});

// 秒杀场景：更新计数也只写 Redis
engine.writeBehind("seckill:count:10001", 1500, 7200, count -> {
    seckillMapper.updateCount(10001L, (Integer) count);
});

/**
 * Refresh-Ahead 缓存读取器：热度数据自动预刷新
 *
 * 核心机制：
 * 1. 将数据 + 过期时间戳（expireAt）一起存入缓存
 * 2. 读取时检查距离过期还有多久
 * 3. 剩余时间低于阈值 → 异步刷新
 */
public class RefreshAheadCache {

    private final RedisTemplate<String, Object> redisTemplate;
    private final ThreadPoolExecutor refreshPool;
    private final double refreshThreshold; // 如 0.2 表示剩余 TTL < 20% 时触发刷新

    public RefreshAheadCache(RedisTemplate<String, Object> redisTemplate,
                              double refreshThreshold) {
        this.redisTemplate = redisTemplate;
        this.refreshThreshold = refreshThreshold;
        this.refreshPool = new ThreadPoolExecutor(
                2, 4, 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(100),
                r -> new Thread(r, "refresh-ahead"),
                new ThreadPoolExecutor.CallerRunsPolicy());
    }

    /**
     * Refresh-Ahead 读操作
     */
    @SuppressWarnings("unchecked")
    public <T> T get(String key, long ttl, Class<T> clazz,
                      Function<String, T> dbLoader) {
        // 1. 查缓存
        T cached = (T) redisTemplate.opsForValue().get(key);
        if (cached != null) {
            // 2. 检查剩余 TTL
            Long remainTtl = redisTemplate.getExpire(key, TimeUnit.MILLISECONDS);
            if (remainTtl != null && remainTtl > 0) {
                long thresholdMillis = (long) (ttl * 1000 * refreshThreshold);
                if (remainTtl < thresholdMillis) {
                    // 3. TTL 低于阈值：异步刷新
                    asyncRefresh(key, ttl, dbLoader);
                }
            }
            return cached;
        }

        // 4. 缓存未命中：同步加载
        T dbValue = dbLoader.apply(extractBizId(key));
        if (dbValue != null) {
            redisTemplate.opsForValue().set(key, dbValue, ttl, TimeUnit.SECONDS);
        }
        return dbValue;
    }

    private <T> void asyncRefresh(String key, long ttl,
                                   Function<String, T> dbLoader) {
        // 使用 SETNX 防止多个线程同时刷新同一个 key
        String refreshLockKey = "refresh:" + key;
        Boolean locked = redisTemplate.opsForValue()
                .setIfAbsent(refreshLockKey, "1", 30, TimeUnit.SECONDS);
        if (!Boolean.TRUE.equals(locked)) {
            return; // 已有其他线程在刷新
        }

        refreshPool.execute(() -> {
            try {
                T dbValue = dbLoader.apply(extractBizId(key));
                if (dbValue != null) {
                    redisTemplate.opsForValue().set(key, dbValue, ttl, TimeUnit.SECONDS);
                }
            } finally {
                redisTemplate.delete(refreshLockKey);
            }
        });
    }

    private String extractBizId(String key) {
        int idx = key.indexOf(':');
        return idx > 0 ? key.substring(idx + 1) : key;
    }
}

RefreshAheadCache cache = new RefreshAheadCache(redisTemplate, 0.2);

// 热点商品：TTL 30 分钟，剩余不足 6 分钟时自动异步刷新
Product product = cache.get("product:hot:5001", 1800, Product.class, bizId -> {
    return productMapper.selectById(Long.valueOf(bizId));
});

/**
 * Write-Around 策略：写只写 DB，读走 Cache-Aside
 */
public class WriteAroundCache {

    private final RedisTemplate<String, Object> redisTemplate;

    public WriteAroundCache(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 写操作：只写 DB，不写缓存
     */
    public void write(String key, Object value, Consumer<Object> dbWriter) {
        // 只写 DB，不写缓存
        dbWriter.accept(value);
        // 注意：连"删缓存"都不做——因为写的数据可能根本不在缓存中
        // 如果业务要求写的 key 之前碰巧在缓存里，可以选择性删除：
        // redisTemplate.delete(key);
    }

    /**
     * 读操作：标准 Cache-Aside 逻辑
     */
    @SuppressWarnings("unchecked")
    public <T> T read(String key, long ttl, Class<T> clazz,
                       Supplier<T> dbLoader) {
        T cached = (T) redisTemplate.opsForValue().get(key);
        if (cached != null) {
            return cached;
        }
        T dbValue = dbLoader.get();
        if (dbValue != null) {
            redisTemplate.opsForValue().set(key, dbValue, ttl, TimeUnit.SECONDS);
        }
        return dbValue;
    }
}

WriteAroundCache cache = new WriteAroundCache(redisTemplate);

// 日志写入：只写 MySQL，不污染 Redis 缓存
cache.write("log:2024-01-15:ops", logEntry, val -> {
    logMapper.insert((LogEntry) val);
});

// 日志查询（极少）：查缓存 → 未命中 → 查 DB → 回填
LogEntry log = cache.read("log:2024-01-15:ops", 600, LogEntry.class, () -> {
    return logMapper.selectByDate("2024-01-15");
});

@Component
public class SeckillService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private RefreshAheadCache refreshAheadCache;
    @Autowired
    private WriteBehindEngine writeBehindEngine;

    /**
     * 读：商品详情 — Refresh-Ahead 自动续期，保证热点商品缓存永不过期
     */
    public Product getProduct(Long productId) {
        return refreshAheadCache.get(
                "seckill:product:" + productId,
                1800,
                Product.class,
                bizId -> productMapper.selectById(Long.valueOf(bizId)));
    }

    /**
     * 写：扣减库存 — Write-Behind 只写 Redis，异步批量刷 DB
     */
    public void deductStock(Long productId, int quantity) {
        String stockKey = "seckill:stock:" + productId;

        // Lua 脚本保证 Redis 原子扣减
        String lua = "local stock = redis.call('get', KEYS[1]) " +
                     "if stock and tonumber(stock) >= tonumber(ARGV[1]) then " +
                     "  redis.call('decrby', KEYS[1], ARGV[1]) " +
                     "  return 1 " +
                     "else " +
                     "  return 0 " +
                     "end";
        Long result = redisTemplate.execute(
                new DefaultRedisScript<>(lua, Long.class),
                Collections.singletonList(stockKey),
                String.valueOf(quantity));

        if (result != null && result == 1) {
            // 扣减成功：异步刷 DB
            writeBehindEngine.writeBehind(stockKey,
                    redisTemplate.opsForValue().get(stockKey),
                    7200,
                    newStock -> productStockMapper.updateStock(
                            productId, Integer.parseInt(newStock.toString())));
        } else {
            throw new RuntimeException("库存不足");
        }
    }
}

@Component
public class ConfigService {

    @Autowired
    private WriteThroughCache writeThroughCache;
    @Autowired
    private ReadThroughCache readThroughCache;

    @PostConstruct
    public void init() {
        readThroughCache.registerLoader("config", bizId ->
                configMapper.selectByKey(bizId));
    }

    /**
     * 读配置：Read-Through，缓存未命中自动加载
     */
    public Config getConfig(String configKey) {
        return readThroughCache.get("config:" + configKey, 3600, Config.class);
    }

    /**
     * 写配置：Write-Through，缓存和 DB 同步更新
     */
    public void updateConfig(String configKey, Config newConfig) {
        writeThroughCache.writeThrough(
                "config:" + configKey,
                newConfig,
                3600,
                val -> configMapper.updateByKey(configKey, (Config) val));
    }
}

@Component
public class LogService {

    @Autowired
    private WriteAroundCache writeAroundCache;

    /**
     * 日志写入：Write-Around，只写 DB，不污染缓存
     */
    public void appendLog(LogEntry entry) {
        writeAroundCache.write("log:recent:" + entry.getTraceId(), entry,
                val -> logMapper.insert((LogEntry) val));
    }

    /**
     * 日志查询：极少发生，走了缓存也合理
     */
    public LogEntry queryLog(String traceId) {
        return writeAroundCache.read("log:recent:" + traceId, 600,
                LogEntry.class,
                () -> logMapper.selectByTraceId(traceId));
    }
}