Redis dynamic hotspot data cache strategy design

@Service
public class HotDataCounter {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // Access count    public void incrementCounter(String key) {
        String countKey = "counter:" + key;
        ().increment(countKey, 1);
        // Set the counter expiration time, such as 1 hour        (countKey, 1, );
    }

    // Get the number of visits    public Long getCounter(String key) {
        String countKey = "counter:" + key;
        return (Long) ().get(countKey);
    }
}

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75f, true);
         = capacity;
    }

    @Override
    protected boolean removeEldestEntry(<K, V> eldest) {
        return size() > capacity;
    }
}

@Service
public class DynamicCacheService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private HotDataCounter hotDataCounter;
    // Hot spot threshold    private static final long HOT_THRESHOLD = 100;

    // Get data    public Object getData(String key) {
        // Increase access count        (key);
        // Get data from cache        Object value = ().get(key);
        if (value != null) {
            return value;
        }
        // Get data from the database        value = getFromDB(key);
        // Determine whether it is hot data        if (isHotData(key)) {
            // Set a long expiration time for hot spot data            ().set(key, value, 1, );
        } else {
            // Set a short expiration time for non-hot data            ().set(key, value, 5, );
        }
        return value;
    }

    // Determine whether it is hot data    private boolean isHotData(String key) {
        Long count = (key);
        return count != null && count > HOT_THRESHOLD;
    }
}

@Component
public class HotDataScheduler {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Scheduled(fixedRate = 300000) // Perform every 5 minutes    public void updateHotData() {
        // Get all counters        Set<String> counterKeys = ("counter:");
        if (counterKeys == null) return;
        // Update hotspot data expiration time        for (String counterKey : counterKeys) {
            String dataKey = ("counter:".length());
            Long count = (Long) ().get(counterKey);
            if (count != null && count > HOT_THRESHOLD) {
                // Extend the expiration time of hot spot data                (dataKey, 1, );
            }
        }
    }
}

@Service
public class MultiLevelCache {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    // Local cache    private final LoadingCache<String, Object> localCache = ()
            .maximumSize(1000)
            .expireAfterWrite(5, )
            .build(new CacheLoader<String, Object>() {
                @Override
                public Object load(String key) {
                    return getFromRedis(key);
                }
            });

    public Object get(String key) {
        try {
            return (key);
        } catch (ExecutionException e) {
            return getFromRedis(key);
        }
    }

    private Object getFromRedis(String key) {
        Object value = ().get(key);
        if (value == null) {
            value = getFromDB(key);
            if (value != null) {
                ().set(key, value);
            }
        }
        return value;
    }
}

@Service
public class HotDataPreloader {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @PostConstruct
    public void preloadHotData() {
        // Get historical hotspot data from statistics        List<String> historicalHotKeys = getHistoricalHotKeys();
        // Preload data to Redis        for (String key : historicalHotKeys) {
            Object value = getFromDB(key);
            if (value != null) {
                ().set(key, value, 1, );
            }
        }
    }
}

@Service
public class CacheUpdateService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // Update cached data    @Transactional
    public void updateData(String key, Object value) {
        // Update the database        updateDB(key, value);
        // Determine whether it is hot data        if (isHotData(key)) {
            // Directly update the cache            ().set(key, value, 1, );
        } else {
            // Delete the cache            (key);
        }
    }
}

@Service
public class CacheMonitorService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // Monitor cache hit rate    public double getHitRate() {
        Long hits = (Long) ().get("cache:hits");
        Long misses = (Long) ().get("cache:misses");
        if (hits == null || misses == null) {
            return 0.0;
        }
        return (double) hits / (hits + misses);
    }

    // Record cache access    public void recordAccess(boolean isHit) {
        String key = isHit ? "cache:hits" : "cache:misses";
        ().increment(key, 1);
    }
}

@Configuration
@RefreshScope
public class CacheConfig {
    @Value("${:100}")
    private long hotThreshold;
    @Value("${:3600}")
    private long hotExpireSeconds;
    @Value("${:300}")
    private long normalExpireSeconds;

}