Guava Cache用法介绍

背景

缓存的主要做用是暂时在内存中保存业务系统的数据处理结果，而且等待下次访问使用。在日长开发有不少场合，有一些数据量不是很大，不会常常改动，而且访问很是频繁。可是因为受限于硬盘IO的性能或者远程网络等缘由获取可能很是的费时。会致使咱们的程序很是缓慢，这在某些业务上是不能忍的！而缓存正是解决这类问题的神器！

 

固然也并非说你用了缓存你的系统就必定会变快，建议在用以前看一下使用缓存的9大误区(上) 使用缓存的9大误区(下)

缓存在不少系统和架构中都用普遍的应用,例如：

• CPU缓存
• 操做系统缓存
• HTTP缓存
• 数据库缓存
• 静态文件缓存
• 本地缓存
• 分布式缓存

能够说在计算机和网络领域，缓存是无处不在的。能够这么说，只要有硬件性能不对等，涉及到网络传输的地方都会有缓存的身影。

缓存整体可分为两种 集中式缓存 和 分布式缓存

“集中式缓存"与"分布式缓存"的区别其实就在于“集中”与"非集中"的概念，其对象多是服务器、内存条、硬盘等。好比：

1.服务器版本：

• 缓存集中在一台服务器上，为集中式缓存。
• 缓存分散在不一样的服务器上，为分布式缓存。

2.内存条版本：

• 缓存集中在一台服务器的一条内存条上，为集中式缓存。
• 缓存分散在一台服务器的不一样内存条上，为分布式缓存。

3.硬盘版本：

• 缓存集中在一台服务器的一个硬盘上，为集中式缓存。
• 缓存分散在一台服务器的不一样硬盘上，为分布式缓存。

想了解分布式缓存能够看一下浅谈分布式缓存那些事儿。

这是几个当前比较流行的java 分布式缓存框架5个强大的Java分布式缓存框架推荐。

而咱们今天要讲的是集中式内存缓存guava cache,这是当前咱们项目正在用的缓存工具，研究一下感受还蛮好用的。固然也有不少其余工具，仍是看我的喜欢。oschina上面也有不少相似开源的java缓存框架

正文

Guava Cache与ConcurrentMap很类似，但也不彻底同样。最基本的区别是ConcurrentMap会一直保存全部添加的元素，直到显式地移除。相对地，Guava Cache为了限制内存占用，一般都设定为自动回收元素。在某些场景下，尽管LoadingCache 不回收元素，它也是颇有用的，由于它会自动加载缓存。

Guava Cache是在内存中缓存数据，相比较于数据库或redis存储，访问内存中的数据会更加高效。Guava官网介绍，下面的这几种状况能够考虑使用Guava Cache：

1. 愿意消耗一些内存空间来提高速度。

2. 预料到某些键会被屡次查询。

3. 缓存中存放的数据总量不会超出内存容量。

因此，能够将程序频繁用到的少许数据存储到Guava Cache中，以改善程序性能。下面对Guava Cache的用法进行详细的介绍。

构建缓存对象

接口Cache表明一块缓存，它有以下方法：

 1 public interface Cache<K, V> {
 2     V get(K key, Callable<? extends V> valueLoader) throws ExecutionException;
 3 
 4     ImmutableMap<K, V> getAllPresent(Iterable<?> keys);
 5 
 6     void put(K key, V value);
 7 
 8     void putAll(Map<? extends K, ? extends V> m);
 9 
10     void invalidate(Object key);
11 
12     void invalidateAll(Iterable<?> keys);
13 
14     void invalidateAll();
15 
16     long size();
17 
18     CacheStats stats();
19 
20     ConcurrentMap<K, V> asMap();
21 
22     void cleanUp();
23 }

能够经过CacheBuilder类构建一个缓存对象，CacheBuilder类采用builder设计模式，它的每一个方法都返回CacheBuilder自己，直到build方法被调用。构建一个缓存对象代码以下。

1 public class StudyGuavaCache {
2     public static void main(String[] args) {
3         Cache<String,String> cache = CacheBuilder.newBuilder().build();
4         cache.put("word","Hello Guava Cache");
5         System.out.println(cache.getIfPresent("word"));
6     }
7 }

