一、Caffeine介紹

1、緩存介紹

緩存(Cache)在代碼世界中無處不在。從底層的CPU多級緩存，到客戶端的頁面緩存，處處都存在著緩存的身影。緩存從本質上來說，是一種空間換時間的手段，通過對數據進行一定的空間安排，使得下次進行數據訪問時起到加速的效果。

就Java而言，其常用的緩存解決方案有很多，例如數據庫緩存框架EhCache，分布式緩存Memcached等，這些緩存方案實際上都是為了提升吞吐效率，避免持久層壓力過大。

對于常見緩存類型而言，可以分為本地緩存以及分布式緩存兩種，Caffeine就是一種優秀的本地緩存，而Redis可以用來做分布式緩存

2、Caffeine介紹

Caffeine是基于Java 1.8的高性能本地緩存庫，由Guava改進而來，而且在Spring5開始的默認緩存實現就將Caffeine代替原來的Google Guava，官方說明指出，其緩存命中率已經接近最優值。實際上Caffeine這樣的本地緩存和ConcurrentMap很像，即支持并發，并且支持O(1)時間復雜度的數據存取。二者的主要區別在于：

ConcurrentMap將存儲所有存入的數據，直到你顯式將其移除；

Caffeine將通過給定的配置，自動移除“不常用”的數據，以保持內存的合理占用。

因此，一種更好的理解方式是：Cache是一種帶有存儲和移除策略的Map。

二、Caffeine基礎

使用Caffeine，需要在工程中引入如下依賴

com.github.ben-manes.caffeine
caffeine
 
3.0.5

1、緩存加載策略

1.1 Cache手動創建

最普通的一種緩存，無需指定加載方式，需要手動調用put()進行加載。需要注意的是put()方法對于已存在的key將進行覆蓋，這點和Map的表現是一致的。在獲取緩存值時，如果想要在緩存值不存在時，原子地將值寫入緩存，則可以調用get(key, k -> value)方法，該方法將避免寫入競爭。調用invalidate()方法，將手動移除緩存。

在多線程情況下，當使用get(key, k -> value)時，如果有另一個線程同時調用本方法進行競爭，則后一線程會被阻塞，直到前一線程更新緩存完成；而若另一線程調用getIfPresent()方法，則會立即返回null，不會被阻塞。

Cachecache=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()，則后一線程將被阻塞，直至前一線程更新緩存完成。

LoadingCacheloadingCache=Caffeine.newBuilder()

//創建緩存或者最近一次更新緩存后經過指定時間間隔，刷新緩存；refreshAfterWrite僅支持LoadingCache
.refreshAfterWrite(10,TimeUnit.SECONDS)
.expireAfterWrite(10,TimeUnit.SECONDS)
.expireAfterAccess(10,TimeUnit.SECONDS)
.maximumSize(10)
//根據key查詢數據庫里面的值，這里是個lamba表達式
.build(key->newDate().toString());

1.3 Async Cache異步獲取

AsyncCache是Cache的一個變體，其響應結果均為CompletableFuture，通過這種方式，AsyncCache對異步編程模式進行了適配。默認情況下，緩存計算使用ForkJoinPool.commonPool()作為線程池，如果想要指定線程池，則可以覆蓋并實現Caffeine.executor(Executor)方法。synchronous()提供了阻塞直到異步緩存生成完畢的能力，它將以Cache進行返回。

在多線程情況下，當兩個線程同時調用get(key, k -> value)，則會返回同一個CompletableFuture對象。由于返回結果本身不進行阻塞，可以根據業務設計自行選擇阻塞等待或者非阻塞。

AsyncLoadingCacheasyncLoadingCache=Caffeine.newBuilder()

//創建緩存或者最近一次更新緩存后經過指定時間間隔刷新緩存；僅支持LoadingCache
.refreshAfterWrite(1,TimeUnit.SECONDS)
.expireAfterWrite(1,TimeUnit.SECONDS)
.expireAfterAccess(1,TimeUnit.SECONDS)
.maximumSize(10)
//根據key查詢數據庫里面的值
.buildAsync(key->{
Thread.sleep(1000);
returnnewDate().toString();
});

//異步緩存返回的是CompletableFuture
CompletableFuturefuture=asyncLoadingCache.get("1");
future.thenAccept(System.out::println);

2、驅逐策略

驅逐策略在創建緩存的時候進行指定。常用的有基于容量的驅逐和基于時間的驅逐。

基于容量的驅逐需要指定緩存容量的最大值，當緩存容量達到最大時，Caffeine將使用LRU策略對緩存進行淘汰；基于時間的驅逐策略如字面意思，可以設置在最后訪問/寫入一個緩存經過指定時間后，自動進行淘汰。

驅逐策略可以組合使用，任意驅逐策略生效后，該緩存條目即被驅逐。

