SpringBoot 整合快取效能之王 Caffeine

使用快取的目的就是提高效能，今天碼哥帶大家實踐運用 spring-boot-starter-cache 抽象的快取元件去整合本地快取效能之王 Caffeine。

大家需要注意的是：in-memeory 快取只適合在單體應用，不適合與分散式環境。

分散式環境的情況下需要將快取修改同步到每個節點，需要一個同步機制保證每個節點快取資料最終一致。

Spring Cache 是什麼

不使用 Spring Cache 抽象的快取介面，我們需要根據不同的快取框架去實現快取，需要在對應的程式碼裡面去對應快取載入、刪除、更新等。

比如查詢我們使用旁路快取策略：先從快取中查詢資料，如果查不到則從資料庫查詢並寫到快取中。

虛擬碼如下：

public User getUser(long userId) {
    // 從快取查詢
    User user = cache.get(userId);
    if (user != null) {
        return user;
    }
    // 從資料庫載入
    User dbUser = loadDataFromDB(userId);
    if (dbUser != null) {
        // 設定到快取中
        cache.put(userId, dbUser)
    }
    return dbUser;
}

我們需要寫大量的這種繁瑣程式碼，Spring Cache 則對快取進行了抽象，提供瞭如下幾個註解實現了快取管理：

• @Cacheable：觸發快取讀取操作，用於查詢方法上，如果快取中找到則直接取出快取並返回，否則執行目標方法並將結果快取。
• @CachePut：觸發快取更新的方法上，與 Cacheable 相比，該註解的方法始終都會被執行，並且使用方法返回的結果去更新快取，適用於 insert 和 update 行為的方法上。
• @CacheEvict：觸發快取失效，刪除快取項或者清空快取，適用於 delete 方法上。

除此之外，抽象的 CacheManager 既能整合基於本地記憶體的單體應用，也能整合 EhCache、Redis 等快取伺服器。

最方便的是通過一些簡單設定和註解就能接入不同的快取框架，無需修改任何程式碼。

整合 Caffeine

碼哥帶大家使用註解方式完成快取操作的方式來整合，完整的程式碼請存取 github：https://github.com/MageByte-Zero/springboot-parent-pom，在 pom.xml 檔案新增如下依賴：

<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>

使用 JavaConfig 方式設定 CacheManager：

@Slf4j
@EnableCaching
@Configuration
public class CacheConfig {

    @Autowired
    @Qualifier("cacheExecutor")
    private Executor cacheExecutor;

    @Bean
    public Caffeine<Object, Object> caffeineCache() {

        return Caffeine.newBuilder()
                // 設定最後一次寫入或存取後經過固定時間過期
                .expireAfterAccess(7, TimeUnit.DAYS)
                // 初始的快取空間大小
                .initialCapacity(500)
            	// 使用自定義執行緒池
                .executor(cacheExecutor)
                .removalListener(((key, value, cause) -> log.info("key:{} removed, removalCause:{}.", key, cause.name())))
                // 快取的最大條數
                .maximumSize(1000);
    }

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
        caffeineCacheManager.setCaffeine(caffeineCache());
        // 不快取空值
        caffeineCacheManager.setAllowNullValues(false);
        return caffeineCacheManager;
    }
}

準備工作搞定，接下來就是如何使用了。

@Slf4j
@Service
public class AddressService {

    public static final String CACHE_NAME = "caffeine:address";

    private static final AtomicLong ID_CREATOR = new AtomicLong(0);

    private Map<Long, AddressDTO> addressMap;

    public AddressService() {
        addressMap = new ConcurrentHashMap<>();

        addressMap.put(ID_CREATOR.incrementAndGet(), AddressDTO.builder().customerId(ID_CREATOR.get()).address("地址1").build());
        addressMap.put(ID_CREATOR.incrementAndGet(), AddressDTO.builder().customerId(ID_CREATOR.get()).address("地址2").build());
        addressMap.put(ID_CREATOR.incrementAndGet(), AddressDTO.builder().customerId(ID_CREATOR.get()).address("地址3").build());
    }

    @Cacheable(cacheNames = {CACHE_NAME}, key = "#customerId")
    public AddressDTO getAddress(long customerId) {
        log.info("customerId：{} 沒有走快取，開始從資料庫查詢", customerId);
        return addressMap.get(customerId);
    }

    @CachePut(cacheNames = {CACHE_NAME}, key = "#result.customerId")
    public AddressDTO create(String address) {
        long customerId = ID_CREATOR.incrementAndGet();
        AddressDTO addressDTO = AddressDTO.builder().customerId(customerId).address(address).build();

        addressMap.put(customerId, addressDTO);
        return addressDTO;
    }

    @CachePut(cacheNames = {CACHE_NAME}, key = "#result.customerId")
    public AddressDTO update(Long customerId, String address) {

        AddressDTO addressDTO = addressMap.get(customerId);
        if (addressDTO == null) {
            throw new RuntimeException("沒有 customerId = " + customerId + "的地址");
        }

        addressDTO.setAddress(address);
        return addressDTO;
    }