上面的代码经过CacheBuilder.newBuilder().build()这句代码建立了一个Cache缓存对象，并在缓存对象中存储了key为word，value为Hello Guava Cache的一条记录。能够看到Cache很是相似于JDK中的Map，可是相比于Map，Guava Cache提供了不少更强大的功能。

从LoadingCache查询的正规方式是使用 get(K)方法。这个方法要么返回已经缓存的值，要么使用CacheLoader向缓存原子地加载新值（经过 load(String key) 方法加载）。因为CacheLoader可能抛出异常， LoadingCache.get(K)也声明抛出ExecutionException异常。若是你定义的CacheLoader没有声明任何检查型异常，则能够经过 getUnchecked(K)查找缓存；但必须注意，一旦CacheLoader声明了检查型异常，就不能够调用 getUnchecked(K)。

 1 LoadingCache<Key, Value> cache = CacheBuilder.newBuilder()
 2        .build(
 3            new CacheLoader<Key, Value>() {
 4              public Value load(Key key) throws AnyException {
 5                return createValue(key);
 6              }
 7            });
 8 ...
 9 try {
10   return cache.get(key);
11 } catch (ExecutionException e) {
12   throw new OtherException(e.getCause());
13 } 

设置最大存储

Guava Cache能够在构建缓存对象时指定缓存所可以存储的最大记录数量。当Cache中的记录数量达到最大值后再调用put方法向其中添加对象，Guava会先从当前缓存的对象记录中选择一条删除掉，腾出空间后再将新的对象存储到Cache中。

 1 public class StudyGuavaCache {
 2     public static void main(String[] args) {
 3         Cache<String,String> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(2)
 5                 .build();
 6         cache.put("key1","value1");
 7         cache.put("key2","value2");
 8         cache.put("key3","value3");
 9         System.out.println("第一个值：" + cache.getIfPresent("key1"));
10         System.out.println("第二个值：" + cache.getIfPresent("key2"));
11         System.out.println("第三个值：" + cache.getIfPresent("key3"));
12     }
13 }

上面代码在构造缓存对象时，经过CacheBuilder类的maximumSize方法指定Cache最多能够存储两个对象，而后调用Cache的put方法向其中添加了三个对象。程序执行结果以下图所示，能够看到第三条对象记录的插入，致使了第一条对象记录被删除。

设置过时时间

在构建Cache对象时，能够经过CacheBuilder类的expireAfterAccess和expireAfterWrite两个方法为缓存中的对象指定过时时间，过时的对象将会被缓存自动删除。其中，expireAfterWrite方法指定对象被写入到缓存后多久过时，expireAfterAccess指定对象多久没有被访问后过时。

 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,String> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(2)
 5                 .expireAfterWrite(3,TimeUnit.SECONDS)
 6                 .build();
 7         cache.put("key1","value1");
 8         int time = 1;
 9         while(true) {
10             System.out.println("第" + time++ + "次取到key1的值为：" + cache.getIfPresent("key1"));
11             Thread.sleep(1000);
12         }
13     }
14 }

上面的代码在构造Cache对象时，经过CacheBuilder的expireAfterWrite方法指定put到Cache中的对象在3秒后会过时。在Cache对象中存储一条对象记录后，每隔1秒读取一次这条记录。程序运行结果以下图所示，能够看到，前三秒能够从Cache中获取到对象，超过三秒后，对象从Cache中被自动删除。

下面代码是expireAfterAccess的例子。

 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,String> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(2)
 5                 .expireAfterAccess(3,TimeUnit.SECONDS)
 6                 .build();
 7         cache.put("key1","value1");
 8         int time = 1;
 9         while(true) {
10             Thread.sleep(time*1000);
11             System.out.println("睡眠" + time++ + "秒后取到key1的值为：" + cache.getIfPresent("key1"));
12         }
13     }
14 }

经过CacheBuilder的expireAfterAccess方法指定Cache中存储的对象若是超过3秒没有被访问就会过时。while中的代码每sleep一段时间就会访问一次Cache中存储的对象key1，每次访问key1以后下次sleep的时间会加长一秒。程序运行结果以下图所示，从结果中能够看出，当超过3秒没有读取key1对象以后，该对象会自动被Cache删除。

也能够同时用expireAfterAccess和expireAfterWrite方法指定过时时间，这时只要对象知足二者中的一个条件就会被自动过时删除。

弱引用

