一、簡介

Caffeine — 一個高效能的 Java 快取庫。快取和 Map 之間的一個根本區別在於快取可以回收儲存的 item。回收策略為在指定時間刪除哪些物件。此策略直接影響快取的命中率 — 快取庫的一個重要特徵。Caffeine 因使用 Window TinyLfu 回收策略，提供了一個近乎最佳的命中率。

二、Caffeine 為我們提供了三種填充策略：手動、同步和非同步

1、手動載入（Manual）

Cache<String, Object> manualCache = Caffeine.newBuilder()
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .maximumSize(10_000)
        .build();

String key = "name1";
// 根據key查詢一個快取，如果沒有返回NULL
graph = manualCache.getIfPresent(key);
// 根據Key查詢一個快取，如果沒有呼叫createExpensiveGraph方法，並將返回值儲存到快取。
// 如果該方法返回Null則manualCache.get返回null，如果該方法丟擲異常則manualCache.get丟擲異常
graph = manualCache.get(key, k -> createExpensiveGraph(k));
// 將一個值放入快取，如果以前有值就覆蓋以前的值
manualCache.put(key, graph);
// 刪除一個快取
manualCache.invalidate(key);

ConcurrentMap<String, Object> map = manualCache.asMap();
cache.invalidate(key);
 

Cache介面允許顯式的去控制快取的檢索，更新和刪除。
我們可以通過cache.getIfPresent(key) 方法來獲取一個key的值，通過cache.put(key, value)方法顯示的將數控放入快取，
但是這樣子會覆蓋緩原來key的資料。更加建議使用cache.get(key，k - > value) 的方式，get 方法將一個引數為 key 的
 Function (createExpensiveGraph) 作為引數傳入。如果快取中不存在該鍵，則呼叫這個 Function 函式，並將返回值作為
該快取的值插入快取中。get 方法是以阻塞方式執行呼叫，即使多個執行緒同時請求該值也只會呼叫一次Function方法。
這樣可以避免與其他執行緒的寫入競爭，這也是為什麼使用 get 優於 getIfPresent 的原因。

注意：如果呼叫該方法返回NULL（如上面的 createExpensiveGraph 方法），則cache.get返回null，如果呼叫該方法丟擲異常，則get方法也會丟擲異常。可以使用Cache.asMap() 方法獲取ConcurrentMap進而對快取進行一些更改。

2、同步載入（Loading）

LoadingCache<String, Object> loadingCache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build(key -> createExpensiveGraph(key));
    
String key = "name1";
// 採用同步方式去獲取一個快取和上面的手動方式是一個原理。在build Cache的時候會提供一個createExpensiveGraph函式。
// 查詢並在缺失的情況下使用同步的方式來構建一個快取
Object graph = loadingCache.get(key);

// 獲取組key的值返回一個Map
List<String> keys = new ArrayList<>();
keys.add(key);
Map<String, Object> graphs = loadingCache.getAll(keys);
 

LoadingCache是使用CacheLoader來構建的快取的值。批量查詢可以使用getAll方法。預設情況下，getAll將會對快取中沒有值的key分別呼叫CacheLoader.load方法來構建快取的值。我們可以重寫CacheLoader.loadAll方法來提高getAll的效率。

注意：您可以編寫一個CacheLoader.loadAll來實現為特別請求的key載入值。
例如，如果計算某個組中的任何鍵的值將為該組中的所有鍵提供值，則loadAll可能會同時載入該組的其餘部分。

3、非同步載入（Asynchronously Loading）

AsyncLoadingCache<String, Object> asyncLoadingCache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            // Either: Build with a synchronous computation that is wrapped as asynchronous
            .buildAsync(key -> createExpensiveGraph(key));
            // Or: Build with a asynchronous computation that returns a future
            // .buildAsync((key, executor) -> createExpensiveGraphAsync(key, executor));

 String key = "name1";

// 查詢並在缺失的情況下使用非同步的方式來構建快取
CompletableFuture<Object> graph = asyncLoadingCache.get(key);
// 查詢一組快取並在缺失的情況下使用非同步的方式來構建快取
List<String> keys = new ArrayList<>();
keys.add(key);
CompletableFuture<Map<String, Object>> graphs = asyncLoadingCache.getAll(keys);
// 非同步轉同步
loadingCache = asyncLoadingCache.synchronous();

AsyncLoadingCache是繼承自LoadingCache類的，非同步載入使用Executor去呼叫方法並返回一個CompletableFuture。非同步載入快取使用
了響應式程式設計模型。如果要以同步方式呼叫時，應提供CacheLoader。要以非同步表示時，應該提供一個AsyncCacheLoader，並返回一個CompletableFuture。synchronous()這個方法返回了一個LoadingCacheView檢視，LoadingCacheView也繼承自LoadingCache。呼叫該方法後就相當於你將一個非同步載入的快取AsyncLoadingCache轉換成了一個同步載入的快取LoadingCache。

預設使用ForkJoinPool.commonPool()來執行非同步執行緒，但是我們可以通過Caffeine.executor(Executor) 方法來替換執行緒池。