实现concurrentHashMap与redis两级缓存

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;

import java.util.concurrent.ConcurrentHashMap;

@Service
public class TwoLevelCacheService {
    private ConcurrentHashMap<String, Object> localCache = new ConcurrentHashMap<>();
    private static final String REDIS_CACHE_PREFIX = "mycache:";

    @Autowired
    private Jedis jedis;

    @Cacheable(value = "mycache", key = "#key")
    public Object getData(String key) {
        if (localCache.containsKey(key)) {
            return localCache.get(key);
        } else {
            Object data = jedis.get(REDIS_CACHE_PREFIX + key);
            if (data != null) {
                localCache.put(key, data);
            }
            return data;
        }
    }

    @CacheEvict(value = "mycache", key = "#key")
    public void clearCache(String key) {
        localCache.remove(key);
        jedis.del(REDIS_CACHE_PREFIX + key);
    }

    // Example method for adding/updating data in cache
    public void putData(String key, Object data) {
        localCache.put(key, data);
        jedis.set(REDIS_CACHE_PREFIX + key, data.toString());
    }
}

import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
@Service
public class DistributedCacheService {
    private ConcurrentHashMap<String, Object> localCache = new ConcurrentHashMap<>();
    @Autowired
    private RedissonClient redissonClient;
    public Object getData(String key) {
        if (localCache.containsKey(key)) {
            return localCache.get(key);
        } else {
            Lock lock = redissonClient.get(key);
            lock.lock();
            try {
                // Double-checked locking to prevent multiple threads refreshing the cache simultaneously
                if (localCache.containsKey(key)) {
                    return localCache.get(key);
                } else {
                    // Get data from Redis
                    RBucket<Object> bucket = redissonClient.getBucket(key);
                    Object data = bucket.get();
                    if (data != null) {
                        localCache.put(key, data);
                    }
                    return data;
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public void putData(String key, Object data) {
        RBucket<Object> bucket = redissonClient.getBucket(key);
        bucket.set(data);
        localCache.put(key, data);
    }

    public void evictData(String key) {
        RBucket<Object> bucket = redissonClient.getBucket(key);
        bucket.delete();
        localCache.remove(key);
    }
}