Java中CaffeineCache自定义缓存时间的实现

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

@Slf4j
public class CaffeineCacheUtils {

    /**
     * 声明缓存对象
     */
    private static final Cache<String, Object> CACHE = Caffeine.newBuilder()
            // 当key和value都没有引用时驱逐缓存
            .weakKeys()
            .weakValues()
            // 最大容量
            .maximumSize(10_000)
            // 固定存活时间24小时
            .expireAfterWrite(2 * 60 * 60 * 1000L, TimeUnit.MILLISECONDS)
            .build()
            // 构建Caffeine缓存
            ;
 }

/**
     * 添加缓存
     *
     * @param key   key值
     * @param value value值
     */
    public static void put(String key, Object value) {
        CACHE.put(key, value);
    }

    /**
     * 获取缓存对象
     *
     * @param key key值
     * @return 返回value值
     */
    public static Object get(String key) {
        return CACHE.getIfPresent(key);
    }

@Test
    public void testCache() {
        CaffeineCacheUtils.put("key", "value");
        Object value = CaffeineCacheUtils.get("key");
        log.info("value={}", value);
    }

@Data
public class CacheValueHolder implements Serializable {

    @Serial
    private static final long serialVersionUID = 1398783661313031605L;

    private Object value;
    private TimeUnit timeUnit;
    private long expire;

}

/**
     * 声明缓存对象
     */
    private static final Cache<String, CacheValueHolder> CACHE = Caffeine.newBuilder()
            // 当key和value都没有引用时驱逐缓存
            .weakKeys()
            .weakValues()
            // 最大容量
            .maximumSize(10_000)
            .expireAfter(new Expiry<String, CacheValueHolder>() {

                @Override
                public long expireAfterCreate(String key, CacheValueHolder valueHolder, long currentTime) {
                    log.info("创建缓存对象，key={}，value={}，currentTime={}", key, JSON.toJSONString(valueHolder), currentTime);
                    return valueHolder.getTimeUnit().toNanos(valueHolder.getExpire());
                }

                @Override
                public long expireAfterUpdate(String key, CacheValueHolder valueHolder, long currentTime, @NonNegative long currentDuration) {
                    log.info("更新缓存对象，key={}，value={}，currentTime={}，currentDuration={}", key, JSON.toJSONString(valueHolder), currentTime, currentDuration);
                    return valueHolder.getTimeUnit().toNanos(valueHolder.getExpire());
                }

                @Override
                public long expireAfterRead(String key, CacheValueHolder valueHolder, long currentTime, @NonNegative long currentDuration) {
                    log.info("读取缓存对象，key={}，value={}，currentTime={}，currentDuration={}", key, JSON.toJSONString(valueHolder), currentTime, currentDuration);
                    return currentDuration;
                }
            })
            // 如果缓存不存在，则同步查询事业部产品列表，同时加入缓存
            .build()
            // 构建Caffeine缓存
            ;

/**
     * 添加缓存
     *
     * @param key      key值
     * @param value    value值
     * @param expire   过期时间
     * @param timeUnit 时间类型
     */
    public static void put(String key, Object value, long expire, TimeUnit timeUnit) {
        CacheValueHolder valueHolder = new CacheValueHolder();
        valueHolder.setValue(value);
        valueHolder.setExpire(expire);
        valueHolder.setTimeUnit(timeUnit);
        CACHE.put(key, valueHolder);
    }

    /**
     * 添加缓存
     *
     * @param key   key值
     * @param value value值
     */
    public static void put(String key, Object value) {
        // 默认缓存存在时间为1000毫秒
        put(key, value, 1000, TimeUnit.MILLISECONDS);
    }

    /**
     * 获取缓存对象
     *
     * @param key key值
     * @return 返回value值
     */
    public static Object get(String key) {
        CacheValueHolder valueHolder = CACHE.getIfPresent(key);
        if (Objects.isNull(valueHolder)) {
            return null;
        }

        return valueHolder.getValue();
    }

@Test
    public void testCache() throws InterruptedException {
        CaffeineCacheUtils.put("key1", "value1", 1000L, TimeUnit.MILLISECONDS);
        CaffeineCacheUtils.put("key2", "value2", 2000L, TimeUnit.MILLISECONDS);
        Object value1 = CaffeineCacheUtils.get("key1");
        Object value2 = CaffeineCacheUtils.get("key2");
        log.info("value1={}", value1);
        log.info("value2={}", value2);

        TimeUnit.MILLISECONDS.sleep(1000L);
        Object value11 = CaffeineCacheUtils.get("key1");
        Object value22 = CaffeineCacheUtils.get("key2");
        log.info("value1={}", value11);
        log.info("value2={}", value22);

    }