LRU 最近最少使用，淘汰最長時間沒有被使用的頁面。

LFU 最不經常使用，淘汰一段時間內使用次數最少的頁面

FIFO 先進先出

Caffeine有4種緩存淘汰設置

大小 （LFU算法進行淘汰）

權重 （大小與權重 只能二選一）

時間

引用 （不常用，本文不介紹）

@Slf4j
publicclassCacheTest{
/**
*緩存大小淘汰
*/
@Test
publicvoidmaximumSizeTest()throwsInterruptedException{
Cachecache=Caffeine.newBuilder()
//超過10個后會使用W-TinyLFU算法進行淘汰
.maximumSize(10)
.evictionListener((key,val,removalCause)->{
log.info("淘汰緩存：key:{}val:{}",key,val);
})
.build();

for(inti=1;icache=Caffeine.newBuilder()
//限制總權重，若所有緩存的權重加起來>總權重就會淘汰權重小的緩存
.maximumWeight(100)
.weigher((Weigher)(key,value)->key)
.evictionListener((key,val,removalCause)->{
log.info("淘汰緩存：key:{}val:{}",key,val);
})
.build();

//總權重其實是=所有緩存的權重加起來
intmaximumWeight=0;
for(inti=1;icache=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
publicvoidexpireAfterWriteTest()throwsInterruptedException{
Cachecache=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

privatestaticintNUM=0;

@Test
publicvoidrefreshAfterWriteTest()throwsInterruptedException{
LoadingCachecache=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、統計

LoadingCachecache=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);
returnnewDate().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

1、@Cacheable相關注解

1.1 相關依賴

如果要使用@Cacheable注解，需要引入相關依賴，并在任一配置類文件上添加@EnableCaching注解

org.springframework.boot
spring-boot-starter-cache

1.2 常用注解

@Cacheable：表示該方法支持緩存。當調用被注解的方法時，如果對應的鍵已經存在緩存，則不再執行方法體，而從緩存中直接返回。當方法返回null時，將不進行緩存操作。

@CachePut：表示執行該方法后，其值將作為最新結果更新到緩存中，每次都會執行該方法。

@CacheEvict：表示執行該方法后，將觸發緩存清除操作。

@Caching：用于組合前三個注解，例如：

@Caching(cacheable=@Cacheable("CacheConstants.GET_USER"),
evict={@CacheEvict("CacheConstants.GET_DYNAMIC",allEntries=true)}
publicUserfind(Integerid){
returnnull;
}

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 引入依賴

org.springframework.boot
spring-boot-starter-cache



com.github.ben-manes.caffeine
caffeine

2.2 緩存常量CacheConstants

創建緩存常量類，把公共的常量提取一層，復用，這里也可以通過配置文件加載這些數據，例如@ConfigurationProperties和@Value

publicclassCacheConstants{

/**
*默認過期時間（配置類中我使用的時間單位是秒，所以這里如3*60為3分鐘）
*/
publicstaticfinalintDEFAULT_EXPIRES=3*60;
publicstaticfinalintEXPIRES_5_MIN=5*60;
publicstaticfinalintEXPIRES_10_MIN=10*60;

publicstaticfinalStringGET_USER="GET:USER";
publicstaticfinalStringGET_DYNAMIC="GET:DYNAMIC";

}

2.3 緩存配置類CacheConfig

@Configuration
@EnableCaching
publicclassCacheConfig{
/**
*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
publicCacheManagercacheManager(){
SimpleCacheManagercacheManager=newSimpleCacheManager();
Listlist=newArrayList<>();
//循環添加枚舉類中自定義的緩存，可以自定義
for(CacheEnumcacheEnum:CacheEnum.values()){
list.add(newCaffeineCache(cacheEnum.getName(),
Caffeine.newBuilder()
.initialCapacity(50)
.maximumSize(1000)
.expireAfterAccess(cacheEnum.getExpires(),TimeUnit.SECONDS)
.build()));
}
cacheManager.setCaches(list);
returncacheManager;
}
}

2.4 調用緩存

這里要注意的是Cache和@Transactional一樣也使用了代理，類內調用將失效

/**
*value：緩存key的前綴。
*key：緩存key的后綴。
*sync：設置如果緩存過期是不是只放一個請求去請求數據庫，其他請求阻塞，默認是false（根據個人需求）。
*unless：不緩存空值,這里不使用，會報錯
*查詢用戶信息類
*如果需要加自定義字符串，需要用單引號
*如果查詢為null，也會被緩存
*/
@Cacheable(value=CacheConstants.GET_USER,key="'user'+#userId",sync=true)
@CacheEvict
publicUserEntitygetUserByUserId(IntegeruserId){
UserEntityuserEntity=userMapper.findById(userId);
System.out.println("查詢了數據庫");
returnuserEntity;
}

審核編輯：黃飛