@Service
public class RedisLocalCacheService {
    
    private final StringRedisTemplate redisTemplate;
    private final Cache<String, String> localCache;
    
    public RedisLocalCacheService(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
        
        // 配置Caffeine緩存
        this.localCache = Caffeine.newBuilder()
                .maximumSize(10_000)  // 最大緩存條目數(shù)
                .expireAfterWrite(Duration.ofMinutes(5))  // 寫入后過期時間
                .recordStats()  // 記錄統(tǒng)計信息
                .build();
    }
    
    public String get(String key) {
        // 首先嘗試從本地緩存獲取
        String value = localCache.getIfPresent(key);
        
        if (value != null) {
            // 本地緩存命中
            return value;
        }
        
        // 本地緩存未命中，從Redis獲取
        value = redisTemplate.opsForValue().get(key);
        
        if (value != null) {
            // 將從Redis獲取的值放入本地緩存
            localCache.put(key, value);
        }
        
        return value;
    }
    
    public void set(String key, String value) {
        // 更新Redis
        redisTemplate.opsForValue().set(key, value);
        
        // 更新本地緩存
        localCache.put(key, value);
    }
    
    public void delete(String key) {
        // 從Redis中刪除
        redisTemplate.delete(key);
        
        // 從本地緩存中刪除
        localCache.invalidate(key);
    }
    
    // 獲取緩存統(tǒng)計信息
    public Map<String, Object> getCacheStats() {
        CacheStats stats = localCache.stats();
        Map<String, Object> statsMap = new HashMap<>();
        
        statsMap.put("hitCount", stats.hitCount());
        statsMap.put("missCount", stats.missCount());
        statsMap.put("hitRate", stats.hitRate());
        statsMap.put("evictionCount", stats.evictionCount());
        
        return statsMap;
    }
}

@Service
public class RedisTrackingCacheService {
    
    private final StatefulRedisConnection<String, String> connection;
    private final RedisCommands<String, String> commands;
    private final Map<String, String> localCache = new ConcurrentHashMap<>();
    private final Set<String> trackedKeys = ConcurrentHashMap.newKeySet();
    
    public RedisTrackingCacheService(RedisClient redisClient) {
        this.connection = redisClient.connect();
        this.commands = connection.sync();
        
        // 配置客戶端緩存失效監(jiān)聽器
        connection.addListener(message -> {
            if (message instanceof PushMessage) {
                PushMessage pushMessage = (PushMessage) message;
                if ("invalidate".equals(pushMessage.getType())) {
                    List<Object> invalidations = pushMessage.getContent();
                    handleInvalidations(invalidations);
                }
            }
        });
        
        // 啟用客戶端緩存跟蹤
        commands.clientTracking(ClientTrackingArgs.Builder.enabled());
    }
    
    public String get(String key) {
        // 首先嘗試從本地緩存獲取
        String value = localCache.get(key);
        
        if (value != null) {
            return value;
        }
        
        // 本地緩存未命中，從Redis獲取
        value = commands.get(key);
        
        if (value != null) {
            // 啟用跟蹤后，Redis服務(wù)器會記錄這個客戶端正在跟蹤這個鍵
            localCache.put(key, value);
            trackedKeys.add(key);
        }
        
        return value;
    }
    
    public void set(String key, String value) {
        // 更新Redis
        commands.set(key, value);
        
        // 更新本地緩存
        localCache.put(key, value);
        trackedKeys.add(key);
    }
    
    private void handleInvalidations(List<Object> invalidations) {
        if (invalidations != null && invalidations.size() >= 2) {
            // 解析失效消息
            String invalidationType = new String((byte[]) invalidations.get(0));
            
            if ("key".equals(invalidationType)) {
                // 單個鍵失效
                String invalidatedKey = new String((byte[]) invalidations.get(1));
                localCache.remove(invalidatedKey);
                trackedKeys.remove(invalidatedKey);
            } else if ("prefix".equals(invalidationType)) {
                // 前綴失效
                String prefix = new String((byte[]) invalidations.get(1));
                Iterator<Map.Entry<String, String>> it = localCache.entrySet().iterator();
                while (it.hasNext()) {
                    String key = it.next().getKey();
                    if (key.startsWith(prefix)) {
                        it.remove();
                        trackedKeys.remove(key);
                    }
                }
            }
        }
    }
    