能够经过weakKeys和weakValues方法指定Cache只保存对缓存记录key和value的弱引用。这样当没有其余强引用指向key和value时，key和value对象就会被垃圾回收器回收。

 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,Object> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(2)
 5                 .weakValues()
 6                 .build();
 7         Object value = new Object();
 8         cache.put("key1",value);
 9 
10         value = new Object();//原对象再也不有强引用
11         System.gc();
12         System.out.println(cache.getIfPresent("key1"));
13     }
14 }

上面代码的打印结果是null。构建Cache时经过weakValues方法指定Cache只保存记录值的一个弱引用。当给value引用赋值一个新的对象以后，就再也不有任何一个强引用指向原对象。System.gc()触发垃圾回收后，原对象就被清除了。

显示清除

能够调用Cache的invalidateAll或invalidate方法显示删除Cache中的记录。invalidate方法一次只能删除Cache中一个记录，接收的参数是要删除记录的key。invalidateAll方法能够批量删除Cache中的记录，当没有传任何参数时，invalidateAll方法将清除Cache中的所有记录。invalidateAll也能够接收一个Iterable类型的参数，参数中包含要删除记录的全部key值。下面代码对此作了示例。

 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,String> cache = CacheBuilder.newBuilder().build();
 4         Object value = new Object();
 5         cache.put("key1","value1");
 6         cache.put("key2","value2");
 7         cache.put("key3","value3");
 8 
 9         List<String> list = new ArrayList<String>();
10         list.add("key1");
11         list.add("key2");
12 
13         cache.invalidateAll(list);//批量清除list中所有key对应的记录
14         System.out.println(cache.getIfPresent("key1"));
15         System.out.println(cache.getIfPresent("key2"));
16         System.out.println(cache.getIfPresent("key3"));
17     }
18 }

代码中构造了一个集合list用于保存要删除记录的key值，而后调用invalidateAll方法批量删除key1和key2对应的记录，只剩下key3对应的记录没有被删除。

移除监听器

能够为Cache对象添加一个移除监听器，这样当有记录被删除时能够感知到这个事件。

 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         RemovalListener<String, String> listener = new RemovalListener<String, String>() {
 4             public void onRemoval(RemovalNotification<String, String> notification) {
 5                 System.out.println("[" + notification.getKey() + ":" + notification.getValue() + "] is removed!");
 6             }
 7         };
 8         Cache<String,String> cache = CacheBuilder.newBuilder()
 9                 .maximumSize(3)
10                 .removalListener(listener)
11                 .build();
12         Object value = new Object();
13         cache.put("key1","value1");
14         cache.put("key2","value2");
15         cache.put("key3","value3");
16         cache.put("key4","value3");
17         cache.put("key5","value3");
18         cache.put("key6","value3");
19         cache.put("key7","value3");
20         cache.put("key8","value3");
21     }
22 }

removalListener方法为Cache指定了一个移除监听器，这样当有记录从Cache中被删除时，监听器listener就会感知到这个事件。程序运行结果以下图所示。

自动加载

Cache的get方法有两个参数，第一个参数是要从Cache中获取记录的key，第二个记录是一个Callable对象。当缓存中已经存在key对应的记录时，get方法直接返回key对应的记录。若是缓存中不包含key对应的记录，Guava会启动一个线程执行Callable对象中的call方法，call方法的返回值会做为key对应的值被存储到缓存中，而且被get方法返回。下面是一个多线程的例子：

 1 public class StudyGuavaCache {
 2 
 3     private static Cache<String,String> cache = CacheBuilder.newBuilder()
 4             .maximumSize(3)
 5             .build();
 6 
 7     public static void main(String[] args) throws InterruptedException {
 8 
 9         new Thread(new Runnable() {
10             public void run() {
11                 System.out.println("thread1");
12                 try {
13                     String value = cache.get("key", new Callable<String>() {
14                         public String call() throws Exception {
15                             System.out.println("load1"); //加载数据线程执行标志
16                             Thread.sleep(1000); //模拟加载时间
17                             return "auto load by Callable";
18                         }
19                     });
20                     System.out.println("thread1 " + value);
21                 } catch (ExecutionException e) {
22                     e.printStackTrace();
23                 }
24             }
25         }).start();
26 
27         new Thread(new Runnable() {
28             public void run() {
29                 System.out.println("thread2");
30                 try {
31                     String value = cache.get("key", new Callable<String>() {
32                         public String call() throws Exception {
33                             System.out.println("load2"); //加载数据线程执行标志
34                             Thread.sleep(1000); //模拟加载时间
35                             return "auto load by Callable";
36                         }
37                     });
38                     System.out.println("thread2 " + value);
39                 } catch (ExecutionException e) {
40                     e.printStackTrace();
41                 }
42             }
43         }).start();
44     }
45 }

