Guava Cache 数据变化实现回调的监听器RemovalListener

最新推荐文章于 2023-12-15 16:09:48 发布
最新推荐文章于 2023-12-15 16:09:48 发布
阅读量8.9k 收藏 5
点赞数 2
分类专栏： Java 文章标签： Guava Cache 回调 监听器 RemovalListener
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangjikuan/article/details/76408578
版权

上一篇介绍了guava的使用，实现了项目第一个需求定期清理cache数据，第二个需求，我们需要在缓存被移除的时候，得到通知产生回调，并做一些额外处理工作。这个时候RemovalListener就派上用场了。

下面是获得所有数据改变的监听

[java]  view plain  copy
  1. public class Main {  
  2.   
  3.     // 创建一个监听器  
  4.     private static class MyRemovalListener implements RemovalListener<Integer, Integer> {  
  5.     @Override  
  6.     public void onRemoval(RemovalNotification<Integer, Integer> notification) {  
  7.         String tips = String.format("key=%s,value=%s,reason=%s", notification.getKey(), notification.getValue(), notification.getCause());  
  8.         System.out.println(tips);  
  9.     }  
  10.     }  
  11.   
  12.     public static void main(String[] args) {  
  13.   
  14.     // 创建一个带有RemovalListener监听的缓存  
  15.     Cache<Integer, Integer> cache = CacheBuilder.newBuilder().removalListener(new MyRemovalListener()).build();  
  16.   
  17.     cache.put(1, 1);  
  18.   
  19.     // 手动清除  
  20.     cache.invalidate(1);  
  21.   
  22.     System.out.println(cache.getIfPresent(1)); // null  
  23.     }  
  24.   
  25. }  

使用invalidate()清除缓存数据之后，注册的回调被触发了。



下面是只有主动删除数据使的回调

public class CacheConnection {
  
  public static RemovalListener<String, Connection> myRemovalListener = new RemovalListener<String, Connection>(){
    @Override  
    public void onRemoval(RemovalNotification<String, Connection> notification) {  
        String tips = String.format("key=%s,value=%s,reason=%s in myRemovalListener", notification.getKey(), notification.getValue(), notification.getCause());  
        System.out.println(tips);
        //when expireAfterAccess to do
        if (notification.getCause().equals("EXPIRED") && notification.getValue() != null) {
          try {
            notification.getValue().close();
          } catch (SQLException e) {
            System.out.printf("Exception in myRemovalListener:\n");
            e.printStackTrace();
          }
          
          System.out.printf("Remove %s in cacheConnection", notification.getKey());
        }
          
    }
  };
  
  public static Cache<String, Connection> cacheConnection = CacheBuilder.newBuilder()  
      //设置cache的初始大小为20000，要合理设置该值  
      .initialCapacity(20000)  
      //设置并发数为5，即同一时间最多只能有5个线程往cache执行写入操作  
      .concurrencyLevel(100)  
      //设置cache中的数据在600秒没有被读写将自动删除  
      .expireAfterAccess(600, TimeUnit.SECONDS) 
      //设置监听，当出现自动删除时的回调
      .removalListener(myRemovalListener)
      //构建cache实例  
      .build();  
  
  public static Connection getCache(String key)  {
    try {
      Connection var = cacheConnection.getIfPresent(key);
      return var;
    } catch (Exception e) {
      // TODO: handle exception
      System.out.println("the value of cacheConnection is null");
      e.printStackTrace();
      return null;
    }
  }
     
   public static void putCache(String key, Connection value) {
     cacheConnection.put(key, value);
   }
   

}


RemovalNotification中包含了缓存的key、value以及被移除的原因RemovalCause。通过源码可以看出，移除原因与容量管理方式是相对应的。下面是具体的消息

