【学习笔记】本地缓存Caffeine介绍及使用

前言

在java开发过程中，缓存是我们经常会谈到的一个话题，而在java领域有个缓存框架号称本地缓存性能之王， Caffeine。

本文就缓存、Caffeine以及与springboot的集成做个记录，希望能帮助到需要的朋友。

一、缓存及Caffeine介绍

1. 缓存介绍

缓存从大面上可以分为硬件缓存和软件缓存.

1.1 硬件缓存

我们知道，计算机中CPU存取数据的速度非常的快，一秒钟能够存取、处理十亿条指令和数据（术语：CPU主频1G），而内存就慢很多，快的内存能够达到几十兆就不错了，可见两者的速度差异非常之大。而缓存就是为了解决CPU和内存两者速度差异问题的中间媒体，通过将CPU访问频率较高的数据从内存读入缓存，进而提高软件执行效率。

1.2 软件缓存

以上是硬件中缓存，软件中的缓存的定义更为广泛一些，实现的方式也更多一些，但目的是一样的，都是复制常用的数据到内存中方便CPU的快读读取（注意：通过java的原理可以看出java不能操作缓存，不过可以给缓存建议存储那些数据）。

缓存的基本思想是以空间换时间。我们知道，IO的读写速度相对内存来说是比较慢的，通常一个web应用的瓶颈就出现在磁盘IO的读写上。那么，如果我们在内存中建立一个存储区，将数据缓存起来，当浏览器端由请求到达的时候，直接从内存中获取相应的数据，这样一来可以降低服务器的压力，二来，可以提高请求的响应速度，提升用户体验。

接下来我们看下java中涉及到的软件缓存的相关内容。

1.2.1 数据库缓存

一般来说，web应用业务逻辑比较复杂，数据库繁多，要获取某个完整的数据，往往要多次读取数据库，或者使用极其复杂效率较低的SQL查询语句。为了提高查询的性能，将查询后的数据放到内存中进行缓存，下次查询时，直接从内存缓存直接返回，提高响应效率。

比如mysql、oracle等本身的缓存机制可以实现数据缓存，有时页面同样的请求，后面的请求时间比第一次请求明显短，就是数据库数据缓存的作用，像mybatis这样的数据库框架也是提供了数据库缓存的相关内容。

1.2.2 应用层缓存

应用层缓存是指我们在代码层面上做的缓存。通过代码逻辑，把曾经请求过的数据或资源等，缓存起来，再次需要数据时通过逻辑上的处理选择可用的缓存的数据。应用层缓存主要针对某个业务方法进行缓存，有些业务对象逻辑比较复杂，可能涉及到多次数据库读写或者其他消耗较高的操作，应用层缓存可以将复杂的业务逻辑解放出来，降低服务器压力。

1.2.3 页面缓存(浏览器缓存)

除了IO外，web应用的另一大瓶颈就是页面模板的渲染。每次请求都需要从业务逻辑层获取相应的model，并将其渲染成对应的HTML。一般来说，web应用读取数据的需求比更新数据的需求大很多，大多数情况下，某个请求返回的HTML是一样的，因此直接将HTML缓存起来也是优化的一个主流做法。

1.2.4 代理服务器缓存

正向代理需要用户浏览器进行配置，反向代理需要先配置DNS服务器，然后接受用户浏览请求，转发请求给远程服务器。反向代理服务器是浏览器和源服务器之间的中间服务器，浏览器先向这个中间服务器发起Web请求，经过处理后（比如权限验证，缓存匹配等），再将请求转发到源服务器。

代理服务器缓存的运作原理跟浏览器的运作原理差不多，只是规模更大。可以把它理解为一个共享缓存，不只为一个用户服务，一般为大量用户提供服务，因此在减少相应时间和带宽使用方面很有效，同一个副本会被重用多次。

常见的反向代理服务器：Nginx

1.2.5 CDN缓存

