资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/Guava学习：Cache缓存入门

Guava学习：Cache缓存入门

xingpingz / 2609人阅读

摘要：并且添加了监听器，当数据被删除后会打印日志。六总结回顾缓存加载显示插入缓存回收，定时，，软弱引用，显示删除接口方法，监听器清理缓存时间只有在获取数据时才或清理缓存，使用者可以单起线程采用方法主动清理。

</>复制代码 
  1. 摘要: 学习Google内部使用的工具包Guava，在Java项目中轻松地增加缓存，提高程序获取数据的效率。
一、什么是缓存？

根据科普中国的定义，缓存就是数据交换的缓冲区（称作Cache），当某一硬件要读取数据时，会首先从缓存中查找需要的数据，如果找到了则直接执行，找不到的话则从内存中找。由于缓存的运行速度比内存快得多，故缓存的作用就是帮助硬件更快地运行。

在这里，我们借用了硬件缓存的概念，当在Java程序中计算或查询数据的代价很高，并且对同样的计算或查询条件需要不止一次获取数据的时候，就应当考虑使用缓存。换句话说，缓存就是以空间换时间，大部分应用在各种IO，数据库查询等耗时较长的应用当中。

二、缓存原理

当获取数据时，程序将先从一个存储在内存中的数据结构中获取数据。如果数据不存在，则在磁盘或者数据库中获取数据并存入到数据结构当中。之后程序需要再次获取数据时，则会先查询这个数据结构。从内存中获取数据时间明显小于通过IO获取数据，这个数据结构就是缓存的实现。

这里引入一个概念，缓存命中率：从缓存中获取到数据的次数/全部查询次数，命中率越高说明这个缓存的效率好。由于机器内存的限制，缓存一般只能占据有限的内存大小，缓存需要不定期的删除一部分数据，从而保证不会占据大量内存导致机器崩溃。

如何提高命中率呢？那就得从删除一部分数据着手了。目前有三种删除数据的方式，分别是：FIFO（先进先出）、LFU（定期淘汰最少使用次数）、LRU（淘汰最长时间未被使用）。

三、GuavaCache工作方式

GuavaCache的工作流程：获取数据->如果存在，返回数据->计算获取数据->存储返回。由于特定的工作流程，使用者必须在创建Cache或者获取数据时指定不存在数据时应当怎么获取数据。GuavaCache采用LRU的工作原理，使用者必须指定缓存数据的大小，当超过缓存大小时，必定引发数据删除。GuavaCache还可以让用户指定缓存数据的过期时间，刷新时间等等很多有用的功能。

四、GuavaCache使用Demo 4.1 简单使用

有人说我就想简简单单的使用cache，就像Map那样方便就行。接下来展示一段简单的使用方式。

首先定义一个需要存储的Bean，对象Man：

</>复制代码 
  1. /**
  2.  * @author jiangmitiao
  3.  * @version V1.0
  4.  * @Title: 标题
  5.  * @Description: Bean
  6.  * @date 2016/10/27 10:01
  7.  */
  8. public class Man {
  9.     //身份证号
  10.     private String id;
  11.     //姓名
  12.     private String name;
  13.     public String getId() {
  14.         return id;
  15.     }
  16.     public void setId(String id) {
  17.         this.id = id;
  18.     }
  19.     public String getName() {
  20.         return name;
  21.     }
  22.     public void setName(String name) {
  23.         this.name = name;
  24.     }
  25.     @Override
  26.     public String toString() {
  27.         return "Man{" +
  28.                 "id="" + id + """ +
  29.                 ", name="" + name + """ +
  30.                 "}";
  31.     }
  32. }

接下来我们写一个Demo：