[java]  view plain  copy
  1. public enum RemovalCause {  
  2.   /** 
  3.    * The entry was manually removed by the user. This can result from the user invoking 
  4.    * {@link Cache#invalidate}, {@link Cache#invalidateAll(Iterable)}, {@link Cache#invalidateAll()}, 
  5.    * {@link Map#remove}, {@link ConcurrentMap#remove}, or {@link Iterator#remove}. 
  6.    */  
  7.   EXPLICIT {  
  8.     @Override  
  9.     boolean wasEvicted() {  
  10.       return false;  
  11.     }  
  12.   },  
  13.   
  14.   /** 
  15.    * The entry itself was not actually removed, but its value was replaced by the user. This can 
  16.    * result from the user invoking {@link Cache#put}, {@link LoadingCache#refresh}, {@link Map#put}, 
  17.    * {@link Map#putAll}, {@link ConcurrentMap#replace(Object, Object)}, or 
  18.    * {@link ConcurrentMap#replace(Object, Object, Object)}. 
  19.    */  
  20.   REPLACED {  
  21.     @Override  
  22.     boolean wasEvicted() {  
  23.       return false;  
  24.     }  
  25.   },  
  26.   
  27.   /** 
  28.    * The entry was removed automatically because its key or value was garbage-collected. This 
  29.    * can occur when using {@link CacheBuilder#weakKeys}, {@link CacheBuilder#weakValues}, or 
  30.    * {@link CacheBuilder#softValues}. 
  31.    */  
  32.   COLLECTED {  
  33.     @Override  
  34.     boolean wasEvicted() {  
  35.       return true;  
  36.     }  
  37.   },  
  38.   
  39.   /** 
  40.    * The entry's expiration timestamp has passed. This can occur when using 
  41.    * {@link CacheBuilder#expireAfterWrite} or {@link CacheBuilder#expireAfterAccess}. 
  42.    */  
  43.   EXPIRED {  
  44.     @Override  
  45.     boolean wasEvicted() {  
  46.       return true;  
  47.     }  
  48.   },  
  49.   
  50.   /** 
  51.    * The entry was evicted due to size constraints. This can occur when using 
  52.    * {@link CacheBuilder#maximumSize} or {@link CacheBuilder#maximumWeight}. 
  53.    */  
  54.   SIZE {  
  55.     @Override  
  56.     boolean wasEvicted() {  
  57.       return true;  
  58.     }  
  59.   };  
  60.   
  61.   /** 
  62.    * Returns {@code true} if there was an automatic removal due to eviction (the cause is neither 
  63.    * {@link #EXPLICIT} nor {@link #REPLACED}). 
  64.    */  
  65.   abstract boolean wasEvicted();  
  66. }  

监听器使用很简单，有几个特点需要注意下：

1、默认情况下，监听器方法是被同步调用的（在移除缓存的那个线程中执行）。如果监听器方法比较耗时，会导致调用者线程阻塞时间变长。下面这段代码，由于监听器执行需要2s，所以main线程调用invalidate()要2s后才能返回。

[java]  view plain  copy
  1. public class Main {  
  2.   
  3.     // 创建一个监听器  
  4.     private static class MyRemovalListener implements RemovalListener<Integer, Integer> {  
  5.         @Override  
  6.         public void onRemoval(RemovalNotification<Integer, Integer> notification) {  
  7.             String tips = String.format("key=%s,value=%s,reason=%s", notification.getKey(), notification.getValue(), notification.getCause());  
  8.             System.out.println(tips);  
  9.   
  10.             try {  
  11.                 // 模拟耗时  
  12.                 Thread.sleep(2000);  
  13.             } catch (InterruptedException e) {  
  14.                 e.printStackTrace();  
  15.             }  
  16.   
  17.         }  
  18.     }  
  19.   
  20.     public static void main(String[] args) {  
  21.   
  22.         // 创建一个带有RemovalListener监听的缓存  
  23.         final Cache<Integer, Integer> cache = CacheBuilder.newBuilder().removalListener(new MyRemovalListener()).build();  
  24.         cache.put(1, 1);  
  25.         cache.put(2, 2);  
  26.   
  27.         System.out.println("main...begin.");  
  28.         cache.invalidate(1);// 耗时2s  
  29.         System.out.println("main...over.");  
  30.     }  
  31.   
  32. }  

解决这个问题的方法是：使用异步监听RemovalListeners.asynchronous(RemovalListener, Executor)。

[java]  view plain  copy
  1. public class Main {  
  2.   
  3.     // 创建一个监听器  
  4.     private static class MyRemovalListener implements RemovalListener<Integer, Integer> {  
  5.         @Override  
  6.         public void onRemoval(RemovalNotification<Integer, Integer> notification) {  
  7.             String tips = String.format("key=%s,value=%s,reason=%s", notification.getKey(), notification.getValue(), notification.getCause());  
  8.             System.out.println(tips);  
  9.   
  10.             try {  
  11.                 // 模拟耗时  
  12.                 Thread.sleep(2000);  
  13.             } catch (InterruptedException e) {  
  14.                 e.printStackTrace();  
  15.             }  
  16.   
  17.         }  
  18.     }  
  19.   
  20.     public static void main(String[] args) {  
  21.   
  22.         RemovalListener<Integer, Integer> async = RemovalListeners.asynchronous(new MyRemovalListener(), Executors.newSingleThreadExecutor());  
  23.         // 创建一个带有RemovalListener监听的缓存  
  24.         final Cache<Integer, Integer> cache = CacheBuilder.newBuilder().removalListener(async).build();  
  25.         cache.put(1, 1);  
  26.         cache.put(2, 2);  
  27.   
  28.         System.out.println("main...begin.");  
  29.         cache.invalidate(1);// main线程立刻返回  
  30.         System.out.println("main...over.");  
  31.     }  
  32.   
  33. }  


