public class CacheEntity {

    /**
     * 緩存鍵
     */
    private String key;

    /**
     * 緩存值
     */
    private Object value;

    /**
     * 過(guò)期時(shí)間
     */
    private Long expireTime;

    //...set、get
}

public class CacheUtils {

    /**
     * 緩存數(shù)據(jù)
     */
    private final static Map<String, CacheEntity> CACHE_MAP = new ConcurrentHashMap<>();

    /**
     * 定時(shí)器線程池，用于清除過(guò)期緩存
     */
    private static ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();


    static {
        // 注冊(cè)一個(gè)定時(shí)線程任務(wù)，服務(wù)啟動(dòng)1秒之后，每隔500毫秒執(zhí)行一次
        executor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                // 清理過(guò)期緩存
                clearCache();
            }
        },1000,500,TimeUnit.MILLISECONDS);
    }

    /**
     * 添加緩存
     * @param key    緩存鍵
     * @param value  緩存值
     */
    public static void put(String key, Object value){
        put(key, value, 0);
    }


    /**
     * 添加緩存
     * @param key    緩存鍵
     * @param value  緩存值
     * @param expire 緩存時(shí)間，單位秒
     */
    public static void put(String key, Object value, long expire){
        CacheEntity cacheEntity = new CacheEntity()
                .setKey(key)
                .setValue(value);
        if(expire > 0){
            Long expireTime = System.currentTimeMillis() + Duration.ofSeconds(expire).toMillis();
            cacheEntity.setExpireTime(expireTime);
        }
        CACHE_MAP.put(key, cacheEntity);
    }


    /**
     * 獲取緩存
     * @param key
     * @return
     */
    public static Object get(String key){
        if(CACHE_MAP.containsKey(key)){
            return CACHE_MAP.get(key).getValue();
        }
        return null;
    }

    /**
     * 移除緩存
     * @param key
     */
    public static void remove(String key){
        if(CACHE_MAP.containsKey(key)){
            CACHE_MAP.remove(key);
        }
    }

    /**
     * 清理過(guò)期的緩存數(shù)據(jù)
     */
    private static void clearCache(){
        if(CACHE_MAP.size() > 0){
            return;
        }
        Iterator<Map.Entry<String, CacheEntity>> iterator = CACHE_MAP.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry<String, CacheEntity> entry = iterator.next();
            if(entry.getValue().getExpireTime() != null && entry.getValue().getExpireTime().longValue() > System.currentTimeMillis()){
                iterator.remove();
            }
        }
    }

}

// 寫(xiě)入緩存數(shù)據(jù)
CacheUtils.put("userName", "張三", 3);

// 讀取緩存數(shù)據(jù)
Object value1 = CacheUtils.get("userName");
System.out.println("第一次查詢結(jié)果：" + value1);

// 停頓4秒
Thread.sleep(4000);

// 讀取緩存數(shù)據(jù)
Object value2 = CacheUtils.get("userName");
System.out.println("第二次查詢結(jié)果：" + value2);

第一次查詢結(jié)果：張三
第二次查詢結(jié)果：null

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

// 創(chuàng)建一個(gè)緩存實(shí)例
Cache<String, String> cache = CacheBuilder.newBuilder()
        // 初始容量
        .initialCapacity(5)
        // 最大緩存數(shù)，超出淘汰
        .maximumSize(10)
        // 過(guò)期時(shí)間
        .expireAfterWrite(3, TimeUnit.SECONDS)
        .build();

// 寫(xiě)入緩存數(shù)據(jù)
cache.put("userName", "張三");

// 讀取緩存數(shù)據(jù)
String value1 = cache.get("userName", () -> {
    // 如果key不存在，會(huì)執(zhí)行回調(diào)方法
    return "key已過(guò)期";
});
System.out.println("第一次查詢結(jié)果：" + value1);

// 停頓4秒
Thread.sleep(4000);

// 讀取緩存數(shù)據(jù)
String value2 = cache.get("userName", () -> {
    // 如果key不存在，會(huì)執(zhí)行回調(diào)方法
    return "key已過(guò)期";
});
System.out.println("第二次查詢結(jié)果：" + value2);

第一次查詢結(jié)果：張三
第二次查詢結(jié)果：key已過(guò)期

<!--caffeine-->
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>2.9.3</version>
</dependency>