    @CacheEvict(cacheNames = {CACHE_NAME}, key = "#customerId")
    public boolean delete(long customerId) {
        log.info("快取 {} 被刪除", customerId);
        return true;
    }
}

使用 CacheName 隔離不同業務場景的快取，每個 Cache 內部持有一個 map 結構儲存資料，key 可用使用 Spring 的 Spel 表示式。

單元測試走起：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = CaffeineApplication.class)
@Slf4j
public class CaffeineApplicationTests {

    @Autowired
    private AddressService addressService;

    @Autowired
    private CacheManager cacheManager;

    @Test
    public void testCache() {
        // 插入快取 和資料庫
        AddressDTO newInsert = addressService.create("南山大道");
        // 要走快取
        AddressDTO address = addressService.getAddress(newInsert.getCustomerId());
        long customerId = 2;

        // 第一次未命中快取，列印 customerId：{} 沒有走快取，開始從資料庫查詢
        AddressDTO address2 = addressService.getAddress(customerId);
        // 命中快取
        AddressDTO cacheAddress2 = addressService.getAddress(customerId);

        // 更新資料庫和快取
        addressService.update(customerId, "地址 2 被修改");

        // 更新後查詢，依然命中快取
        AddressDTO hitCache2 = addressService.getAddress(customerId);
        Assert.assertEquals(hitCache2.getAddress(), "地址 2 被修改");

        // 刪除快取
        addressService.delete(customerId);

        // 未命中快取, 從資料庫讀取
        AddressDTO hit = addressService.getAddress(customerId);
        System.out.println(hit.getCustomerId());
    }

}

大家發現沒，只需要在對應的方法上加上註解，就能愉快的使用快取了。需要注意的是， 設定的 cacheNames 一定要對應，每個業務場景使用對應的 cacheNames。

另外 key 可以使用 spel 表示式，大家重點可以關注 @CachePut(cacheNames = {CACHE_NAME}, key = "#result.customerId")，result 表示介面返回結果，Spring 提供了幾個後設資料直接使用。

核心原理

Java Caching定義了5個核心介面，分別是 CachingProvider, CacheManager, Cache, Entry 和 Expiry。

核心類圖：

• Cache：抽象了快取的操作，比如，get()、put()；
• CacheManager：管理 Cache，可以理解成 Cache 的集合管理，之所以有多個 Cache，是因為可以根據不同場景使用不同的快取失效時間和數量限制。
• CacheInterceptor、CacheAspectSupport、AbstractCacheInvoker：CacheInterceptor 是一個AOP 方法攔截器，在方法前後做額外的邏輯，比如查詢操作，先查快取，找不到資料再執行方法，並把方法的結果寫入快取等，它繼承了CacheAspectSupport（快取操作的主體邏輯）、AbstractCacheInvoker（封裝了對 Cache 的讀寫）。
• CacheOperation、AnnotationCacheOperationSource、SpringCacheAnnotationParser：CacheOperation定義了快取操作的快取名字、快取key、快取條件condition、CacheManager等，AnnotationCacheOperationSource 是一個獲取快取註解對應 CacheOperation 的類，而SpringCacheAnnotationParser 是解析註解的類，解析後會封裝成 CacheOperation 集合供AnnotationCacheOperationSource 查詢。

CacheAspectSupport：快取切面支援類，是CacheInterceptor 的父類別，封裝了所有的快取操作的主體邏輯。

主要流程如下：

1. 通過CacheOperationSource，獲取所有的CacheOperation列表
2. 如果有@CacheEvict註解、並且標記為在呼叫前執行，則做刪除/清空快取的操作
3. 如果有@Cacheable註解，查詢快取
4. 如果快取未命中（查詢結果為null），則新增到cachePutRequests，後續執行原始方法後會寫入快取
5. 快取命中時，使用快取值作為結果；快取未命中、或有@CachePut註解時，需要呼叫原始方法，使用原始方法的返回值作為結果
6. 如果有@CachePut註解，則新增到cachePutRequests
7. 如果快取未命中，則把查詢結果值寫入快取；如果有@CachePut註解，也把方法執行結果寫入快取
8. 如果有@CacheEvict註解、並且標記為在呼叫後執行，則做刪除/清空快取的操作

今天就到這了，分享一些工作小技巧給大家，後面碼哥會分享如何接入 Redis ，並且帶大家實現一個基於 Sping Boot 實現一個 Caffeine 作為一級快取、Redis 作為二級快取的分散式二級快取框架。

我們下期見，大家可以在評論區叫我靚仔麼？不叫也行，點贊分享也是鼓勵。

參考資料

[1]https://segmentfault.com/a/1190000041640222

[2]https://docs.spring.io/spring-framework/docs/current/reference/html/integration.html