2、创建cache的时候只能添加1个监听器，这个监听器对象会被多个线程共享，所以如果监听器需要操作共享资源，那么一定要做好同步控制。下面这段代码可以看出：2个线程会交替执行监听器的发方法。

[java]  view plain  copy
  1. public class Main {  
  2.   
  3.     // 创建一个监听器  
  4.     private static class MyRemovalListener implements RemovalListener<Integer, Integer> {  
  5.         @Override  
  6.         public void onRemoval(RemovalNotification<Integer, Integer> notification) {  
  7.             String tips = String.format("key=%s,value=%s,reason=%s", notification.getKey(), notification.getValue(), notification.getCause());  
  8.             System.out.println(tips);  
  9.   
  10.             try {  
  11.                 // 模拟耗时  
  12.                 Thread.sleep(2000);  
  13.             } catch (InterruptedException e) {  
  14.                 e.printStackTrace();  
  15.             }  
  16.   
  17.             System.out.println("process over.");  
  18.         }  
  19.     }  
  20.   
  21.     public static void main(String[] args) {  
  22.   
  23.         // 创建一个带有RemovalListener监听的缓存  
  24.         final Cache<Integer, Integer> cache = CacheBuilder.newBuilder().removalListener(new MyRemovalListener()).build();  
  25.         cache.put(1, 1);  
  26.         cache.put(2, 2);  
  27.   
  28.         new Thread(new Runnable() {  
  29.             @Override  
  30.             public void run() {  
  31.                 System.out.println("thread1...trigger RemovalListener begin.");  
  32.                 cache.invalidate(1);  
  33.                 System.out.println("thread1...trigger RemovalListener over.");  
  34.             }  
  35.         }).start();  
  36.   
  37.         new Thread(new Runnable() {  
  38.             @Override  
  39.             public void run() {  
  40.                 System.out.println("thread2...trigger RemovalListener begin.");  
  41.                 cache.invalidate(2);  
  42.                 System.out.println("thread2...trigger RemovalListener over.");  
  43.             }  
  44.         }).start();  
  45.     }  
  46.   
  47. }  



3、监听器中抛出的任何异常，在被记录到日志后，会被guava丢弃，不会导致监听器不可用。下面这段代码可以看到：监听器中抛出的异常只是被记录了(打印到了控制台)，并没有导致JVM退出，之后缓存被移除一样可以再次触发。
[java]  view plain  copy
  1. public class Main {  
  2.   
  3.     // 创建一个监听器  
  4.     private static class MyRemovalListener implements RemovalListener<Integer, Integer> {  
  5.         @Override  
  6.         public void onRemoval(RemovalNotification<Integer, Integer> notification) {  
  7.             String tips = String.format("key=%s,value=%s,reason=%s", notification.getKey(), notification.getValue(), notification.getCause());  
  8.             System.out.println(tips);  
  9.   
  10.             throw new RuntimeException();  
  11.         }  
  12.     }  
  13.   
  14.     public static void main(String[] args) {  
  15.   
  16.         // 创建一个带有RemovalListener监听的缓存  
  17.         final Cache<Integer, Integer> cache = CacheBuilder.newBuilder().removalListener(new MyRemovalListener()).build();  
  18.         cache.put(1, 1);  
  19.         cache.put(2, 2);  
  20.   
  21.         cache.invalidate(1);  
  22.         cache.invalidate(2);  
  23.     }  
  24.   
  25. }  
