本地缓存Caffeine使用随笔

maven依赖

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

配置Bean

@Bean("brandInfoCache")
public LoadingCache<String,BaseBrandInfo> brandInfoCache(){
    /**
     * initialCapacity: 初始的缓存空间大小
     * maximumSize: 缓存的最大数量
     * maximumWeight: 缓存的最大权重
     * expireAfterAccess: 最后一次读或写操作后经过指定时间过期
     * expireAfterWrite: 最后一次写操作后经过指定时间过期
     * refreshAfterWrite: 创建缓存或者最近一次更新缓存后经过指定时间间隔，刷新缓存
     * weakKeys: 打开key的弱引用
     * weakValues：打开value的弱引用
     * softValues：打开value的软引用
     * recordStats：开发统计功能
     *
     * 注意:
     * expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准。
     * maximumSize和maximumWeight不可以同时使用。
     */
    return  Caffeine.newBuilder()
            .maximumSize(100000).recordStats()
            .expireAfterWrite(60,TimeUnit.MINUTES)
            .refreshAfterWrite(60,TimeUnit.MINUTES)
            .removalListener(new RemovalListener<String, BaseBrandInfo>() {
                @Override
                public void onRemoval(@Nullable String brandCode, @Nullable BaseBrandInfo baseBrandInfo, @NonNull RemovalCause removalCause) {
                    log.info("CacheConfig-品牌缓存清除() brandCode:{}, baseBrandInfo:{}, cause:{}", brandCode, baseBrandInfo, removalCause);
                }
            })
            .build(getBrandInfo());
}

@NonNull
private CacheLoader<String,BaseBrandInfo> getBrandInfo(){
    return new CacheLoader<String, BaseBrandInfo>() {
        @Override
        public @Nullable BaseBrandInfo load(@NonNull String brandCode) throws Exception {
            log.info("CacheConfig-品牌缓存未命中():{}, brandCode:{}", "查询数据库", brandCode);
            BaseBrandInfo entity = brandInfoMapper.selectByBrandCode(brandCode);
            if (Objects.isNull(entity)) {
                log.warn("CacheConfig-品牌缓存未命中():{}, brandCode:{}", "查询数据库不存在", brandCode);
                return null;
            }
            return entity;
        }
    };
}

使用缓存Bean

@Autowired
@Qualifier("brandInfoCache")
private LoadingCache<String,BaseBrandInfo> loadingCache;

//加载所有的缓存数据
public List<BaseBrandInfo> getCacheAll(){
    ConcurrentMap<String, BaseBrandInfo> brandInfoConcurrentMap = loadingCache.asMap();
    //使用JDK原生Stream API
    List<BaseBrandInfo> baseBrandInfoList = brandInfoConcurrentMap.values().stream().filter(Objects::nonNull).distinct().collect(Collectors.toList());
    //使用StreamEx API
    //List<BaseBrandInfo> baseBrandInfoList = EntryStream.of(brandInfoConcurrentMap).values().filter(Objects::nonNull).distinct().collect(Collectors.toList());
    return baseBrandInfoList;
}

//根据查询条件在JVM中筛选过滤
public List<BaseBrandInfo> loadByCondition(ReqBrandConditionVO reqBrandConditionVO){
    StreamEx<BaseBrandInfo> streamEx = StreamEx.of(getCacheAll());
    if (isNotEmpty(reqBrandConditionVO.getBrandCodes())) {
        streamEx = streamEx.filter(p -> reqBrandConditionVO.getBrandCodes().contains(p.getBrandCode()));
    }
    List<BaseBrandInfo> list = streamEx.collect(Collectors.toList());
    return list;
}

//按key刷新缓存
public void refreshBrandCache(String brandCode){
    loadingCache.refresh(brandCode);
}

//失效所有缓存
public void refreshBrandCache(){
    loadingCache.invalidateAll();
}

源码路径:https://gitee.com/mirrors/ben-manes-caffeine

最后

以上就是发嗲寒风为你收集整理的本地缓存Caffeine使用随笔的全部内容，希望文章能够帮你解决本地缓存Caffeine使用随笔所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。