1. 首页
  2. 文章中心
  3. java基础

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

119 阅读 0 评论
我是靠谱客的博主 殷勤大船，这篇文章主要介绍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<V>)方法。这个方法返回缓存中相应的值，或者用给定的Callable运算并把结果加入到缓存中。在整个加载方法完成前，缓存项相关的可观察状态都不会更改。这个方法简便地实现了模式"如果有缓存则返回;否则运算、缓存、然后返回"

三、开发实例：

依赖引入：
复制代码
1
2
3
4
5
6
7
8
  <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方式使用：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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方式使用：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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)指定最大总重

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
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、键和值

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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方法刷新缓存

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 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;
               }
             }
           });

官网：https://github.com/google/guava/wiki/CachesExplained

最后

以上就是殷勤大船最近收集整理的关于Java Cache 缓存方案详解及代码-Guava Cache的全部内容，更多相关Java内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(79)

相关文章

【C++】给定两个没有刻度的容器,对于任意给定的容积,求出如何只用两个瓶装出L升的水典型例子思路结束语
【C++】给定两个没有刻度的容器,对于任意给定的容积,求出如何只用两个瓶装出L升的水典型例子思路结束语
【Java面试题】利用5升和6升两个水桶得到3升水
【Java面试题】利用5升和6升两个水桶得到3升水
程序解：现有3L容器和5L容器各一个，问如何量出4L水（水无限）
程序解：现有3L容器和5L容器各一个，问如何量出4L水（水无限）
java cache_Java中常用缓存Cache机制的实现
java cache_Java中常用缓存Cache机制的实现
Java Cache 缓存方案详解及代码-Guava Cache
Java Cache 缓存方案详解及代码-Guava Cache
opython3lde_在widows下搭建python3.3的开发环境
opython3lde_在widows下搭建python3.3的开发环境
第十三届蓝桥杯大赛软件类决赛Java大学B组C题——左移右移解题思路
第十三届蓝桥杯大赛软件类决赛Java大学B组C题——左移右移解题思路
opython3l_python之 数据类型判定与类型转换
opython3l_python之 数据类型判定与类型转换

评论列表共有 0 条评论

立即
投稿
返回
顶部