一、 概念

Google Guava Cache是一种非常优秀本地缓存解决方案，提供了基于容量，时间和引用的缓存回收方式。guava cache是运行在JVM的本地缓存，并不能把数据存放到外部服务器上。如果有这样的要求，因该尝试Memcached或 Redis这类分布式缓存。

基于容量的方式内部实现采用LRU算法，基于引用回收很好的利用了Java 虚拟机的垃圾回收机制。

Guava Cache与ConcurrentMap很相似，但也不完全一样。最基本的区别是ConcurrentMap会一直保存所有添加的元素，直到显式地移除。Guava Cache为了限制内存占用，通常都设定为自动回收元素。Guava Cache 的优点是封装了get，put操作；提供线程安全的缓存操作；提供过期策略；提供回收策略；缓存监控。当缓存的数据超过最大值时，使用LRU算法替换。

二、Guava Cache 加载方式：加载方式1 - CacheLoader

LoadingCache是附带CacheLoader构建而成的缓存实现。创建自己的CacheLoader通常只需要简单地实现V load(K key) throws Exception方法

加载方式2 - Callable

所有类型的Guava Cache，不管有没有自动加载功能，都支持get(K,Callable<V>)方法。这个方法返回缓存中相应的值，或者用给定的Callable运算并把结果加入到缓存中。在整个加载方法完成前，缓存项相关的可观察状态都不会更改。这个方法简便地实现了模式"如果有缓存则返回;否则运算、缓存、然后返回"

三、开发实例：依赖引入：

  <dependencies>        <!--  -->        <dependency>            <groupId>com.google.guava</groupId>            <artifactId>guava</artifactId>            <version>31.1-jre</version>        </dependency>    </dependencies>

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()       .maximumSize(1000)       .build(           new CacheLoader<Key, Graph>() {             public Graph load(Key key) throws AnyException {               return createExpensiveGraph(key);             }           });...try {  return graphs.get(key);} catch (ExecutionException e) {  throw new OtherException(e.getCause());}

Cache<Key, Value> cache = CacheBuilder.newBuilder()    .maximumSize(1000)    .build(); // look Ma, no CacheLoader...try {  // If the key wasn't in the "easy to compute" group, we need to  // do things the hard way.  cache.get(key, new Callable<Value>() {    @Override    public Value call() throws AnyException {      return doThingsTheHardWay(key);    }  });} catch (ExecutionException e) {  throw new OtherException(e.getCause());}

基于容量回收

如果要规定缓存项的数目不超过固定值，只需使用CacheBuilder.maximumSize(long)在缓存项的数目达到限定值之前，缓存就可能进行回收操作，通常发生在缓存项的数目逼近限定值时另外不同的缓存项有不同的“权重”（weights）-例如：如果你的缓存值，占据完全不同的内存空间，可以使用CacheBuilder.weigher(Weigher)指定一个权重函数，并且用acheBuilder.maximumWeight(long)指定最大总重

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()       .maximumWeight(100000)       .weigher(new Weigher<Key, Graph>() {          public int weigh(Key k, Graph g) {            return g.vertices().size();          }        })       .build(           new CacheLoader<Key, Graph>() {             public Graph load(Key key) { // no checked exception               return createExpensiveGraph(key);             }           });

CacheBuilder提供两种定时回收的方法：

expireAfterAccess(long,TimeUnit):缓存项在给定时间内没有被读/写访问，则回收

expireAfterWriter(long,TimeUnit):缓存项在给定时间内没有被写访问(创建或覆盖)

Guava Cache添加移除监听器

可以为Cache对象添加一个移除监听器，以便缓存被移除时做一些额外操作。

缓存项被移除时，RemovalListener会获取通知RemovalNotification,其中包含移除原因RemovalCause、键和值

CacheLoader<Key, DatabaseConnection> loader = new CacheLoader<Key, DatabaseConnection> () {  public DatabaseConnection load(Key key) throws Exception {    return openConnection(key);  }};RemovalListener<Key, DatabaseConnection> removalListener = new RemovalListener<Key, DatabaseConnection>() {  public void onRemoval(RemovalNotification<Key, DatabaseConnection> removal) {    DatabaseConnection conn = removal.getValue();    conn.close(); // tear down properly  }};return CacheBuilder.newBuilder()  .expireAfterWrite(2, TimeUnit.MINUTES)  .removalListener(removalListener)  .build(loader);

刷新和回收不太一样。正如LoadingCache.refresh(K)所声明，刷新表示为键加载新值，这个过程可以是异步的。在刷新操作进行时，缓存仍然可以向其他线程返回旧值，而不像回收操作，读缓存的线程必须等待新值加载完成。在进行缓存定时刷新时，需要指定缓存的刷新间隔，和一个用来加载缓存的CacheLoader,当达到刷新时间间隔后，下一次获取缓存时，会调用CacheLoader的load方法刷新缓存

// Some keys don't need refreshing, and we want refreshes to be done asynchronously.LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()       .maximumSize(1000)       .refreshAfterWrite(1, TimeUnit.MINUTES)       .build(           new CacheLoader<Key, Graph>() {             public Graph load(Key key) { // no checked exception               return getGraphFromDatabase(key);             }             public ListenableFuture<Graph> reload(final Key key, Graph prevGraph) {               if (neverNeedsRefresh(key)) {                 return Futures.immediateFuture(prevGraph);               } else {                 // asynchronous!                 ListenableFutureTask<Graph> task = ListenableFutureTask.create(new Callable<Graph>() {                   public Graph call() {                     return getGraphFromDatabase(key);                   }                 });                 executor.execute(task);                 return task;               }             }           });

官网：

大家好，我是Doker品牌的Sinbad,欢迎点赞和评论,您的鼓励是我们持续更新的动力！更多资料请前往Doker 多克