一、Caffeine介绍
1、缓存介绍
缓存(Cache)在代码世界中无处不在。从底层的CPU多级缓存，到客户端的页面缓存，处处都存在着缓存的身影。缓存从实质上来说，是一种空间换工夫的伎俩，通过对数据进行肯定的空间安顿，使得下次进行数据拜访时起到减速的成果。
就Java而言，其罕用的缓存解决方案有很多，例如数据库缓存框架EhCache，分布式缓存Memcached等，这些缓存计划实际上都是为了晋升吞吐效率，防止长久层压力过大。
对于常见缓存类型而言，能够分为本地缓存以及分布式缓存两种，Caffeine就是一种优良的本地缓存，而Redis能够用来做分布式缓存
2、Caffeine介绍
Caffeine官网：
https://github.com/ben-manes/caffeine
Caffeine是基于Java 1.8的高性能本地缓存库，由Guava改良而来，而且在Spring5开始的默认缓存实现就将Caffeine代替原来的Google Guava，官网阐明指出，其缓存命中率曾经靠近最优值。实际上Caffeine这样的本地缓存和ConcurrentMap很像，即反对并发，并且反对O(1)工夫复杂度的数据存取。二者的次要区别在于：
- ConcurrentMap将存储所有存入的数据，直到你显式将其移除；
- Caffeine将通过给定的配置，主动移除“不罕用”的数据，以放弃内存的正当占用。
因而，一种更好的了解形式是：Cache是一种带有存储和移除策略的Map。
二、Caffeine根底
应用Caffeine，须要在工程中引入如下依赖
<dependency> <groupId>com.github.ben-manes.caffeine</groupId> <artifactId>caffeine</artifactId> <!--https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeinez找最新版--> <version>3.0.5</version></dependency>举荐一个开源收费的 Spring Boot 实战我的项目：
https://github.com/javastacks/spring-boot-best-practice
1、缓存加载策略
1.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 -> "默认值"));1.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());1.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(); });//异步缓存返回的是CompletableFutureCompletableFuture<String> future = asyncLoadingCache.get("1");future.thenAccept(System.out::println);2、驱赶策略
驱赶策略在创立缓存的时候进行指定。罕用的有基于容量的驱赶和基于工夫的驱赶。
基于容量的驱赶须要指定缓存容量的最大值，当缓存容量达到最大时，Caffeine将应用LRU策略对缓存进行淘汰；基于工夫的驱赶策略如字面意思，能够设置在最初拜访/写入一个缓存通过指定工夫后，主动进行淘汰。
驱赶策略能够组合应用，任意驱赶策略失效后，该缓存条目即被驱赶。
- LRU 最近起码应用，淘汰最长工夫没有被应用的页面。
- LFU 最不常常应用，淘汰一段时间内应用次数起码的页面
- FIFO 先进先出
Caffeine有4种缓存淘汰设置
- 大小 （LFU算法进行淘汰）
- 权重 （大小与权重 只能二选一）
- 工夫
- 援用 （不罕用，本文不介绍）
@Slf4jpublic class CacheTest { /** * 缓存大小淘汰 */ @Test public 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()); } /** * 权重淘汰 */ @Test public 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()); } /** * 拜访后到期（每次拜访都会重置工夫，也就是说如果始终被拜访就不会被淘汰） */ @Test public 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 } /** * 写入后到期 */ @Test public 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 }}3、刷新机制
refreshAfterWrite()示意x秒后主动刷新缓存的策略能够配合淘汰策略应用，留神的是刷新机制只反对LoadingCache和AsyncLoadingCache
private static int NUM = 0;@Testpublic 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}4、统计
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());5、总结
上述一些策略在创立时都能够进行自由组合，个别状况下有两种办法
- 设置
maxSize、refreshAfterWrite，不设置expireAfterWrite/expireAfterAccess，设置expireAfterWrite当缓存过期时会同步加锁获取缓存，所以设置expireAfterWrite时性能较好，然而某些时候会取旧数据,适宜容许取到旧数据的场景 - 设置
maxSize、expireAfterWrite/expireAfterAccess，不设置 refreshAfterWrite 数据一致性好，不会获取到旧数据，然而性能没那么好（比照起来），适宜获取数据时不耗时的场景
三、SpringBoot整合Caffeine
举荐一个开源收费的 Spring Boot 实战我的项目：
https://github.com/javastacks/spring-boot-best-practice
1、@Cacheable相干注解
1.1 相干依赖
如果要应用@Cacheable注解，须要引入相干依赖，并在任一配置类文件上增加@EnableCaching注解
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId></dependency>1.2 罕用注解
- @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;}1.3 罕用注解属性
- cacheNames/value：缓存组件的名字，即cacheManager中缓存的名称。
- key：缓存数据时应用的key。默认应用办法参数值，也能够应用SpEL表达式进行编写。
- keyGenerator：和key二选一应用。
- cacheManager：指定应用的缓存管理器。
- condition：在办法执行开始前查看，在合乎condition的状况下，进行缓存
- unless：在办法执行实现后查看，在合乎unless的状况下，不进行缓存
- sync：是否应用同步模式。若应用同步模式，在多个线程同时对一个key进行load时，其余线程将被阻塞。
1.4 缓存同步模式
sync开启或敞开，在Cache和LoadingCache中的体现是不统一的：
- Cache中，sync示意是否须要所有线程同步期待
- LoadingCache中，sync示意在读取不存在/已驱赶的key时，是否执行被注解办法
2、实战
2.1 引入依赖
<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
创立缓存常量类，把公共的常量提取一层，复用，这里也能够通过配置文件加载这些数据，例如@ConfigurationProperties和@Value
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
@Configuration@EnableCachingpublic 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不能够同时应用 */ @Bean public 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)@CacheEvictpublic UserEntity getUserByUserId(Integer userId){ UserEntity userEntity = userMapper.findById(userId); System.out.println("查问了数据库"); return userEntity;}版权申明：本文为CSDN博主「魅Lemon」的原创文章，遵循CC 4.0 BY-SA版权协定，转载请附上原文出处链接及本申明。原文链接：https://blog.csdn.net/lemon_TT/article/details/122905113
近期热文举荐：
1.1,000+ 道 Java面试题及答案整顿(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！
5.《Java开发手册（嵩山版）》最新公布，速速下载！
感觉不错，别忘了顺手点赞+转发哦！