Java内存缓存工具实现 - Guava LoadingCache

一、Guava介绍

  1. Guava是Google guava中的一个内存缓存模块，用于将数据缓存到JVM内存中。实际项目开发中经常将一些公共或者常用的数据缓存起来方便快速访问。

  2. Guava Cache是单个应用运行时的本地缓存。它不把数据存放到文件或外部服务器。如果不符合需求，可以选择Memcached、Redis等工具。

二、代码示例

1. POM引入

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

2. 封装工具类

package com.soyoung.ad.engine.util;

import com.google.common.cache.*;
import lombok.extern.slf4j.Slf4j;

import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 功能描述
 *
 * @author 马振全 2020/1/13 16:18
 */
@Slf4j
public class CacheManager {

    /** 缓存项最大数量 */
    private static final long GUAVA_CACHE_SIZE = 100000;

    /** 缓存时间：天 */
    private static final long GUAVA_CACHE_DAY = 10;

    /** 缓存操作对象 */
    private static LoadingCache<Long, String> GLOBAL_CACHE = null;

    static {
        try {
            GLOBAL_CACHE = loadCache(new CacheLoader<Long, String>() {
                @Override
                public String load(Long key) throws Exception {
                    // 处理缓存键不存在缓存值时的处理逻辑
                    return "";
                }
            });
        } catch (Exception e) {
            log.error("初始化Guava Cache出错", e);
        }
    }

    /**
     * 全局缓存设置
     *
     * 缓存项最大数量：100000
     * 缓存有效时间（天）：10
     *
     *
     * @param cacheLoader
     * @return
     * @throws Exception
     */
    private static LoadingCache<Long, String> loadCache(CacheLoader<Long, String> cacheLoader) throws Exception {
        LoadingCache<Long, String> cache = CacheBuilder.newBuilder()
                //缓存池大小，在缓存项接近该大小时， Guava开始回收旧的缓存项
                .maximumSize(GUAVA_CACHE_SIZE)
                //设置时间对象没有被读/写访问则对象从内存中删除(在另外的线程里面不定期维护)
                .expireAfterAccess(GUAVA_CACHE_DAY, TimeUnit.DAYS)
                // 设置缓存在写入之后 设定时间 后失效
                .expireAfterWrite(GUAVA_CACHE_DAY, TimeUnit.DAYS)
                //移除监听器,缓存项被移除时会触发
                .removalListener(new RemovalListener<Long, String>() {
                    @Override
                    public void onRemoval(RemovalNotification<Long, String> rn) {
                        //逻辑操作
                    }
                })
                //开启Guava Cache的统计功能
                .recordStats()
                .build(cacheLoader);
        return cache;
    }

    /**
     * 设置缓存值
     * 注: 若已有该key值，则会先移除(会触发removalListener移除监听器)，再添加
     *
     * @param key
     * @param value
     */
    public static void put(Long key, String value) {
        try {
            GLOBAL_CACHE.put(key, value);
        } catch (Exception e) {
            log.error("设置缓存值出错", e);
        }
    }

    /**
     * 批量设置缓存值
     *
     * @param map
     */
    public static void putAll(Map<? extends Long, ? extends String> map) {
        try {
            GLOBAL_CACHE.putAll(map);
        } catch (Exception e) {
            log.error("批量设置缓存值出错", e);
        }
    }

    /**
     * 获取缓存值
     * 注：如果键不存在值，将调用CacheLoader的load方法加载新值到该键中
     *
     * @param key
     * @return
     */
    public static String get(Long key) {
        String token = "";
        try {
            token = GLOBAL_CACHE.get(key);
        } catch (Exception e) {
            log.error("获取缓存值出错", e);
        }
        return token;
    }

    /**
     * 移除缓存
     *
     * @param key
     */
    public static void remove(Long key) {
        try {
            GLOBAL_CACHE.invalidate(key);
        } catch (Exception e) {
            log.error("移除缓存出错", e);
        }
    }

    /**
     * 批量移除缓存
     *
     * @param keys
     */
    public static void removeAll(Iterable<Long> keys) {
        try {
            GLOBAL_CACHE.invalidateAll(keys);
        } catch (Exception e) {
            log.error("批量移除缓存出错", e);
        }
    }

    /**
     * 清空所有缓存
     */
    public static void removeAll() {
        try {
            GLOBAL_CACHE.invalidateAll();
        } catch (Exception e) {
            log.error("清空所有缓存出错", e);
        }
    }

    /**
     * 获取缓存项数量
     *
     * @return
     */
    public static long size() {
        long size = 0;
        try {
            size = GLOBAL_CACHE.size();
        } catch (Exception e) {
            log.error("获取缓存项数量出错", e);
        }
        return size;
    }
}

三、使用总结

1. 移除机制

guava做cache时候数据的移除分为被动移除和主动移除两种。

被动移除分为三种：

  1. 基于大小的移除：数量达到指定大小，会把不常用的键值移除

  2. 基于时间的移除：expireAfterAccess(long, TimeUnit) 根据某个键值对最后一次访问之后多少时间后移除
    　　　　　　　　expireAfterWrite(long, TimeUnit) 根据某个键值对被创建或值被替换后多少时间移除

  3. 基于引用的移除：主要是基于java的垃圾回收机制，根据键或者值的引用关系决定移除

主动移除分为三种：1).单独移除：Cache.invalidate(key)

　　　　　　　　　2).批量移除：Cache.invalidateAll(keys)

　　　　　　　　　3).移除所有：Cache.invalidateAll()

如果配置了移除监听器RemovalListener，则在所有移除的动作时会同步执行该listener下的逻辑。

如需改成异步，使用：RemovalListeners.asynchronous(RemovalListener, Executor)

2. 遇到的问题

  1. 在put操作之前，如果已经有该键值，会先触发removalListener移除监听器，再添加

  2. 配置了expireAfterAccess和expireAfterWrite，但在指定时间后没有被移除。

    解决方案：CacheBuilder构建的缓存不会在特定时间自动执行清理和回收工作，也不会在某个缓存项过期后马上清理，它不会启动一个线程来进行缓存维护，因为a）线程相对较重，b）某些环境限制线程的创建。它会在写操作时顺带做少量的维护工作，或者偶尔在读操作时做。当然，也可以创建自己的维护线程，以固定的时间间隔调用Cache.cleanUp()。

3. Cache提供哪些方法

/**
* 该接口的实现被认为是线程安全的，即可在多线程中调用
* 通过被定义单例使用
*/
public interface Cache<K, V> {

/**
* 通过key获取缓存中的value，若不存在直接返回null
*/
V getIfPresent(Object key);

/**
* 通过key获取缓存中的value，若不存在就通过valueLoader来加载该value
* 整个过程为 "if cached, return; otherwise create, cache and return"
* 注意valueLoader要么返回非null值，要么抛出异常，绝对不能返回null
*/
V get(K key, Callable<? extends V> valueLoader) throws ExecutionException;

/**
* 添加缓存，若key存在，就覆盖旧值
*/
void put(K key, V value);

/**
* 删除该key关联的缓存
*/
void invalidate(Object key);

/**
* 删除所有缓存
*/
void invalidateAll();

/**
* 执行一些维护操作，包括清理缓存
*/
void cleanUp();
}

　　

posted @ 2020-01-14 11:37  森林木马  阅读(3069)  评论(2)  编辑  收藏  举报