</>复制代码 
  1. import com.google.common.cache.*;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import java.util.concurrent.*;
  5. /**
  6.  * @author jiangmitiao
  7.  * @version V1.0
  8.  * @Description: Demo
  9.  * @date 2016/10/27 10:00
  10.  */
  11. public class GuavaCachDemo {
  12.     private LoadingCache loadingCache;
  13.     //loadingCache
  14.     public void InitLoadingCache() {
  15.         //指定一个如果数据不存在获取数据的方法
  16.         CacheLoader cacheLoader = new CacheLoader() {
  17.             @Override
  18.             public Man load(String key) throws Exception {
  19.                 //模拟mysql操作
  20.                 Logger logger = LoggerFactory.getLogger("LoadingCache");
  21.                 logger.info("LoadingCache测试 从mysql加载缓存ing...(2s)");
  22.                 Thread.sleep(2000);
  23.                 logger.info("LoadingCache测试 从mysql加载缓存成功");
  24.                 Man tmpman = new Man();
  25.                 tmpman.setId(key);
  26.                 tmpman.setName("其他人");
  27.                 if (key.equals("001")) {
  28.                     tmpman.setName("张三");
  29.                     return tmpman;
  30.                 }
  31.                 if (key.equals("002")) {
  32.                     tmpman.setName("李四");
  33.                     return tmpman;
  34.                 }
  35.                 return tmpman;
  36.             }
  37.         };
  38.         //缓存数量为1，为了展示缓存删除效果
  39.         loadingCache = CacheBuilder.newBuilder().maximumSize(1).build(cacheLoader);
  40.     }
  41.     //获取数据，如果不存在返回null
  42.     public Man getIfPresentloadingCache(String key){
  43.         return loadingCache.getIfPresent(key);
  44.     }
  45.     //获取数据，如果数据不存在则通过cacheLoader获取数据，缓存并返回
  46.     public Man getCacheKeyloadingCache(String key){
  47.         try {
  48.             return loadingCache.get(key);
  49.         } catch (ExecutionException e) {
  50.             e.printStackTrace();
  51.         }
  52.         return null;
  53.     }
  54.     //直接向缓存put数据
  55.     public void putloadingCache(String key,Man value){
  56.         Logger logger = LoggerFactory.getLogger("LoadingCache");
  57.         logger.info("put key :{} value : {}",key,value.getName());
  58.         loadingCache.put(key,value);
  59.     }
  60. }

接下来，我们写一些测试方法，检测一下