CDN（ ContentDeliveryNetwork 内容分发网络）缓存，也叫网关缓存、反向代理缓存。浏览器先向CDN网关发起Web请求，网关服务器后面对应着一台或多台负载均衡源服务器，会根据它们的负载请求，动态将请求转发到合适的源服务器上。虽然这种架构负载均衡源服务器之间的缓存没法共享，但却拥有更好的处扩展性。CDN是一种集群服务器网络，不是软件。

1.2.6 基于Spring的缓存

spring作为一个成熟的java web 框架，自身有一套完善的缓存机制，同时，spring还未其他缓存的实现提供了扩展。

2. Caffeine简单介绍

Caffeine是基于Java 1.8的高性能本地缓存库，由Guava改进而来，而且在Spring5开始的默认缓存实现就将Caffeine代替原来的Google Guava，官方说明指出，其缓存命中率已经接近最优值。

实际上Caffeine这样的本地缓存和ConcurrentMap很像，即支持并发，并且支持O(1)时间复杂度的数据存取。二者的主要区别在于：

ConcurrentMap将存储所有存入的数据，直到你显式将其移除；
Caffeine将通过给定的配置，自动移除“不常用”的数据，以保持内存的合理占用。

因此，一种更好的理解方式是：Cache是一种带有存储和移除策略的Map。

二、Caffeine基础

Caffeine官网: https://github.com/ben-manes/caffeine

1. 功能一览

Caffeine 提供了灵活的构造来创建具有以下功能组合的缓存：

自动将条目自动加载到缓存中，可以选择异步加载
基于频率和新近度超过最大值时基于大小的逐出，提供过期策略
自上次访问或上次写入以来测得的基于时间的条目到期
发生第一个陈旧的条目请求时，异步刷新
键自动包装在弱引用中
值自动包装在弱引用或软引用中
逐出（或以其他方式删除）条目的通知
写入传播到外部资源
缓存访问统计信息的累积

2. 缓存加载策略介绍

2.1 Cache手动创建

最普通的一种缓存，无需指定加载方式，需要手动调用put()进行加载。需要注意的是put()方法对于已存在的key将进行覆盖，这点和Map的表现是一致的。在获取缓存值时，如果想要在缓存值不存在时，原子地将值写入缓存，则可以调用get(key, k -> value)方法，该方法将避免写入竞争。调用invalidate()方法，将手动移除缓存。

在多线程情况下，当使用get(key, k -> value)时，如果有另一个线程同时调用本方法进行竞争，则后一线程会被阻塞，直到前一线程更新缓存完成；而若另一线程调用getIfPresent()方法，则会立即返回null，不会被阻塞。

一段简单的示例代码如下:

Cache<Object, Object> cache = Caffeine.newBuilder()//初始数量.initialCapacity(10)//最大条数.maximumSize(10)//expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准//最后一次写操作后经过指定时间过期.expireAfterWrite(1, TimeUnit.SECONDS)//最后一次读或写操作后经过指定时间过期.expireAfterAccess(1, TimeUnit.SECONDS)//监听缓存被移除.removalListener((key, val, removalCause) -> { })//记录命中.recordStats().build();cache.put("1","张三");//张三System.out.println(cache.getIfPresent("1"));//存储的是默认值System.out.println(cache.get("2",o -> "默认值"));

2.2 Loading Cache自动创建

LoadingCache是一种自动加载的缓存。其和普通缓存不同的地方在于，当缓存不存在/缓存已过期时，若调用get()方法，则会自动调用CacheLoader.load()方法加载最新值。调用getAll()方法将遍历所有的key调用get()，除非实现了CacheLoader.loadAll()方法。使用LoadingCache时，需要指定CacheLoader，并实现其中的load()方法供缓存缺失时自动加载。

在多线程情况下，当两个线程同时调用get()，则后一线程将被阻塞，直至前一线程更新缓存完成。

LoadingCache<String, String> loadingCache = Caffeine.newBuilder()//创建缓存或者最近一次更新缓存后经过指定时间间隔，刷新缓存；refreshAfterWrite仅支持LoadingCache.refreshAfterWrite(10, TimeUnit.SECONDS).expireAfterWrite(10, TimeUnit.SECONDS).expireAfterAccess(10, TimeUnit.SECONDS).maximumSize(10)//根据key查询数据库里面的值，这里是个lamba表达式.build(key -> new Date().toString());