这段代码中有两个线程共享同一个Cache对象，两个线程同时调用get方法获取同一个key对应的记录。因为key对应的记录不存在，因此两个线程都在get方法处阻塞。此处在call方法中调用Thread.sleep(1000)模拟程序从外存加载数据的时间消耗。代码的执行结果以下图：

从结果中能够看出，虽然是两个线程同时调用get方法，但只有一个get方法中的Callable会被执行(没有打印出load2)。Guava能够保证当有多个线程同时访问Cache中的一个key时，若是key对应的记录不存在，Guava只会启动一个线程执行get方法中Callable参数对应的任务加载数据存到缓存。当加载完数据后，任何线程中的get方法都会获取到key对应的值。

统计信息

能够对Cache的命中率、加载数据时间等信息进行统计。在构建Cache对象时，能够经过CacheBuilder的recordStats方法开启统计信息的开关。开关开启后Cache会自动对缓存的各类操做进行统计，调用Cache的stats方法能够查看统计后的信息。

 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws InterruptedException {
 3         Cache<String,String> cache = CacheBuilder.newBuilder()
 4                 .maximumSize(3)
 5                 .recordStats() //开启统计信息开关
 6                 .build();
 7         cache.put("key1","value1");
 8         cache.put("key2","value2");
 9         cache.put("key3","value3");
10         cache.put("key4","value4");
11 
12         cache.getIfPresent("key1");
13         cache.getIfPresent("key2");
14         cache.getIfPresent("key3");
15         cache.getIfPresent("key4");
16         cache.getIfPresent("key5");
17         cache.getIfPresent("key6");
18 
19         System.out.println(cache.stats()); //获取统计信息
20     }
21 }

程序执行结果以下图所示：

这些统计信息对于调整缓存设置是相当重要的，在性能要求高的应用中应该密切关注这些数据

LoadingCache

LoadingCache是Cache的子接口，相比较于Cache，当从LoadingCache中读取一个指定key的记录时，若是该记录不存在，则LoadingCache能够自动执行加载数据到缓存的操做。LoadingCache接口的定义以下：

 1 public interface LoadingCache<K, V> extends Cache<K, V>, Function<K, V> {
 2 
 3     V get(K key) throws ExecutionException;
 4 
 5     V getUnchecked(K key);
 6 
 7     ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException;
 8 
 9     V apply(K key);
10 
11     void refresh(K key);
12 
13     @Override
14     ConcurrentMap<K, V> asMap();
15 }

与构建Cache类型的对象相似，LoadingCache类型的对象也是经过CacheBuilder进行构建，不一样的是，在调用CacheBuilder的build方法时，必须传递一个CacheLoader类型的参数，CacheLoader的load方法须要咱们提供实现。当调用LoadingCache的get方法时，若是缓存不存在对应key的记录，则CacheLoader中的load方法会被自动调用从外存加载数据，load方法的返回值会做为key对应的value存储到LoadingCache中，并从get方法返回。

 1 public class StudyGuavaCache {
 2     public static void main(String[] args) throws ExecutionException {
 3         CacheLoader<String, String> loader = new CacheLoader<String, String> () {
 4             public String load(String key) throws Exception {
 5                 Thread.sleep(1000); //休眠1s，模拟加载数据
 6                 System.out.println(key + " is loaded from a cacheLoader!");
 7                 return key + "'s value";
 8             }
 9         };
10 
11         LoadingCache<String,String> loadingCache = CacheBuilder.newBuilder()
12                 .maximumSize(3)
13                 .build(loader);//在构建时指定自动加载器
14 
15         loadingCache.get("key1");
16         loadingCache.get("key2");
17         loadingCache.get("key3");
18     }
19 }

程序执行结果以下图所示：

转自：

http://www.javashuo.com/article/p-avaquyum-ht.html

https://www.jianshu.com/p/64b0df87e51b