</>复制代码 
  1. public class Test {
  2.     public static void main(String[] args){
  3.         GuavaCachDemo cachDemo = new GuavaCachDemo()
  4.         System.out.println("使用loadingCache");
  5.         cachDemo.InitLoadingCache();
  6.         System.out.println("使用loadingCache get方法  第一次加载");
  7.         Man man = cachDemo.getCacheKeyloadingCache("001");
  8.         System.out.println(man);
  9.         System.out.println("
  10. 使用loadingCache getIfPresent方法  第一次加载");
  11.         man = cachDemo.getIfPresentloadingCache("002");
  12.         System.out.println(man);
  13.         System.out.println("
  14. 使用loadingCache get方法  第一次加载");
  15.         man = cachDemo.getCacheKeyloadingCache("002");
  16.         System.out.println(man);
  17.         System.out.println("
  18. 使用loadingCache get方法  已加载过");
  19.         man = cachDemo.getCacheKeyloadingCache("002");
  20.         System.out.println(man);
  21.         System.out.println("
  22. 使用loadingCache get方法  已加载过,但是已经被剔除掉,验证重新加载");
  23.         man = cachDemo.getCacheKeyloadingCache("001");
  24.         System.out.println(man);
  25.         System.out.println("
  26. 使用loadingCache getIfPresent方法  已加载过");
  27.         man = cachDemo.getIfPresentloadingCache("001");
  28.         System.out.println(man);
  29.         System.out.println("
  30. 使用loadingCache put方法  再次get");
  31.         Man newMan = new Man();
  32.         newMan.setId("001");
  33.         newMan.setName("额外添加");
  34.         cachDemo.putloadingCache("001",newMan);
  35.         man = cachDemo.getCacheKeyloadingCache("001");
  36.         System.out.println(man);
  37.     }
  38. }

测试结果如下：

4.2 高级特性 
</>复制代码 
  1. 由于目前使用有局限性，接下来只讲我用到的一些方法。

我来演示一下GuavaCache自带的两个Cache

</>复制代码 
  1. GuavaCacheDemo.java
  2. import com.google.common.cache.*;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import java.util.concurrent.*;
  6. /**
  7.  * @author jiangmitiao
  8.  * @version V1.0
  9.  * @Description: Demo
  10.  * @date 2016/10/27 10:00
  11.  */
  12. public class GuavaCachDemo {
  13.     private Cache cache;
  14.     private LoadingCache loadingCache;
  15.     private RemovalListener removalListener;
  16.     public void Init(){
  17.         //移除key-value监听器
  18.         removalListener = new RemovalListener(){
  19.             public void onRemoval(RemovalNotification notification) {
  20.                 Logger logger = LoggerFactory.getLogger("RemovalListener");
  21.                 logger.info(notification.getKey()+"被移除");
  22.                 //可以在监听器中获取key,value,和删除原因
  23.                 notification.getValue();
  24.                 notification.getCause();//EXPLICIT、REPLACED、COLLECTED、EXPIRED、SIZE
  25.             }};
  26.         //可以使用RemovalListeners.asynchronous方法将移除监听器设为异步方法
  27.         //removalListener = RemovalListeners.asynchronous(removalListener, new ThreadPoolExecutor(1,1,1000, TimeUnit.MINUTES,new ArrayBlockingQueue(1)));
  28.     }
  29.     //loadingCache
  30.     public void InitLoadingCache() {
  31.         //指定一个如果数据不存在获取数据的方法
  32.         CacheLoader cacheLoader = new CacheLoader() {
  33.             @Override
  34.             public Man load(String key) throws Exception {
  35.                 //模拟mysql操作
  36.                 Logger logger = LoggerFactory.getLogger("LoadingCache");
  37.                 logger.info("LoadingCache测试 从mysql加载缓存ing...(2s)");
  38.                 Thread.sleep(2000);
  39.                 logger.info("LoadingCache测试 从mysql加载缓存成功");
  40.                 Man tmpman = new Man();
  41.                 tmpman.setId(key);
  42.                 tmpman.setName("其他人");
  43.                 if (key.equals("001")) {
  44.                     tmpman.setName("张三");
  45.                     return tmpman;
  46.                 }
  47.                 if (key.equals("002")) {
  48.                     tmpman.setName("李四");
  49.                     return tmpman;
  50.                 }
  51.                 return tmpman;
  52.             }
  53.         };
  54.         //缓存数量为1，为了展示缓存删除效果
  55.         loadingCache = CacheBuilder.newBuilder().
  56.                 //设置2分钟没有获取将会移除数据
  57.                 expireAfterAccess(2, TimeUnit.MINUTES).
  58.                 //设置2分钟没有更新数据则会移除数据
  59.                 expireAfterWrite(2, TimeUnit.MINUTES).
  60.                 //每1分钟刷新数据
  61.                 refreshAfterWrite(1,TimeUnit.MINUTES).
  62.                 //设置key为弱引用
  63.                 weakKeys().
  64. //                weakValues().//设置存在时间和刷新时间后不能再次设置
  65. //                softValues().//设置存在时间和刷新时间后不能再次设置
  66.                 maximumSize(1).
  67.                 removalListener(removalListener).
  68.                 build(cacheLoader);
  69.     }
  70.     //获取数据，如果不存在返回null
  71.     public Man getIfPresentloadingCache(String key){
  72.         return loadingCache.getIfPresent(key);
  73.     }
  74.     //获取数据，如果数据不存在则通过cacheLoader获取数据，缓存并返回
  75.     public Man getCacheKeyloadingCache(String key){
  76.         try {
  77.             return loadingCache.get(key);
  78.         } catch (ExecutionException e) {
  79.             e.printStackTrace();
  80.         }
  81.         return null;
  82.     }
  83.     //直接向缓存put数据
  84.     public void putloadingCache(String key,Man value){
  85.         Logger logger = LoggerFactory.getLogger("LoadingCache");
  86.         logger.info("put key :{} value : {}",key,value.getName());
  87.         loadingCache.put(key,value);
  88.     }
  89.     public void InitDefault() {
  90.         cache = CacheBuilder.newBuilder().
  91.                 expireAfterAccess(2, TimeUnit.MINUTES).
  92.                 expireAfterWrite(2, TimeUnit.MINUTES).
  93. //                refreshAfterWrite(1,TimeUnit.MINUTES).//没有cacheLoader的cache不能设置刷新，因为没有指定获取数据的方式
  94.                 weakKeys().
  95. //                weakValues().//设置存在时间和刷新时间后不能再次设置
  96. //                softValues().//设置存在时间和刷新时间后不能再次设置
  97.                 maximumSize(1).
  98.                 removalListener(removalListener).
  99.                 build();
  100.     }
  101.     public Man getIfPresentCache(String key){
  102.         return cache.getIfPresent(key);
  103.     }
  104.     public Man getCacheKeyCache(final String key) throws ExecutionException {
  105.         return cache.get(key, new Callable() {
  106.             public Man call() throws Exception {
  107.                 //模拟mysql操作
  108.                 Logger logger = LoggerFactory.getLogger("Cache");
  109.                 logger.info("Cache测试 从mysql加载缓存ing...(2s)");
  110.                 Thread.sleep(2000);
  111.                 logger.info("Cache测试 从mysql加载缓存成功");
  112.                 Man tmpman = new Man();
  113.                 tmpman.setId(key);
  114.                 tmpman.setName("其他人");
  115.                 if (key.equals("001")) {
  116.                     tmpman.setName("张三");
  117.                     return tmpman;
  118.                 }
  119.                 if (key.equals("002")) {
  120.                     tmpman.setName("李四");
  121.                     return tmpman;
  122.                 }
  123.                 return tmpman;
  124.             }
  125.         });
  126.     }
  127.     public void putCache(String key,Man value){
  128.         Logger logger = LoggerFactory.getLogger("Cache");
  129.         logger.info("put key :{} value : {}",key,value.getName());
  130.         cache.put(key,value);
  131.     }
  132. }

在这个demo中，分别采用了Guava自带的两个Cache：LocalLoadingCache和LocalManualCache。并且添加了监听器，当数据被删除后会打印日志。

Main：

</>复制代码 
  1. public static void main(String[] args){
  2.     GuavaCachDemo cachDemo = new GuavaCachDemo();
  3.     cachDemo.Init();
  4.     System.out.println("使用loadingCache");
  5.     cachDemo.InitLoadingCache();
  6.     System.out.println("使用loadingCache get方法  第一次加载");
  7.     Man man = cachDemo.getCacheKeyloadingCache("001");
  8.     System.out.println(man);
  9.     System.out.println("
  10. 使用loadingCache getIfPresent方法  第一次加载");
  11.     man = cachDemo.getIfPresentloadingCache("002");
  12.     System.out.println(man);
  13.     System.out.println("
  14. 使用loadingCache get方法  第一次加载");
  15.     man = cachDemo.getCacheKeyloadingCache("002");
  16.     System.out.println(man);
  17.     System.out.println("
  18. 使用loadingCache get方法  已加载过");
  19.     man = cachDemo.getCacheKeyloadingCache("002");
  20.     System.out.println(man);
  21.     System.out.println("
  22. 使用loadingCache get方法  已加载过,但是已经被剔除掉,验证重新加载");
  23.     man = cachDemo.getCacheKeyloadingCache("001");
  24.     System.out.println(man);
  25.     System.out.println("
  26. 使用loadingCache getIfPresent方法  已加载过");
  27.     man = cachDemo.getIfPresentloadingCache("001");
  28.     System.out.println(man);
  29.     System.out.println("
  30. 使用loadingCache put方法  再次get");
  31.     Man newMan = new Man();
  32.     newMan.setId("001");
  33.     newMan.setName("额外添加");
  34.     cachDemo.putloadingCache("001",newMan);
  35.     man = cachDemo.getCacheKeyloadingCache("001");
  36.     System.out.println(man);
  37.     ///////////////////////////////////
  38.     System.out.println("
  39. 使用Cache");
  40.     cachDemo.InitDefault();
  41.     System.out.println("使用Cache get方法  第一次加载");
  42.     try {
  43.         man = cachDemo.getCacheKeyCache("001");
  44.     } catch (ExecutionException e) {
  45.         e.printStackTrace();
  46.     }
  47.     System.out.println(man);
  48.     System.out.println("
  49. 使用Cache getIfPresent方法  第一次加载");
  50.     man = cachDemo.getIfPresentCache("002");
  51.     System.out.println(man);
  52.     System.out.println("
  53. 使用Cache get方法  第一次加载");
  54.     try {
  55.         man = cachDemo.getCacheKeyCache("002");
  56.     } catch (ExecutionException e) {
  57.         e.printStackTrace();
  58.     }
  59.     System.out.println(man);
  60.     System.out.println("
  61. 使用Cache get方法  已加载过");
  62.     try {
  63.         man = cachDemo.getCacheKeyCache("002");
  64.     } catch (ExecutionException e) {
  65.         e.printStackTrace();
  66.     }
  67.     System.out.println(man);
  68.     System.out.println("
  69. 使用Cache get方法  已加载过,但是已经被剔除掉,验证重新加载");
  70.     try {
  71.         man = cachDemo.getCacheKeyCache("001");
  72.     } catch (ExecutionException e) {
  73.         e.printStackTrace();
  74.     }
  75.     System.out.println(man);
  76.     System.out.println("
  77. 使用Cache getIfPresent方法  已加载过");
  78.     man = cachDemo.getIfPresentCache("001");
  79.     System.out.println(man);
  80.     System.out.println("
  81. 使用Cache put方法  再次get");
  82.     Man newMan1 = new Man();
  83.     newMan1.setId("001");
  84.     newMan1.setName("额外添加");
  85.     cachDemo.putloadingCache("001",newMan1);
  86.     man = cachDemo.getCacheKeyloadingCache("001");
  87.     System.out.println(man);
  88. }

测试结果如下：

由上述结果可以表明，GuavaCache可以在数据存储到达指定大小后删除数据结构中的数据。我们可以设置定期删除而达到定期从数据库、磁盘等其他地方更新数据等（再次访问时数据不存在重新获取）。也可以采用定时刷新的方式更新数据。

还可以设置移除监听器对被删除的数据进行一些操作。通过RemovalListeners.asynchronous(RemovalListener,Executor)方法将监听器设为异步，笔者通过实验发现，异步监听不会在删除数据时立刻调用监听器方法。

五、GuavaCache结构初探

类结构图

GuavaCache并不希望我们设置复杂的参数，而让我们采用建造者模式创建Cache。GuavaCache分为两种Cache:Cache，LoadingCache。LoadingCache继承了Cache，他比Cache主要多了get和refresh方法。多这两个方法能干什么呢？

在第四节高级特性demo中，我们看到builder生成不带CacheLoader的Cache实例。在类结构图中其实是生成了LocalManualCache类实例。而带CacheLoader的Cache实例生成的是LocalLoadingCache。他可以定时刷新数据，因为获取数据的方法已经作为构造参数方法存入了Cache实例中。同样，在get时，不需要像LocalManualCache还需要传入一个Callable实例。

实际上，这两个Cache实现类都继承自LocalCache，大部分实现都是父类做的。

六、总结回顾

缓存加载：CacheLoader、Callable、显示插入(put)

缓存回收：LRU，定时(expireAfterAccess，expireAfterWrite)，软弱引用，显示删除(Cache接口方法invalidate，invalidateAll)

监听器：CacheBuilder.removalListener(RemovalListener)

清理缓存时间：只有在获取数据时才或清理缓存LRU，使用者可以单起线程采用Cache.cleanUp()方法主动清理。

刷新：主动刷新方法LoadingCache.referesh(K)

信息统计：CacheBuilder.recordStats() 开启Guava Cache的统计功能。Cache.stats() 返回CacheStats对象。（其中包括命中率等相关信息）

获取当前缓存所有数据：cache.asMap()，cache.asMap().get(Object)会刷新数据的访问时间（影响的是：创建时设置的在多久没访问后删除数据）

LocalManualCache和LocalLoadingCache的选择

ManualCache可以在get时动态设置获取数据的方法，而LoadingCache可以定时刷新数据。如何取舍？我认为在缓存数据有很多种类的时候采用第一种cache。而数据单一，数据库数据会定时刷新时采用第二种cache。

具体工程中的情况也欢迎大家与我交流，互相学习。

参考资料：

http://www.cnblogs.com/peida/...

https://github.com/tiantianga...

http://www.blogjava.net/DLevi...

http://ifeve.com/google-guava...

更多文章：http://blog.gavinzh.com

云服务器 GPU云服务器 Guava 编程学习入门学习 学习机器学习入门 学习入门

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/61831.html

相关文章

  • Guava学习：Cache缓存

    摘要：并且添加了监听器，当数据被删除后会打印日志。六总结回顾缓存加载显示插入缓存回收，定时，，软弱引用，显示删除接口方法，监听器清理缓存时间只有在获取数据时才或清理缓存，使用者可以单起线程采用方法主动清理。 摘要: 学习Google内部使用的工具包Guava，在Java项目中轻松地增加缓存，提高程序获取数据的效率。一、什么是缓存？根据科普中国的定义，缓存就是数据交换的缓冲区（称作Cache）...

    PumpkinDylan 评论0 收藏0

  • Guava 源码分析（Cache 原理【二阶段】）

    摘要：前言在上文源码分析原理中分析了的相关原理。我在北京模拟执行你在哪儿回复最后执行结果开始提问提问完毕，我去干其他事了收到消息你在哪儿等待响应中。。。。。回复我在北京这样一个模拟的异步事件回调就完成了。 showImg(https://segmentfault.com/img/remote/1460000015643387?w=2048&h=1150); 前言 在上文「Guava 源码分析...

    msup 评论0 收藏0

  • Guava 源码分析（Cache 原理【二阶段】）

    摘要：前言在上文源码分析原理中分析了的相关原理。我在北京模拟执行你在哪儿回复最后执行结果开始提问提问完毕，我去干其他事了收到消息你在哪儿等待响应中。。。。。回复我在北京这样一个模拟的异步事件回调就完成了。 showImg(https://segmentfault.com/img/remote/1460000015643387?w=2048&h=1150); 前言 在上文「Guava 源码分析...

    dack 评论0 收藏0

  • 集中式内存缓存 Guava Cache

    摘要：缓存总体可分为两种集中式缓存和分布式缓存集中式缓存与分布式缓存的区别其实就在于集中与非集中的概念，其对象可能是服务器内存条硬盘等。内存条版本缓存集中在一台服务器的一条内存条上，为集中式缓存。 背景 缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日长开发有很多场合，有一些数据量不是很大，不会经常改动，并且访问非常频繁。但是由于受限于硬盘IO的性能或者远程...

    Dean 评论0 收藏0

  • 集中式内存缓存 Guava Cache

    摘要：缓存总体可分为两种集中式缓存和分布式缓存集中式缓存与分布式缓存的区别其实就在于集中与非集中的概念，其对象可能是服务器内存条硬盘等。内存条版本缓存集中在一台服务器的一条内存条上，为集中式缓存。 背景 缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日长开发有很多场合，有一些数据量不是很大，不会经常改动，并且访问非常频繁。但是由于受限于硬盘IO的性能或者远程...

    KitorinZero 评论0 收藏0

发表评论

登陆后可评论

0条评论

xingpingz

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<