實戰：這款高性能緩存利器，可以直接封神！

2025-04-07 00:00:00

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

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

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

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

什么是Caffeine？

Caffeine官方：

https://github.com/ben-manes/caffeine

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>

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 -> "默認值"));

（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());

（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);
            returnnew Date().toString();
        });

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

2.驅逐策略

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

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

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

LRU 最近最少使用，淘汰最長時間沒有被使用的頁面。
LFU 最不經常使用，淘汰一段時間內使用次數最少的頁面。
FIFO 先進先出

Caffeine有4種緩存淘汰設置

大小（LFU算法進行淘汰）
權重（大小與權重只能二選一）
時間
引用（不常用，本文不介紹）

@Slf4j
publicclass 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 staticint 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
}

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);
            returnnew 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

1.@Cacheable相關注解

（1）相關依賴

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

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

（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;
}

（3）常用注解屬性

cacheNames/value：緩存組件的名字，即cacheManager中緩存的名稱。
key：緩存數據時使用的key。默認使用方法參數值，也可以使用SpEL表達式進行編寫。
keyGenerator：和key二選一使用。
cacheManager：指定使用的緩存管理器。
condition：在方法執行開始前檢查，在符合condition的情況下，進行緩存。
unless：在方法執行完成后檢查，在符合unless的情況下，不進行緩存。
sync：是否使用同步模式。若使用同步模式，在多個線程同時對一個key進行load時，其他線程將被阻塞。

（4）緩存同步模式

sync開啟或關閉，在Cache和LoadingCache中的表現是不一致的：

Cache中，sync表示是否需要所有線程同步等待。
LoadingCache中，sync表示在讀取不存在/已驅逐的key時，是否執行被注解方法。

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）緩存常量CacheConstants

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

public class CacheConstants {
    /**
     * 默認過期時間（配置類中我使用的時間單位是秒，所以這里如 3*60 為3分鐘）
     */
    publicstaticfinalint DEFAULT_EXPIRES = 3 * 60;
    publicstaticfinalint EXPIRES_5_MIN = 5 * 60;
    publicstaticfinalint EXPIRES_10_MIN = 10 * 60;

    publicstaticfinal String GET_USER = "GET:USER";
    publicstaticfinal String GET_DYNAMIC = "GET:DYNAMIC";

}

（3）緩存配置類CacheConfig

@Configuration
@EnableCaching
publicclass 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;
    }
}

（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;
}

責任編輯：姜華來源：冰河技術

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看