Java缓存caffeine使用心得

文章目录

添加依赖
一、手动加载
- 1，定义缓存
- 2，写入缓存（增、改）
- 3，获取大小
- 4，模拟耗时操作
- 5，移除缓存元素
- 6，查询缓存（查）
- 7，统计缓存
二、同步加载
- 1，定义缓存
- 2，查询缓存
- 3，刷新缓存
三、异步加载
- 1，定义缓存
- 2，查找缓存
参考博文

Caffeine是基于Java 8的高性能，接近最佳的缓存库，是Spring 5默认支持的Cache，底层数据存储采用ConcurrentHashMap，缓存和 Map 之间的一个根本区别在于缓存可以回收存储的 item。
在这里插入图片描述

添加依赖

<dependency>
  <groupId>com.github.ben-manes.caffeine</groupId>
  <artifactId>caffeine</artifactId>
  <version>2.9.3</version>
</dependency>

一、手动加载

1，定义缓存

Cache<String,String> cache = Caffeine.newBuilder()
// 初始容量
.initialCapacity(5)
// 写入间隔多久过期
.expireAfterWrite(10, TimeUnit.MINUTES)
// 最大缓存数，数字新写法（带下划线，增加可读性）
.maximumSize(10_000)
// 驱逐监听器
.evictionListener((String key,String str,RemovalCause cause) ->
                  System.out.printf("Key %s was evicted (%s)%n", key, cause))
// 移除监听器
.removalListener((String key,String str,RemovalCause cause) ->{
    System.out.printf("Key %s was removed (%s)%n", key, cause);
})
.build();

2，写入缓存（增、改）

cache.put("aaa","aac");
cache.put("bbb","bbd");

3，获取大小

此时如果我们把maximumSize调整为1，就是说最大缓存数就是1，而上一步我们添加2个缓存，这时调用estimatedSize方法获取到的长度还是2。因为虽然在执行缓存清理机制，不过该机制是异步的，所以需要加cleanUp方法后，再获取大小就是实际的大小

cache.cleanUp(); // 如果不加这行，打印的是size=2。加了这行打印size=1
long size = cache.estimatedSize();
System.out.println("size = " + size);
// size = 1

4，模拟耗时操作

验证过期策略

try {
    Thread.sleep(2000);
    // 这个sleep方法和Thread.sleep一样
    // TimeUnit.SECONDS.sleep(2000);
} catch (InterruptedException e) {
    throw new RuntimeException(e);
}

5，移除缓存元素

方法有三个（删）

// 移除某个元素
cache.invalidate("aaa");
// 移除所有缓存元素
cache.invalidateAll();
// 移除一组元素
cache.invalidateAll(keys);

6，查询缓存（查）

优先使用get方法，因为getIfPresent执行时非原子性，如果是高并发场景下可能会造成数据错乱

// 方法一：没有查找到的时候返回null
String ddd = cache.getIfPresent("ddd");
System.out.println("ddd="+ ddd);
// ddd=null
// 方法二：如果缓存不存在则生成缓存元素 并且写入缓存, 如果无法生成则返回null
String ccc = cache.get("ccc", k->"Hello");
System.out.println("ccc=" +ccc);
// ccc=Hello

7，统计缓存

long hitCount = cache.stats().hitCount();
long missCount = cache.stats().missCount();
System.out.println("统计缓存=>"+hitCount + "missCount:" +  missCount);
// 统计缓存=>hitCount=0;missCount:0

二、同步加载

1，定义缓存

LoadingCache<String,String> cache = Caffeine.newBuilder()
.maximumSize(10_000)
.expireAfterWrite(10,TimeUnit.MINUTES)
.build(key -> createData(key));

其中build参数也可以简写为

.build(TestCaffeineCache::createData);

createData函数如下，相当于给value一个默认值

private static String createData(String key){
return key + "value";
}

2，查询缓存

可以直接使用get(key)方法

String value = cache.get("hello");
System.out.println("key=="+value);
// key==hellovalue

如果在get之前先put了一下，那么打印出来的就是put的value值

cache.put("hello","world");
// key==world

批量查找缓存

Map<String,String> values  = cache.getAll(Arrays.asList("key1","key2"));
// 或者
Map<String,String> values  = cache.getAll(Stream.of("key1","key2").collect(Collectors.toList()));

3，刷新缓存

cache.refresh("key");

三、异步加载

1，定义缓存

AsyncLoadingCache<String ,String> cache = Caffeine.newBuilder()
.maximumSize(10_000)
.expireAfterWrite(10,TimeUnit.MINUTES)
.buildAsync( key -> createExpensiveStr(key));

private static String createExpensiveStr(String key){
return key + "expensiveValue";
}

2，查找缓存

可以发现除了返回值类型不太像，其他都和上一个同步加载差不多

CompletableFuture<String> hello = cache.get("hello");
hello.thenAccept( str ->{
    System.out.println("hello=="+str);
});
// hello==helloexpensiveValue

// 批量查找
CompletableFuture<Map<String,String>> values = cache.getAll(Arrays.asList("one","two"));
values.thenAccept( str ->{
            System.out.println("values=="+str);
        });
// values=={one=oneexpensiveValue, two=twoexpensiveValue}