Java Cache 缓存方案详解及代码-Guava Cache

最新推荐文章于 2024-04-20 16:30:08 发布

Java毕业项目分享师

最新推荐文章于 2024-04-20 16:30:08 发布

阅读量767

点赞数 19

分类专栏： JAVA专栏文章标签： java 缓存 guava spring boot spring 后端

本文链接：https://blog.csdn.net/mh1121681298/article/details/136863921

版权

JAVA专栏专栏收录该内容

92 篇文章 1 订阅

订阅专栏

Java Cache 缓存方案详解及代码-Guava Cache

一、概念

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)方法。这个方法返回缓存中相应的值，或者用给定的Callable运算并把结果加入到缓存中。在整个加载方法完成前，缓存项相关的可观察状态都不会更改。这个方法简便地实现了模式"如果有缓存则返回;否则运算、缓存、然后返回"

三、开发实例：

依赖引入：

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

CacheLoader方式使用：

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());
}

Callable方式使用：

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);
             }
           });

Guava Cache缓存回收-定时回收

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);

Guava Cache刷新

刷新和回收不太一样。正如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;
               }
             }
           });