Caffeine缓存深度解析：解决弱引用导致的值丢失与实例管理问题

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;

public class ProblematicCacheExample {

    // 缓存被配置为使用弱键和弱值
    private Cache<Long, SmsData> codeCache = Caffeine.newBuilder()
            .expireAfterWrite(24, TimeUnit.HOURS)
            .weakKeys() // 弱键
            .weakValues() // 弱值
            .build();

    // 假设SmsData是一个简单的POJO
    static class SmsData {
        private int sendCount;
        private int checkCount;
        // 省略构造器、getter和setter
        public int getSendCount() { return sendCount; }
        public void setSendCount(int sendCount) { this.sendCount = sendCount; }
        public int getCheckCount() { return checkCount; }
        public void setCheckCount(int checkCount) { this.checkCount = checkCount; }
        @Override
        public String toString() {
            return "SmsData{" + "sendCount=" + sendCount + ", checkCount=" + checkCount + '}';
        }
    }

    public void storeAndRetrieve(long id, int currentSendCount) {
        SmsData dataToStore = new SmsData();
        dataToStore.setSendCount(++currentSendCount);
        dataToStore.setCheckCount(0);

        codeCache.put(id, dataToStore); // 存入缓存
        System.out.println("尝试存入缓存，key: " + id + ", value: " + dataToStore);

        SmsData retrievedData = codeCache.getIfPresent(id); // 立即尝试获取
        if (retrievedData == null) {
            System.out.println("错误：从缓存获取失败，key: " + id + " 返回 null。");
        } else {
            System.out.println("成功从缓存获取，key: " + id + ", value: " + retrievedData);
        }
    }

    public static void main(String[] args) {
        ProblematicCacheExample example = new ProblematicCacheExample();
        example.storeAndRetrieve(123L, 0);
        // 强制进行垃圾回收，模拟弱引用被回收的场景
        System.gc();
        try {
            Thread.sleep(100); // 稍作等待
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("GC后再次尝试获取...");
        SmsData dataAfterGC = example.codeCache.getIfPresent(123L);
        System.out.println("GC后获取结果: " + (dataAfterGC == null ? "null" : dataAfterGC));
    }
}

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;

public class CorrectCaffeineCacheExample {

    // 假设SmsData是一个简单的POJO
    static class SmsData {
        private int sendCount;
        private int checkCount;

        public int getSendCount() { return sendCount; }
        public void setSendCount(int sendCount) { this.sendCount = sendCount; }
        public int getCheckCount() { return checkCount; }
        public void setCheckCount(int checkCount) { this.checkCount = checkCount; }

        @Override
        public String toString() {
            return "SmsData{" +
                   "sendCount=" + sendCount +
                   ", checkCount=" + checkCount +
                   '}';
        }
    }

    // 声明为 static final，确保缓存实例的唯一性和持久性
    // 移除 weakKeys() 和 weakValues()，使用默认的强引用
    private static final Cache<Long, SmsData> codeCache = Caffeine.newBuilder()
            .expireAfterWrite(24, TimeUnit.HOURS) // 根据业务需求设置过期策略
            .maximumSize(10_000) // 可选：设置最大缓存条目数，防止内存溢出
            .build();

    public void processSmsData(long id, int initialSendCount) {
        int currentSendCount = initialSendCount;

        // 尝试从缓存获取数据
        SmsData data = codeCache.getIfPresent(id);
        if (data == null) {
            // 缓存中不存在，创建新数据
            data = new SmsData();
            data.setSendCount(++currentSendCount);
            data.setCheckCount(0);
            System.out.println("缓存中无数据，创建新数据并存入。key: " + id + ", value: " + data);
        } else {
            // 缓存中存在，更新数据
            data.setSendCount(++currentSendCount);
            System.out.println("从缓存获取数据并更新。key: " + id + ", value: " + data);
        }

        // 确保数据存回缓存（即使是更新也需要put，因为SmsData是可变对象）
        codeCache.put(id, data);
        System.out.println("数据已存入/更新缓存。");

        // 再次尝试获取，验证数据是否持久
        SmsData retrievedData = codeCache.getIfPresent(id);
        if (retrievedData != null) {
            System.out.println("验证：成功从缓存获取，key: " + id + ", value: " + retrievedData);
        } else {
            System.out.println("验证：从缓存获取失败，key: " + id + " 返回 null。这不应该发生！");
        }
    }

    public static void main(String[] args) {
        CorrectCaffeineCacheExample example = new CorrectCaffeineCacheExample();
        long smsId = 456L;

        // 第一次调用，数据会存入缓存
        example.processSmsData(smsId, 0);

        // 模拟后续操作，数据应能从缓存中获取并更新
        System.out.println("\n--- 模拟后续操作 ---");
        example.processSmsData(smsId, example.codeCache.getIfPresent(smsId).getSendCount()); // 传入当前sendCount

        // 模拟另一个实例（但由于是static final，实际上是同一个缓存）
        System.out.println("\n--- 模拟另一个实例或线程访问 ---");
        CorrectCaffeineCacheExample anotherExample = new CorrectCaffeineCacheExample();
        anotherExample.processSmsData(smsId, anotherExample.codeCache.getIfPresent(smsId).getSendCount());
    }
}