Caffeine本地缓存实战

简介

Caffeine 是一个高性能Java 缓存库，提供近乎最佳的命中率。

A Cache 类似于ConcurrentMap，但不完全相同。最根本的区别是ConcurrentMap保留所有添加到它的元素，直到它们被显式删除。Cache另一方面，A通常配置为自动驱逐条目，以限制其内存占用。在某些情况下， a LoadingCacheorAsyncLoadingCache可能很有用，即使它不驱逐条目，由于其自​​动缓存加载

功能

Caffeine 提供灵活的构造来创建具有以下功能组合的缓存：

自动将条目加载到缓存中，可选异步
当超过基于频率和新近度的最大值时基于大小的驱逐
基于时间的条目过期，自上次访问或上次写入以来测量
当条目的第一个陈旧请求发生时异步刷新
键自动包装在弱引用中
值自动包装在弱引用或软引用中
驱逐（或以其他方式删除）条目的通知
写入传播到外部资源
缓存访问统计的累积

使用

1.pom.xml依赖

            
            
                com.github.ben-manes.caffeine
                caffeine
                2.9.1
            

2.初始化缓存

你也可以基于以下，做升级，比如做异步操作...

/**
 * @description Caffeine本地缓存
 * @author: yx-0173
 * @date: 2021-07-15 10:23
 **/
@Configuration
@Slf4j
public class CacheConfig {

    @Bean
    public Cache cache() {
        return Caffeine.newBuilder()
                // 设置最后一次写入或访问后经过固定时间过期
                .expireAfterWrite(60, TimeUnit.SECONDS)
                // 监听器
                .removalListener((String key, Object graph, RemovalCause cause) ->
                        log.info("移除缓存中key为：{},value为：{}的缓存记录", key, graph))
                // 初始的缓存空间大小
                .initialCapacity(100)
                // 缓存的最大条数
                .maximumSize(1000)
                .build();
    }
   
   // api测试，以下代码不要写道这个配置类，可自行整理
   
   // 查找条目，如果未找到，则为null
   cache.getIfPresent(key);
   // 从缓存中查询，如果查询不到则将对应的值放入缓存，如果不可计算，则为null
   cache.get(key, k - > createExpensiveGraph(key));
   // 插入或修改缓存
   cache.put(key, graph);
   // 根据key删除一个缓存
   cache.invalidate(key);
   // 批量获取
   cache.getAll(keys);
   。。。还有很多，可自行官网，页尾附上官网地址
}

3.工具类贡献给大家

**
 * @description 本地缓存工具类
 * @author: yx-0173
 * @date: 2021-07-15 12:51
 **/
@Component
public class CacheUtil {

    @Resource
    private Cache cache;

    /**
     * 根据key获取value
     *
     * @return Object
     */
    public V get(K key) {
        return cache.asMap().get(key);
    }

    /**
     * 根据key获取value
     *
     * @return Object
     */
    public Map getBatch(List key) {
        return cache.getAllPresent(key);
    }

    /**
     * 将一个map插入
     */
    public void putBatch(Map map) {
        cache.asMap().putAll(map);
    }


    public ConcurrentMap get() {
        return cache.asMap();
    }

    /**
     * 插入缓存
     *
     * @param key   key
     * @param value value
     */
    public void put(K key, V value) {
        cache.put(key, value);
    }

    /**
     * 插入缓存,如果不存在，则将value放入缓存
     *
     * @param key   key
     * @param value value
     */
    public V getIfNotExist(K key, V value) {
        return cache.get(key, k -> value);
    }

    /**
     * 是否含有
     *
     * @param key key
     */
    public boolean contains(K key) {
        return cache.asMap().containsKey(key);
    }

    /**
     * 清除
     */
    public void deleteAll() {
        cache.invalidateAll();
    }

    /**
     * 批量删除
     *
     * @param key key
     */
    public void delete(List key) {
        cache.invalidateAll(key);
    }

    /**
     * 删除
     *
     * @param key key
     */
    public void delete(K key) {
        cache.asMap().remove(key);
    }

    /**
     * 更新
     *
     * @param key   key
     * @param value value
     */
    public void update(K key, V value) {
        cache.put(key, value);
    }
}

Caffeine驱逐策略

1.基于大小

Size-based

// 根据缓存中的条目数驱逐
LoadingCache graphs = Caffeine.newBuilder()
    .maximumSize(10_000)
    .build(key -> createExpensiveGraph(key));

// 根据缓存中的顶点数驱逐
LoadingCache graphs = Caffeine.newBuilder()
    .maximumWeight(10_000)
    .weigher((Key key, Graph graph) -> graph.vertices().size())
    .build(key -> createExpensiveGraph(key));

学习之道，永无止境，要学习如何以渔，不要学如何以鱼。
Caffeine官网：https://github.com/ben-manes/...