Redis动态热点数据缓存策略设计

@service
public class hotdatacounter {
    @autowired
    private redistemplate<string, object> redistemplate;

    // 访问计数
    public void incrementcounter(string key) {
        string countkey = "counter:" + key;
        redistemplate.opsforvalue().increment(countkey, 1);
        // 设置计数器过期时间，比如1小时
        redistemplate.expire(countkey, 1, timeunit.hours);
    }

    // 获取访问次数
    public long getcounter(string key) {
        string countkey = "counter:" + key;
        return (long) redistemplate.opsforvalue().get(countkey);
    }
}

public class lrucache<k, v> extends linkedhashmap<k, v> {
    private final int capacity;

    public lrucache(int capacity) {
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    @override
    protected boolean removeeldestentry(map.entry<k, v> eldest) {
        return size() > capacity;
    }
}

@service
public class dynamiccacheservice {
    @autowired
    private redistemplate<string, object> redistemplate;
    @autowired
    private hotdatacounter hotdatacounter;
    // 热点阈值
    private static final long hot_threshold = 100;

    // 获取数据
    public object getdata(string key) {
        // 增加访问计数
        hotdatacounter.incrementcounter(key);
        // 从缓存获取数据
        object value = redistemplate.opsforvalue().get(key);
        if (value != null) {
            return value;
        }
        // 从数据库获取数据
        value = getfromdb(key);
        // 判断是否为热点数据
        if (ishotdata(key)) {
            // 热点数据设置较长的过期时间
            redistemplate.opsforvalue().set(key, value, 1, timeunit.hours);
        } else {
            // 非热点数据设置较短的过期时间
            redistemplate.opsforvalue().set(key, value, 5, timeunit.minutes);
        }
        return value;
    }

    // 判断是否为热点数据
    private boolean ishotdata(string key) {
        long count = hotdatacounter.getcounter(key);
        return count != null && count > hot_threshold;
    }
}

@component
public class hotdatascheduler {
    @autowired
    private redistemplate<string, object> redistemplate;

    @scheduled(fixedrate = 300000) // 每5分钟执行一次
    public void updatehotdata() {
        // 获取所有计数器
        set<string> counterkeys = redistemplate.keys("counter:");
        if (counterkeys == null) return;
        // 更新热点数据过期时间
        for (string counterkey : counterkeys) {
            string datakey = counterkey.substring("counter:".length());
            long count = (long) redistemplate.opsforvalue().get(counterkey);
            if (count != null && count > hot_threshold) {
                // 延长热点数据过期时间
                redistemplate.expire(datakey, 1, timeunit.hours);
            }
        }
    }
}

@service
public class multilevelcache {
    @autowired
    private redistemplate<string, object> redistemplate;
    // 本地缓存
    private final loadingcache<string, object> localcache = cachebuilder.newbuilder()
            .maximumsize(1000)
            .expireafterwrite(5, timeunit.minutes)
            .build(new cacheloader<string, object>() {
                @override
                public object load(string key) {
                    return getfromredis(key);
                }
            });

    public object get(string key) {
        try {
            return localcache.get(key);
        } catch (executionexception e) {
            return getfromredis(key);
        }
    }

    private object getfromredis(string key) {
        object value = redistemplate.opsforvalue().get(key);
        if (value == null) {
            value = getfromdb(key);
            if (value != null) {
                redistemplate.opsforvalue().set(key, value);
            }
        }
        return value;
    }
}

@service
public class hotdatapreloader {
    @autowired
    private redistemplate<string, object> redistemplate;

    @postconstruct
    public void preloadhotdata() {
        // 从统计数据中获取历史热点数据
        list<string> historicalhotkeys = gethistoricalhotkeys();
        // 预加载数据到redis
        for (string key : historicalhotkeys) {
            object value = getfromdb(key);
            if (value != null) {
                redistemplate.opsforvalue().set(key, value, 1, timeunit.hours);
            }
        }
    }
}

@service
public class cacheupdateservice {
    @autowired
    private redistemplate<string, object> redistemplate;

    // 更新缓存数据
    @transactional
    public void updatedata(string key, object value) {
        // 更新数据库
        updatedb(key, value);
        // 判断是否为热点数据
        if (ishotdata(key)) {
            // 直接更新缓存
            redistemplate.opsforvalue().set(key, value, 1, timeunit.hours);
        } else {
            // 删除缓存
            redistemplate.delete(key);
        }
    }
}

@service
public class cachemonitorservice {
    @autowired
    private redistemplate<string, object> redistemplate;

    // 监控缓存命中率
    public double gethitrate() {
        long hits = (long) redistemplate.opsforvalue().get("cache:hits");
        long misses = (long) redistemplate.opsforvalue().get("cache:misses");
        if (hits == null || misses == null) {
            return 0.0;
        }
        return (double) hits / (hits + misses);
    }

    // 记录缓存访问
    public void recordaccess(boolean ishit) {
        string key = ishit ? "cache:hits" : "cache:misses";
        redistemplate.opsforvalue().increment(key, 1);
    }
}

@configuration
@refreshscope
public class cacheconfig {
    @value("${cache.hot.threshold:100}")
    private long hotthreshold;
    @value("${cache.hot.expire:3600}")
    private long hotexpireseconds;
    @value("${cache.normal.expire:300}")
    private long normalexpireseconds;

}