2.3 Async Cache异步获取

AsyncCache是Cache的一个变体，其响应结果均为CompletableFuture，通过这种方式，AsyncCache对异步编程模式进行了适配。默认情况下，缓存计算使用ForkJoinPool.commonPool()作为线程池，如果想要指定线程池，则可以覆盖并实现Caffeine.executor(Executor)方法。synchronous()提供了阻塞直到异步缓存生成完毕的能力，它将以Cache进行返回。

在多线程情况下，当两个线程同时调用get(key, k -> value)，则会返回同一个CompletableFuture对象。由于返回结果本身不进行阻塞，可以根据业务设计自行选择阻塞等待或者非阻塞。

AsyncLoadingCache<String, String> asyncLoadingCache = Caffeine.newBuilder()//创建缓存或者最近一次更新缓存后经过指定时间间隔刷新缓存；仅支持LoadingCache.refreshAfterWrite(1, TimeUnit.SECONDS).expireAfterWrite(1, TimeUnit.SECONDS).expireAfterAccess(1, TimeUnit.SECONDS).maximumSize(10)//根据key查询数据库里面的值.buildAsync(key -> {Thread.sleep(1000);return new Date().toString();});//异步缓存返回的是CompletableFuture
CompletableFuture<String> future = asyncLoadingCache.get("1");
future.thenAccept(System.out::println);

3. 移除策略(淘汰机制)介绍

驱逐策略在创建缓存的时候进行指定。常用的有基于容量的驱逐和基于时间的驱逐。

基于容量的驱逐需要指定缓存容量的最大值，当缓存容量达到最大时，Caffeine将使用LRU策略对缓存进行淘汰；基于时间的驱逐策略如字面意思，可以设置在最后访问/写入一个缓存经过指定时间后，自动进行淘汰。

驱逐策略可以组合使用，任意驱逐策略生效后，该缓存条目即被驱逐。

LRU 最近最少使用，淘汰最长时间没有被使用的页面。
LFU 最不经常使用，淘汰一段时间内使用次数最少的页面
FIFO 先进先出

Caffeine有4种缓存淘汰设置

大小（LFU算法进行淘汰）
权重（大小与权重只能二选一）
时间 (设置过期时间，类似redis)
引用（不常用，本文不介绍）

一段示例代码如下:

@Slf4j
public class CacheTest {/*** 缓存大小淘汰*/@Testpublic void maximumSizeTest() throws InterruptedException {Cache<Integer, Integer> cache = Caffeine.newBuilder()//超过10个后会使用W-TinyLFU算法进行淘汰.maximumSize(10).evictionListener((key, val, removalCause) -> {log.info("淘汰缓存：key:{} val:{}", key, val);}).build();for (int i = 1; i < 20; i++) {cache.put(i, i);}Thread.sleep(500);//缓存淘汰是异步的// 打印还没被淘汰的缓存System.out.println(cache.asMap());}/*** 权重淘汰*/@Testpublic void maximumWeightTest() throws InterruptedException {Cache<Integer, Integer> cache = Caffeine.newBuilder()//限制总权重，若所有缓存的权重加起来>总权重就会淘汰权重小的缓存.maximumWeight(100).weigher((Weigher<Integer, Integer>) (key, value) -> key).evictionListener((key, val, removalCause) -> {log.info("淘汰缓存：key:{} val:{}", key, val);}).build();//总权重其实是=所有缓存的权重加起来int maximumWeight = 0;for (int i = 1; i < 20; i++) {cache.put(i, i);maximumWeight += i;}System.out.println("总权重=" + maximumWeight);Thread.sleep(500);//缓存淘汰是异步的// 打印还没被淘汰的缓存System.out.println(cache.asMap());}/*** 访问后到期（每次访问都会重置时间，也就是说如果一直被访问就不会被淘汰）*/@Testpublic void expireAfterAccessTest() throws InterruptedException {Cache<Integer, Integer> cache = Caffeine.newBuilder().expireAfterAccess(1, TimeUnit.SECONDS)//可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护//若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除.scheduler(Scheduler.systemScheduler()).evictionListener((key, val, removalCause) -> {log.info("淘汰缓存：key:{} val:{}", key, val);}).build();cache.put(1, 2);System.out.println(cache.getIfPresent(1));Thread.sleep(3000);System.out.println(cache.getIfPresent(1));//null}/*** 写入后到期*/@Testpublic void expireAfterWriteTest() throws InterruptedException {Cache<Integer, Integer> cache = Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.SECONDS)//可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护//若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除.scheduler(Scheduler.systemScheduler()).evictionListener((key, val, removalCause) -> {log.info("淘汰缓存：key:{} val:{}", key, val);}).build();cache.put(1, 2);Thread.sleep(3000);System.out.println(cache.getIfPresent(1));//null}
}

4. 刷新机制

refreshAfterWrite()表示x秒后自动刷新缓存的策略，可以配合淘汰策略使用，需要注意的是刷新机制只支持LoadingCache和AsyncLoadingCache

private static int NUM = 0;@Test
public void refreshAfterWriteTest() throws InterruptedException {LoadingCache<Integer, Integer> cache = Caffeine.newBuilder().refreshAfterWrite(1, TimeUnit.SECONDS)//模拟获取数据，每次获取就自增1.build(integer -> ++NUM);//获取ID=1的值，由于缓存里还没有，所以会自动放入缓存System.out.println(cache.get(1));// 1// 延迟2秒后，理论上自动刷新缓存后取到的值是2// 但其实不是，值还是1，因为refreshAfterWrite并不是设置了n秒后重新获取就会自动刷新// 而是x秒后&&第二次调用getIfPresent的时候才会被动刷新Thread.sleep(2000);System.out.println(cache.getIfPresent(1));// 1//此时才会刷新缓存，而第一次拿到的还是旧值System.out.println(cache.getIfPresent(1));// 2
}

5. 统计

Caffeine提供了常用的统计功能，包括命中次数、命中率、总条数、加载时间等，通过cache.stats()可以获取到统计数据。

LoadingCache<String, String> cache = Caffeine.newBuilder()//创建缓存或者最近一次更新缓存后经过指定时间间隔，刷新缓存；refreshAfterWrite仅支持LoadingCache.refreshAfterWrite(1, TimeUnit.SECONDS).expireAfterWrite(1, TimeUnit.SECONDS).expireAfterAccess(1, TimeUnit.SECONDS).maximumSize(10)//开启记录缓存命中率等信息.recordStats()//根据key查询数据库里面的值.build(key -> {Thread.sleep(1000);return new Date().toString();});cache.put("1", "shawn");
cache.get("1");/** hitCount :命中的次数* missCount:未命中次数* requestCount:请求次数* hitRate:命中率* missRate:丢失率* loadSuccessCount:成功加载新值的次数* loadExceptionCount:失败加载新值的次数* totalLoadCount:总条数* loadExceptionRate:失败加载新值的比率* totalLoadTime:全部加载时间* evictionCount:丢失的条数*/
System.out.println(cache.stats());

6. 总结

上述一些策略在创建时都可以进行自由组合，一般情况下有两种方法

设置 maxSize、refreshAfterWrite，不设置 expireAfterWrite/expireAfterAccess

设置expireAfterWrite当缓存过期时会同步加锁获取缓存，所以设置expireAfterWrite时性能较好，但是某些时候会取旧数据,适合允许取到旧数据的场景

设置 maxSize、expireAfterWrite/expireAfterAccess，不设置 refreshAfterWrite

数据一致性好，不会获取到旧数据，但是性能没那么好（对比起来），适合获取数据时不耗时的场景

三、Springboot整合Caffeine

1. 常用注解

@Cacheable：表示该方法支持缓存。当调用被注解的方法时，如果对应的键已经存在缓存，则不再执行方法体，而从缓存中直接返回。当方法返回null时，将不进行缓存操作。
@CachePut：表示执行该方法后，其值将作为最新结果更新到缓存中，每次都会执行该方法。
@CacheEvict：表示执行该方法后，将触发缓存清除操作。
@Caching：用于组合前三个注解，例如：

@Caching(cacheable = @Cacheable("CacheConstants.GET_USER"),evict = {@CacheEvict("CacheConstants.GET_DYNAMIC",allEntries = true)}
public User find(Integer id) {return null;
}

注解属性说明:

cacheNames/value：缓存组件的名字，即cacheManager中缓存的名称。
key：缓存数据时使用的key。默认使用方法参数值，也可以使用SpEL表达式进行编写。
keyGenerator：和key二选一使用。
cacheManager：指定使用的缓存管理器。
condition：在方法执行开始前检查，在符合condition的情况下，进行缓存
unless：在方法执行完成后检查，在符合unless的情况下，不进行缓存
sync：是否使用同步模式。若使用同步模式，在多个线程同时对一个key进行load时，其他线程将被阻塞。

2. 整合实战

2.1 新建springboot项目并引入如下依赖:

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId>
</dependency><dependency><groupId>com.github.ben-manes.caffeine</groupId><artifactId>caffeine</artifactId>
</dependency>

2.2 缓存常量类

CacheConstants.java

public class CacheConstants {/*** 默认过期时间（配置类中我使用的时间单位是秒，所以这里如 3*60 为3分钟）*/public static final int DEFAULT_EXPIRES = 3 * 60;public static final int EXPIRES_5_MIN = 5 * 60;public static final int EXPIRES_10_MIN = 10 * 60;public static final String GET_USER = "GET:USER";public static final String GET_DYNAMIC = "GET:DYNAMIC";}

2.3 缓存配置类CacheConfig

CacheConfig.java

@Configuration
@EnableCaching
public class CacheConfig {/*** Caffeine配置说明：* initialCapacity=[integer]: 初始的缓存空间大小* maximumSize=[long]: 缓存的最大条数* maximumWeight=[long]: 缓存的最大权重* expireAfterAccess=[duration]: 最后一次写入或访问后经过固定时间过期* expireAfterWrite=[duration]: 最后一次写入后经过固定时间过期* refreshAfterWrite=[duration]: 创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存* weakKeys: 打开key的弱引用* weakValues：打开value的弱引用* softValues：打开value的软引用* recordStats：开发统计功能* 注意：* expireAfterWrite和expireAfterAccess同事存在时，以expireAfterWrite为准。* maximumSize和maximumWeight不可以同时使用* weakValues和softValues不可以同时使用*/@Beanpublic CacheManager cacheManager() {SimpleCacheManager cacheManager = new SimpleCacheManager();List<CaffeineCache> list = new ArrayList<>();//循环添加枚举类中自定义的缓存，可以自定义for (CacheEnum cacheEnum : CacheEnum.values()) {list.add(new CaffeineCache(cacheEnum.getName(),Caffeine.newBuilder().initialCapacity(50).maximumSize(1000).expireAfterAccess(cacheEnum.getExpires(), TimeUnit.SECONDS).build()));}cacheManager.setCaches(list);return cacheManager;}
}

2.4 调用缓存

这里要注意的是Cache和@Transactional一样也使用了代理，类内调用将失效

/*** value：缓存key的前缀。* key：缓存key的后缀。* sync：设置如果缓存过期是不是只放一个请求去请求数据库，其他请求阻塞，默认是false（根据个人需求）。* unless：不缓存空值,这里不使用，会报错* 查询用户信息类* 如果需要加自定义字符串，需要用单引号* 如果查询为null，也会被缓存*/
@Cacheable(value = CacheConstants.GET_USER,key = "'user'+#userId",sync = true)
@CacheEvict
public UserEntity getUserByUserId(Integer userId){UserEntity userEntity = userMapper.findById(userId);System.out.println("查询了数据库");return userEntity;
}