import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.redisson.api.*;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.CacheBuilder;

@Service
public class CacheService {
    // 本地一級緩存（Caffeine）
    private final Cache<String, Object> localCache;
    // Redisson客戶端，用于分布式操作
    private final RedissonClient redissonClient;
    // 鎖緩存，用于控制并發(fā)
    private final ConcurrentHashMap<String, ReentrantLock> lockMap = new ConcurrentHashMap<>();
    // 延遲任務(wù)執(zhí)行器
    private final ScheduledExecutorService scheduledExecutorService;
    // 主題訂閱，用于接收集群消息
    private final RTopic cacheClearTopic;

    @Autowired
    public CacheService(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
        this.localCache = CacheBuilder.newBuilder()
                .maximumSize(10_000)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build();
        this.scheduledExecutorService = Executors.newScheduledThreadPool(5);
        this.cacheClearTopic = redissonClient.getTopic("cache:clear");
        
        // 注冊消息監(jiān)聽器
        cacheClearTopic.addListener(String.class, (channel, key) -> {
            localCache.invalidate(key);
        });
    }

    // 讀取緩存
    public Object get(String key) {
        // 1. 先查本地緩存
        Object value = localCache.getIfPresent(key);
        if (value != null) {
            return value;
        }

        // 2. 本地緩存未命中，查Redis
        RMap<String, Object> redisMap = redissonClient.getMap("cache");
        value = redisMap.get(key);
        if (value != null) {
            localCache.put(key, value);
            return value;
        }

        // 3. Redis未命中，查數(shù)據(jù)庫
        ReentrantLock lock = lockMap.computeIfAbsent(key, k -> new ReentrantLock());
        lock.lock();
        try {
            // 雙重檢查
            value = localCache.getIfPresent(key);
            if (value != null) {
                return value;
            }
            
            value = redisMap.get(key);
            if (value != null) {
                localCache.put(key, value);
                return value;
            }

            // 從數(shù)據(jù)庫讀取
            value = readFromDatabase(key);
            if (value != null) {
                // 放入Redis并設(shè)置TTL
                redisMap.put(key, value, 300, TimeUnit.SECONDS);
                // 放入本地緩存
                localCache.put(key, value);
            }
            return value;
        } finally {
            lock.unlock();
            lockMap.remove(key);
        }
    }

    // 更新數(shù)據(jù)
    public void update(String key, Object value) {
        // 使用分布式鎖保證寫操作的原子性
        RLock lock = redissonClient.getLock("writeLock:" + key);
        lock.lock();
        try {
            // 1. 更新數(shù)據(jù)庫
            boolean success = updateDatabase(key, value);
            if (success) {
                // 2. 先刪除本地緩存
                localCache.invalidate(key);
                // 3. 刪除Redis緩存
                RMap<String, Object> redisMap = redissonClient.getMap("cache");
                redisMap.remove(key);
                // 4. 發(fā)布清除緩存的消息到集群
                cacheClearTopic.publish(key);
                // 5. 延遲雙刪
                scheduledExecutorService.schedule(() -> {
                    redisMap.remove(key);
                }, 100, TimeUnit.MILLISECONDS);
            }
        } finally {
            lock.unlock();
        }
    }

    // 從數(shù)據(jù)庫讀取數(shù)據(jù)（示例方法）
    private Object readFromDatabase(String key) {
        // 實際實現(xiàn)中會查詢數(shù)據(jù)庫
        return "data_from_db_" + key;
    }

    // 更新數(shù)據(jù)庫（示例方法）
    private boolean updateDatabase(String key, Object value) {
        // 實際實現(xiàn)中會更新數(shù)據(jù)庫
        return true;
    }
}    

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        // 單機模式配置
        config.useSingleServer()
              .setAddress("redis://localhost:6379")
              .setConnectionMinimumIdleSize(5)
              .setConnectionPoolSize(50);
        
        // 集群模式配置示例
        /*
        config.useClusterServers()
              .addNodeAddress("redis://node1:6379", "redis://node2:6379")
              .setScanInterval(2000)
              .setMasterConnectionMinimumIdleSize(10)
              .setMasterConnectionPoolSize(64)
              .setSlaveConnectionMinimumIdleSize(10)
              .setSlaveConnectionPoolSize(64);
        */
        
        return Redisson.create(config);
    }
}