// 創(chuàng)建一個(gè)緩存實(shí)例
Cache<String, String> cache = Caffeine.newBuilder()
        // 初始容量
        .initialCapacity(5)
        // 最大緩存數(shù)，超出淘汰
        .maximumSize(10)
        // 設(shè)置緩存寫(xiě)入間隔多久過(guò)期
        .expireAfterWrite(3, TimeUnit.SECONDS)
        // 設(shè)置緩存最后訪問(wèn)后間隔多久淘汰，實(shí)際很少用到
        //.expireAfterAccess(3, TimeUnit.SECONDS)
        .build();

// 寫(xiě)入緩存數(shù)據(jù)
cache.put("userName", "張三");

// 讀取緩存數(shù)據(jù)
String value1 = cache.get("userName", (key) -> {
    // 如果key不存在，會(huì)執(zhí)行回調(diào)方法
    return "key已過(guò)期";
});
System.out.println("第一次查詢結(jié)果：" + value1);

// 停頓4秒
Thread.sleep(4000);

// 讀取緩存數(shù)據(jù)
String value2 = cache.get("userName", (key) -> {
    // 如果key不存在，會(huì)執(zhí)行回調(diào)方法
    return "key已過(guò)期";
});
System.out.println("第二次查詢結(jié)果：" + value2);

第一次查詢結(jié)果：張三
第二次查詢結(jié)果：key已過(guò)期

<!--ehcache-->
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.9.7</version>
</dependency>

/**
 * 自定義過(guò)期策略實(shí)現(xiàn)
 */
public  class CustomExpiryPolicy<K, V> implements ExpiryPolicy<K, V> {

    private final Map<K, Duration> keyExpireMap = new ConcurrentHashMap();


    public Duration setExpire(K key, Duration duration) {
        return keyExpireMap.put(key, duration);
    }

    public Duration getExpireByKey(K key) {
        return Optional.ofNullable(keyExpireMap.get(key))
                .orElse(null);
    }

    public Duration removeExpire(K key) {
        return keyExpireMap.remove(key);
    }

    @Override
    public Duration getExpiryForCreation(K key, V value) {
        return Optional.ofNullable(getExpireByKey(key))
                .orElse(Duration.ofNanos(Long.MAX_VALUE));
    }

    @Override
    public Duration getExpiryForAccess(K key, Supplier<? extends V> value) {
        return getExpireByKey(key);
    }

    @Override
    public Duration getExpiryForUpdate(K key, Supplier<? extends V> oldValue, V newValue) {
        return getExpireByKey(key);
    }
}

public static void main(String[] args) throws InterruptedException {
    String userCache = "userCache";

    // 自定義過(guò)期策略
    CustomExpiryPolicy<Object, Object> customExpiryPolicy = new CustomExpiryPolicy<>();

    // 聲明一個(gè)容量為20的堆內(nèi)緩存配置
    CacheConfigurationBuilder configurationBuilder = CacheConfigurationBuilder
            .newCacheConfigurationBuilder(String.class, String.class, ResourcePoolsBuilder.heap(20))
            .withExpiry(customExpiryPolicy);

    // 初始化一個(gè)緩存管理器
    CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
            // 創(chuàng)建cache實(shí)例
            .withCache(userCache, configurationBuilder)
            .build(true);

    // 獲取cache實(shí)例
    Cache<String, String> cache = cacheManager.getCache(userCache, String.class, String.class);
    // 獲取過(guò)期策略
    CustomExpiryPolicy expiryPolicy = (CustomExpiryPolicy)cache.getRuntimeConfiguration().getExpiryPolicy();

    // 寫(xiě)入緩存數(shù)據(jù)
    cache.put("userName", "張三");
    // 設(shè)置3秒過(guò)期
    expiryPolicy.setExpire("userName", Duration.ofSeconds(3));

    // 讀取緩存數(shù)據(jù)
    String value1 = cache.get("userName");
    System.out.println("第一次查詢結(jié)果：" + value1);

    // 停頓4秒
    Thread.sleep(4000);

    // 讀取緩存數(shù)據(jù)
    String value2 = cache.get("userName");
    System.out.println("第二次查詢結(jié)果：" + value2);
}

第一次查詢結(jié)果：張三
第二次查詢結(jié)果：null