    // 獲取緩存統(tǒng)計信息
    public Map<String, Object> getCacheStats() {
        Map<String, Object> stats = new HashMap<>();
        stats.put("cacheSize", localCache.size());
        stats.put("trackedKeys", trackedKeys.size());
        return stats;
    }
    
    // 清除本地緩存但保持跟蹤
    public void clearLocalCache() {
        localCache.clear();
    }
    
    // 關(guān)閉連接并清理資源
    @PreDestroy
    public void cleanup() {
        if (connection != null) {
            connection.close();
        }
    }
}

@Configuration
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeineSpec(CaffeineSpec.parse(
                "maximumSize=10000,expireAfterWrite=300s,recordStats"));
        return cacheManager;
    }
}

@Service
public class RedisTtlCacheService {
    
    private final StringRedisTemplate redisTemplate;
    
    @Autowired
    public RedisTtlCacheService(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    
    @Cacheable(value = "redisCache", key = "#key")
    public String get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
    
    @CachePut(value = "redisCache", key = "#key")
    public String set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
        return value;
    }
    
    @CacheEvict(value = "redisCache", key = "#key")
    public void delete(String key) {
        redisTemplate.delete(key);
    }
    
    // 分層緩存 - 不同過期時間的緩存
    @Cacheable(value = "shortTermCache", key = "#key")
    public String getWithShortTtl(String key) {
        return redisTemplate.opsForValue().get(key);
    }
    
    @Cacheable(value = "longTermCache", key = "#key")
    public String getWithLongTtl(String key) {
        return redisTemplate.opsForValue().get(key);
    }
    
    // 在程序邏輯中手動控制過期時間
    public String getWithDynamicTtl(String key, Duration ttl) {
        // 使用LoadingCache，可以動態(tài)設(shè)置過期時間
        Cache<String, String> dynamicCache = Caffeine.newBuilder()
                .expireAfterWrite(ttl)
                .build();
        
        return dynamicCache.get(key, k -> redisTemplate.opsForValue().get(k));
    }
    
    // 定期刷新緩存
    @Scheduled(fixedRate = 60000) // 每分鐘執(zhí)行
    public void refreshCache() {
        // 獲取需要刷新的鍵列表
        List<String> keysToRefresh = getKeysToRefresh();
        
        for (String key : keysToRefresh) {
            // 觸發(fā)重新加載，會調(diào)用被@Cacheable注解的方法
            this.get(key);
        }
    }
    
    private List<String> getKeysToRefresh() {
        // 實際應(yīng)用中，可能從配置系統(tǒng)或特定的Redis set中獲取
        return Arrays.asList("config:app", "config:features", "daily:stats");
    }
    
    // 使用二級緩存模式，對熱點數(shù)據(jù)使用更長的TTL
    public String getWithTwoLevelCache(String key) {
        // 首先查詢本地一級緩存（短TTL）
        Cache<String, String> l1Cache = Caffeine.newBuilder()
                .maximumSize(1000)
                .expireAfterWrite(Duration.ofSeconds(10))
                .build();
        
        String value = l1Cache.getIfPresent(key);
        if (value != null) {
            return value;
        }
        
        // 查詢本地二級緩存（長TTL）
        Cache<String, String> l2Cache = Caffeine.newBuilder()
                .maximumSize(10000)
                .expireAfterWrite(Duration.ofMinutes(5))
                .build();
        
        value = l2Cache.getIfPresent(key);
        if (value != null) {
            // 提升到一級緩存
            l1Cache.put(key, value);
            return value;
        }
        
        // 查詢Redis
        value = redisTemplate.opsForValue().get(key);
        if (value != null) {
            // 更新兩級緩存
            l1Cache.put(key, value);
            l2Cache.put(key, value);
        }
        
        return value;
    }
}

@Service
public class RedisPubSubCacheService {
    
    private final StringRedisTemplate redisTemplate;
    private final Map<String, String> localCache = new ConcurrentHashMap<>();
    
    @Autowired
    public RedisPubSubCacheService(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
        
        // 訂閱緩存失效通知
        subscribeToInvalidations();
    }
    
