Java实现本地缓存数据30天后自动过期清除的三种主流方案

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 带过期时间本地缓存，默认30天过期
 */
public class ExpireLocalCache<K, V> {

    // 缓存实体：存储value+存入时间戳
    private static class CacheItem<V> {
        private final V value;
        private final long createTime;

        public CacheItem(V value) {
            this.value = value;
            this.createTime = System.currentTimeMillis();
        }

        // 判断是否过期 30天 = 30 * 24 * 60 * 60 *1000 ms
        public boolean isExpired() {
            long expireMs = 30L * 24 * 60 * 60 * 1000;
            return System.currentTimeMillis() - createTime > expireMs;
        }
    }

    private final ConcurrentHashMap<K, CacheItem<V>> cacheMap = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler;

    public ExpireLocalCache() {
        // 定时清理线程，每1小时扫描一次，删除过期数据
        scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(this::cleanExpire, 1, 1, TimeUnit.HOURS);
    }

    /**
     * 存入缓存
     */
    public void put(K key, V value) {
        if (value == null) {
            cacheMap.remove(key);
            return;
        }
        cacheMap.put(key, new CacheItem<>(value));
    }

    /**
     * 获取缓存，自动判断过期，过期返回null并删除
     */
    public V get(K key) {
        CacheItem<V> item = cacheMap.get(key);
        if (item == null) {
            return null;
        }
        if (item.isExpired()) {
            cacheMap.remove(key);
            return null;
        }
        return item.value;
    }

    /**
     * 手动删除key
     */
    public void remove(K key) {
        cacheMap.remove(key);
    }

    /**
     * 定时清理所有过期key
     */
    private void cleanExpire() {
        cacheMap.entrySet().removeIf(entry -> entry.getValue().isExpired());
    }

    /**
     * 关闭定时任务，程序退出调用
     */
    public void shutdown() {
        scheduler.shutdown();
    }

    // 测试
    public static void main(String[] args) {
        ExpireLocalCache<String, String> cache = new ExpireLocalCache<>();
        cache.put("demoKey", "测试数据");
        String val = cache.get("demoKey");
        System.out.println(val);
    }
}

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version>
</dependency>

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.util.concurrent.TimeUnit;

public class GuavaLocalCacheDemo {
    public static void main(String[] args) {
        // 构建缓存：写入之后30天过期
        Cache<String, String> cache = CacheBuilder.newBuilder()
                .expireAfterWrite(30, TimeUnit.DAYS) // ✅ 写入30天后过期
                .maximumSize(10000) // 可选：限制缓存最大数量，防止内存爆掉
                .recordStats() // 可选：统计缓存命中率
                .build();

        // 写入
        cache.put("key1", "value1");

        // 获取，过期自动返回null
        String value = cache.getIfPresent("key1");
        System.out.println(value);
    }
}

<dependency>
    <groupId>com.github.benmanes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version>
</dependency>

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

public class CaffeineCacheDemo {
    public static void main(String[] args) {
        Cache<String, String> cache = Caffeine.newBuilder()
                .expireAfterWrite(30, TimeUnit.DAYS) // 写入30天过期
                .maximumSize(10000)
                .build();

        cache.put("key", "data");
        String val = cache.getIfPresent("key");
        System.out.println(val);
    }
}