Guava - LoadingCache实现Java本地缓存

前言

Guava是Google开源出来的一套工具库。其中提供的cache模块非常方便，是一种与ConcurrentMap相似的缓存Map。

官方地址：https://github.com/google/guava/wiki/CachesExplained

 

开始构建

一. 添加依赖

    com.google.guava
    guava
    27.1-jre

二.创建 CacheLoader

 1 LoadingCache cache = CacheBuilder.newBuilder()
 2                 //缓存池大小，在缓存项接近该大小时， Guava开始回收旧的缓存项
 3                 .maximumSize(GUAVA_CACHE_SIZE)
 4                 //设置时间对象没有被读/写访问则对象从内存中删除(在另外的线程里面不定期维护)
 5                 .expireAfterAccess(10, TimeUnit.MINUTES)
 6                 //移除监听器,缓存项被移除时会触发
 7                 .removalListener(new RemovalListener () {
 8                     @Override
 9                     public void onRemoval(RemovalNotification rn) {
10                         //执行逻辑操作
11                     }
12                 })
13                 //开启Guava Cache的统计功能
14                 .recordStats()
15                 .build(cacheLoader);

三.个人封装的工具类

  1 package com.xxx;
  2 
  3 import com.google.common.cache.*;
  4 import org.slf4j.Logger;
  5 
  6 import java.util.ArrayList;
  7 import java.util.List;
  8 import java.util.Map;
  9 import java.util.concurrent.ConcurrentMap;
 10 import java.util.concurrent.TimeUnit;
 11 
 12 public class CacheManager {
 13 
 14     private static Logger log = Log.get();
 15 
 16     /** 缓存项最大数量 */
 17     private static final long GUAVA_CACHE_SIZE = 100000;
 18 
 19     /** 缓存时间：天 */
 20     private static final long GUAVA_CACHE_DAY = 10;
 21 
 22     /** 缓存操作对象 */
 23     private static LoadingCache GLOBAL_CACHE = null;
 24 
 25     static {
 26         try {
 27             GLOBAL_CACHE = loadCache(new CacheLoader () {
 28                 @Override
 29                 public String load(Long key) throws Exception {
 30                     // 处理缓存键不存在缓存值时的处理逻辑
 31                     return "";
 32                 }
 33             });
 34         } catch (Exception e) {
 35             log.error("初始化Guava Cache出错", e);
 36         }
 37     }
 38 
 39     /**
 40      * 全局缓存设置
 41      *
 42      * 缓存项最大数量：100000
 43      * 缓存有效时间（天）：10
 44      *
 45      *
 46      * @param cacheLoader
 47      * @return
 48      * @throws Exception
 49      */
 50     private static LoadingCache loadCache(CacheLoader cacheLoader) throws Exception {
 51         LoadingCache cache = CacheBuilder.newBuilder()
 52                 //缓存池大小，在缓存项接近该大小时， Guava开始回收旧的缓存项
 53                 .maximumSize(GUAVA_CACHE_SIZE)
 54                 //设置时间对象没有被读/写访问则对象从内存中删除(在另外的线程里面不定期维护)
 55                 .expireAfterAccess(GUAVA_CACHE_DAY, TimeUnit.DAYS)
 56                 // 设置缓存在写入之后 设定时间 后失效
 57                 .expireAfterWrite(GUAVA_CACHE_DAY, TimeUnit.DAYS)
 58                 //移除监听器,缓存项被移除时会触发
 59                 .removalListener(new RemovalListener () {
 60                     @Override
 61                     public void onRemoval(RemovalNotification rn) {
 62                         //逻辑操作
 63                     }
 64                 })
 65                 //开启Guava Cache的统计功能
 66                 .recordStats()
 67                 .build(cacheLoader);
 68         return cache;
 69     }
 70 
 71     /**
 72      * 设置缓存值
 73      * 注: 若已有该key值，则会先移除(会触发removalListener移除监听器)，再添加
 74      *
 75      * @param key
 76      * @param value
 77      */
 78     public static void put(Long key, String value) {
 79         try {
 80             GLOBAL_CACHE.put(key, value);
 81         } catch (Exception e) {
 82             log.error("设置缓存值出错", e);
 83         }
 84     }
 85 
 86     /**
 87      * 批量设置缓存值
 88      *
 89      * @param map
 90      */
 91     public static void putAll(Mapextends Long, ? extends String> map) {
 92         try {
 93             GLOBAL_CACHE.putAll(map);
 94         } catch (Exception e) {
 95             log.error("批量设置缓存值出错", e);
 96         }
 97     }
 98 
 99     /**
100      * 获取缓存值
101      * 注：如果键不存在值，将调用CacheLoader的load方法加载新值到该键中
102      *
103      * @param key
104      * @return
105      */
106     public static String get(Long key) {
107         String token = "";
108         try {
109             token = GLOBAL_CACHE.get(key);
110         } catch (Exception e) {
111             log.error("获取缓存值出错", e);
112         }
113         return token;
114     }
115 
116         /**
117      * 移除缓存
118      *
119      * @param key
120      */
121     public static void remove(Long key) {
122         try {
123             GLOBAL_CACHE.invalidate(key);
124         } catch (Exception e) {
125             log.error("移除缓存出错", e);
126         }
127     }
128 
129     /**
130      * 批量移除缓存
131      *
132      * @param keys
133      */
134     public static void removeAll(Iterable keys) {
135         try {
136             GLOBAL_CACHE.invalidateAll(keys);
137         } catch (Exception e) {
138             log.error("批量移除缓存出错", e);
139         }
140     }
141 
142     /**
143      * 清空所有缓存
144      */
145     public static void removeAll() {
146         try {
147             GLOBAL_CACHE.invalidateAll();
148         } catch (Exception e) {
149             log.error("清空所有缓存出错", e);
150         }
151     }
152 
153     /**
154      * 获取缓存项数量
155      *
156      * @return
157      */
158     public static long size() {
159         long size = 0;
160         try {
161             size = GLOBAL_CACHE.size();
162         } catch (Exception e) {
163             log.error("获取缓存项数量出错", e);
164         }
165         return size;
166     }
167 }

 

总结

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在文档上有说明：If expireAfterWrite or expireAfterAccess is requested entries may be evicted on each cache modification, on occasional cache accesses, or on calls to Cache.cleanUp(). Expired entries may be counted in Cache.size(), but will never be visible to read or write operations. 翻译过来大概的意思是：CacheBuilder构建的缓存不会在特定时间自动执行清理和回收工作，也不会在某个缓存项过期后马上清理，它不会启动一个线程来进行缓存维护，因为a）线程相对较重，b）某些环境限制线程的创建。它会在写操作时顺带做少量的维护工作，或者偶尔在读操作时做。当然，也可以创建自己的维护线程，以固定的时间间隔调用Cache.cleanUp()。

 

转载于:https://www.cnblogs.com/xhq1024/p/11174775.html