    private void subscribeToInvalidations() {
        // 使用獨立的Redis連接訂閱緩存失效通知
        RedisConnectionFactory connectionFactory = redisTemplate.getConnectionFactory();
        
        if (connectionFactory != null) {
            // 創(chuàng)建消息監(jiān)聽容器
            RedisMessageListenerContainer container = new RedisMessageListenerContainer();
            container.setConnectionFactory(connectionFactory);
            
            // 消息監(jiān)聽器，處理緩存失效通知
            MessageListener invalidationListener = (message, pattern) -> {
                String invalidationMessage = new String(message.getBody());
                handleCacheInvalidation(invalidationMessage);
            };
            
            // 訂閱緩存失效通知頻道
            container.addMessageListener(invalidationListener, new PatternTopic("cache:invalidations"));
            container.start();
        }
    }
    
    private void handleCacheInvalidation(String invalidationMessage) {
        try {
            // 解析失效消息
            Map<String, Object> invalidation = new ObjectMapper().readValue(
                    invalidationMessage, new TypeReference<Map<String, Object>>() {});
            
            String type = (String) invalidation.get("type");
            
            if ("key".equals(type)) {
                // 單個鍵失效
                String key = (String) invalidation.get("key");
                localCache.remove(key);
            } else if ("prefix".equals(type)) {
                // 前綴失效
                String prefix = (String) invalidation.get("prefix");
                localCache.keySet().removeIf(key -> key.startsWith(prefix));
            } else if ("all".equals(type)) {
                // 清空整個緩存
                localCache.clear();
            }
        } catch (Exception e) {
            // 處理解析錯誤
        }
    }
    
    public String get(String key) {
        // 首先嘗試從本地緩存獲取
        String value = localCache.get(key);
        
        if (value != null) {
            return value;
        }
        
        // 本地緩存未命中，從Redis獲取
        value = redisTemplate.opsForValue().get(key);
        
        if (value != null) {
            // 存入本地緩存
            localCache.put(key, value);
        }
        
        return value;
    }
    
    public void set(String key, String value) {
        // 更新Redis
        redisTemplate.opsForValue().set(key, value);
        
        // 更新本地緩存
        localCache.put(key, value);
        
        // 發(fā)布緩存更新通知
        publishInvalidation("key", key);
    }
    
    public void delete(String key) {
        // 從Redis中刪除
        redisTemplate.delete(key);
        
        // 從本地緩存中刪除
        localCache.remove(key);
        
        // 發(fā)布緩存失效通知
        publishInvalidation("key", key);
    }
    
    public void deleteByPrefix(String prefix) {
        // 獲取并刪除指定前綴的鍵
        Set<String> keys = redisTemplate.keys(prefix + "*");
        if (keys != null && !keys.isEmpty()) {
            redisTemplate.delete(keys);
        }
        
        // 清除本地緩存中匹配的鍵
        localCache.keySet().removeIf(key -> key.startsWith(prefix));
        
        // 發(fā)布前綴失效通知
        publishInvalidation("prefix", prefix);
    }
    
    public void clearAllCache() {
        // 清空本地緩存
        localCache.clear();
        
        // 發(fā)布全局失效通知
        publishInvalidation("all", null);
    }
    
    private void publishInvalidation(String type, String key) {
        try {
            // 創(chuàng)建失效消息
            Map<String, Object> invalidation = new HashMap<>();
            invalidation.put("type", type);
            if (key != null) {
                invalidation.put(type.equals("key") ? "key" : "prefix", key);
            }
            invalidation.put("timestamp", System.currentTimeMillis());
            
            // 添加來源標識，防止自己接收自己發(fā)出的消息
            invalidation.put("source", getApplicationInstanceId());
            
            // 序列化并發(fā)布消息
            String message = new ObjectMapper().writeValueAsString(invalidation);
            redisTemplate.convertAndSend("cache:invalidations", message);
        } catch (Exception e) {
            // 處理序列化錯誤
        }
    }
    
    private String getApplicationInstanceId() {
        // 返回應(yīng)用實例唯一標識，避免處理自己發(fā)出的消息
        return "app-instance-" + UUID.randomUUID().toString();
    }
    
    // 獲取緩存統(tǒng)計信息
    public Map<String, Object> getCacheStats() {
        Map<String, Object> stats = new HashMap<>();
        stats.put("cacheSize", localCache.size());
        return stats;
    }
}