zhangjikuan
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【guava】GuavaCache缓存失效的时候做一些操作 RemovalListener
九师兄
09-27 3980
1.概述 转载:https://blog.csdn.net/chen_kkw/article/details/81144169 以为需要我使用guava缓存我的数据库连接，但是因为设置了1分钟失效就关闭，但是关闭的时候，我希望能做些操作，最好是关闭连接，代码如下 private static class MyRemovalListener implements RemovalListener<Integer, Integer> { @Override public voi
Guava Cache实战—从场景使用到原理分析
python6_quanzhan的博客
11-18 1055
摘要：本文先介绍为什么使用 Guava Cache 缓存；然后讲解 Guava 缓存使用方法、清理方法及使用过程中踩过的坑；接着讲解其底层数据结构，分析其性能优异的原因；最后讲解在使用本地缓存时可以优化的方向。 为什么使用本地缓存 在多线程高并发场景中往往是离不开 cache 的，需要根据不同的应用场景来需要选择不同的 cache，比如分布式缓存如 Redis、memcached，还有本地（进程内）缓存如 ehcache、Guava Cache。缓存相比IO操作，速度快，效率高；Guava 相比 R.
Guava库学习：学习Guava Cache（七）RemovalListener（1）
weixin_34362790的博客
12-21 264
2019独角兽企业重金招聘Python工程师标准>>> ...
Guava Cache 缓存数据被移除后的监听器RemovalListener
热门推荐
aty
11-11 1万+
guava的容量管理，有4种方式可以将数据从缓存中移除。有的时候，我们需要在缓存被移除的时候，得到这个通知，并做一些额外处理工作。这个时候RemovalListener就派上用场了。监听器有几个特点需要注意下：1、默认情况下，监听器方法是被同步调用的（在移除缓存的那个线程中执行）。2、创建cache的时候只能添加1个监听器，这个监听器对象会被多个线程共享，所以如果监听器需要操作共享资源，那么一定要做好同步控制。3、监听器中抛出的任何异常，在被记录到日志后，会被guava丢弃，不会导致监听器不可用。
Guava1.2——GuavaCache的RemoveListener分析
xocupid的博客
06-22 507
put操作1.prewritevoid preWriteCleanup(long now)void runLockedCleanup(long now)void drainReferenceQueues()void expireEntries(long now)以上是准备工作，和get方法中的准备类似。2.postwritevoid postWriteCleanup()void runUnlockedCleanup();// 该方法会把removalNotificationQueue中的元素清楚掉，并调用o
Guava库学习：学习Guava Cache（七）RemovalListener（2）
weixin_33810006的博客
12-21 230
2019独角兽企业重金招聘Python工程师标准>>> ...
Guava Cache三种被动更新机制与过期监听器removalListener
yangchao2726的博客
02-21 1546
Guava Cache三种被动更新机制：expireAfterWrite与refreshAfterWrite的不同
Guava入门~RemovalListener
小强快跑~~
09-05 557
1.COLLECTED: key或value被垃圾回收；getCause()获取RemovalCause。5.SIZE:超过了最大限制数量。3.EXPLICIT:手动移除；4.REPLACED:被替换；2.EXPIRED:已过期；实现Map.Entry接口。
Go-Localcaching-GuavaCache在Go中的部分的实现
08-13
但是，Guava Cache包含了一些高级特性，如自动过期、大小限制、缓存加载和监听器等，这些需要通过自定义代码或者第三方库来实现。 1. **自动过期**：Guava Cache允许设置缓存项的过期时间，超过这个时间后，缓存项...
Guava Cache：核心参数深度剖析和相关源码分析
weixin_38569499的博客
10-04 4414
1、核心参数概览 2、核心参数分功能分析
Guava cache缓存实践
小黑说Java
12-28 382
在我们日常开发中，如果某些数据会频繁的进行读取，并且很少会做修改，我们一般会对这些数据进行缓存，来提高读取的速度。 使用缓存之所以能提高性能，是因为读取的速度比从磁盘或数据库中读取的速度更高。 但是使用缓存并不是全部都是好处，因为存放缓存数据的空间一般都是CPU内存，或者Redis等，它们的空间更宝贵，是典型的空间换时间，所以需要放到缓存中的数据应该是.
GuavaCache RemovalListener 失效
旧时光 | YoungChen's 博客
07-21 2660
问题 最近接触到 Google 的 Java 工具包 Guava，确实很好用，特别是其中的 GuavaCache 算是经常使用到的本地缓存，这次遇到一个需求是希望在 xxx min 之后做一个延时操作，虽然可以开一个定时任务做，但是由于当时代码里正好使用到了 GuavaCache，想起来可以基于 Key 的过期做一个回调方法不就行了嘛，猜测 GuavaCache 肯定是支持这样的回调 API 的...
guava之guava cache
sinat_14913533的博客
04-23 1322
caffine的原文翻译 https://segmentfault.com/a/1190000008751999 细读这个：https://www.chinacion.cn/article/5629.html Count-Min Sketch算法，就是BloomFilter的升级版本，BloomFilter是判断一个对象存在or不存在的，Count-Min Sketch是用来记录一个对象的次数的。BloomFilter的问题，也同样存在Count-.
Guava 缓存Cache用法介绍
不见其长，日有所长
06-05 3735
1. 前言 Guava Cache是在内存中缓存数据，相比较于数据库或redis存储，访问内存中的数据会更加高效。Guava官网介绍，下面的这几种情况可以考虑使用Guava Cache： 愿意消耗一些内存空间来提升速度。 预料到某些键会被多次查询。 缓存中存放的数据总量不会超出内存容量。 所以，可以将程序频繁用到的少量数据存储到Guava Cache中，以改善程序性能。下面对Guava Cache的用法进行详细的介绍。 2. 构建缓存对象 接口Cache代表一块缓存，它有如下方法： public int
guava RemovalListener失效分析
peaktravel的专栏
12-13 3323
一、问题 使用Guava Cache来实现自动清理缓存中的过期数据，基本代码如下： import com.google.common.cache.Cache; import com.google.common.cache.CacheBuilder; import com.google.common.cache.RemovalListener; import com.google.common.c...
Guava Cache 过期回源
井底之蛙
09-29 2476
缓存的更新有两种方法: 被动更新：先从缓存获取，没有则回源获取，再更新缓存； 主动更新：发现数据改变后直接更新缓存（在分布式场景下，不容易实现） 在高并发环境，被动回源是需要注意的。 问题：高并发场景下，大量请求在同一时间回源，大量的请求同一时间穿透到后端，容易引起后端服务崩溃（也容易引起并发问题）。 guava cache解决办法： guava cache保证单线程回源，对于同一个key，只让一个请求回源load，其他线程阻塞等待结果。同时，在Guava里可以通过配置expireAfterAcces
Guava 工具类之Cache的使用 本地缓存组件
最新发布
weixin_56800842的博客
12-15 908
guava cache是Google guava中提供的一款轻量级的本地缓存组件，其特点是简单、轻便、完善、扩展性强，内存管理机制也相对完善。
基于guava框架中事件总实现具体事件的监听
李杰的博客
05-31 460
文章目录 Guava的EventBus可以简化生产/消费模型。EventBus通过非常简单的方式，实现了观察者模式中的监听注册，事件分发。 public class GuavaListener { // 只有通过@Subscribe注解的方法才会被注册进EventBus，即可实现对多个消息的订阅 @Subscribe public void receiveMessage(String message) { System.out.println(message);
SpringBoot加入Guava Cache实现本地缓存代码实例
05-12
以下是一个简单的Spring Boot应用程序，使用Guava Cache实现本地缓存： 首先，需要在pom.xml文件中添加依赖： ``` <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>28.0-jre</version> </dependency> ``` 然后，创建一个CacheManager bean来管理缓存： ``` @Configuration public class CacheConfig { @Bean public CacheManager cacheManager() { return new GuavaCacheManager("myCache"); } } ``` 在上面的代码中，我们使用GuavaCacheManager创建一个名为“myCache”的缓存管理器。 接下来，创建一个Service bean来使用缓存： ``` @Service public class MyService { @Autowired private CacheManager cacheManager; public String getData(String key) { Cache cache = cacheManager.getCache("myCache"); Cache.ValueWrapper valueWrapper = cache.get(key); if (valueWrapper != null) { return (String) valueWrapper.get(); } else { String data = getDataFromDatabase(key); cache.put(key, data); return data; } } private String getDataFromDatabase(String key) { // 从数据库获取数据 return "data for " + key; } } ``` 在上面的代码中，我们注入了CacheManager bean，并使用它来获取名为“myCache”的缓存。如果缓存中不存在所需的数据，我们从数据库中获取数据并将其放入缓存中。 现在，我们可以测试该应用程序是否正常工作： ``` @RestController public class MyController { @Autowired private MyService myService; @GetMapping("/data") public String getData(@RequestParam String key) { return myService.getData(key); } } ``` 在上面的代码中，我们注入了MyService bean，并在HTTP GET请求中使用它来获取数据。现在，我们可以使用curl或浏览器访问http://localhost:8080/data?key=test，应该会返回“data for test”。如果我们再次访问http://localhost:8080/data?key=test，应该会返回缓存中的数据，而不是从数据库中获取数据。 这就是使用Guava Cache在Spring Boot应用程序中实现本地缓存的简单示例。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值