解决Caffeine缓存中值意外丢失的问题：深入理解弱引用与缓存生命周期

// 原始问题中的Caffeine缓存配置示例
private Cache<Long, SmsData> codeCache = Caffeine.newBuilder()
        .expireAfterWrite(24, TimeUnit.HOURS)
        .weakKeys()   // 键使用弱引用
        .weakValues() // 值使用弱引用
        .build();

// 示例：一个非static的缓存可能面临的问题
public class ShortLivedService {
    // 这是一个实例级别的缓存，它的生命周期与ShortLivedService实例绑定
    private Cache<Long, SmsData> instanceCache = Caffeine.newBuilder()
            .expireAfterWrite(1, TimeUnit.MINUTES)
            .build();

    public void processRequest(Long id, SmsData data) {
        instanceCache.put(id, data);
        // ... 执行其他业务逻辑 ...
        // 当ShortLivedService实例执行完请求并被回收后，instanceCache也会随之消失
    }
}

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

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

    public SmsData() {
        // 默认构造器
    }

    public SmsData(int sendCount, int checkCount) {
        this.sendCount = sendCount;
        this.checkCount = 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 +
               '}';
    }
}

public class SmsDataCacheManager {

    // 推荐的Caffeine缓存配置：声明为 static final 且不使用弱引用
    private static final Cache<Long, SmsData> CODE_CACHE = Caffeine.newBuilder()
            .expireAfterWrite(24, TimeUnit.HOURS) // 设置写入后24小时过期
            // .weakKeys()   // 移除此配置，键将使用强引用
            // .weakValues() // 移除此配置，值将使用强引用
            .build();

    /**
     * 存储SmsData到缓存中。
     * @param id 键
     * @param data 值
     */
    public static void storeSmsData(Long id, SmsData data) {
        CODE_CACHE.put(id, data);
        System.out.println("Stored id: " + id + ", data: " + data);
    }

    /**
     * 从缓存中获取SmsData。
     * @param id 键
     * @return 对应的SmsData，如果不存在则为null
     */
    public static SmsData getSmsData(Long id) {
        SmsData data = CODE_CACHE.getIfPresent(id);
        System.out.println("Retrieved id: " + id + ", data: " + data);
        return data;
    }

    public static void main(String[] args) {
        Long testId = 12345L;
        SmsData initialData = new SmsData(1, 0);

        // 存储值
        storeSmsData(testId, initialData);

        // 尝试立即获取值，此时应该能成功获取
        SmsData retrievedData = getSmsData(testId);
        if (retrievedData != null) {
            System.out.println("Successfully retrieved data: " + retrievedData);
        } else {
            System.out.println("Failed to retrieve data immediately after put.");
        }

        // 模拟一段时间后再次获取，只要未过期且没有显式移除，值将保持存在
        // 在没有weakKeys/weakValues的情况下，即使发生GC，值也不会丢失
        try {
            Thread.sleep(100); // 短暂等待
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        SmsData secondRetrieval = getSmsData(testId);
        if (secondRetrieval != null) {
            System.out.println("Successfully retrieved data after a short delay: " + secondRetrieval);
        } else {
            System.out.println("Failed to retrieve data after a short delay.");
        }

        // 验证过期机制 (可选，需要等待24小时或更短的过期时间)
        // System.out.println("Waiting for cache to expire...");
        // try {
        //     Thread.sleep(TimeUnit.HOURS.toMillis(24) + 1000); // 等待超过24小时
        // } catch (InterruptedException e) {
        //     Thread.currentThread().interrupt();
        // }
        // SmsData expiredData = getSmsData(testId);
        // if (expiredData == null) {
        //     System.out.println("Data successfully expired.");
        // } else {