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:在 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&lt;Long, AddressDTO&gt; addressMap;
    public AddressService() {
        addressMap = new ConcurrentHashMap&lt;&gt;();
        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 提供瞭幾個元數據直接使用。

名稱 地點 描述 例子
methodName 根對象 被調用的方法的名稱 #root.methodName
method 根對象 被調用的方法 #root.method.name
target 根對象 被調用的目標對象 #root.target
targetClass 根對象 被調用的目標的類 #root.targetClass
args 根對象 用於調用目標的參數(作為數組) #root.args[0]
caches 根對象 運行當前方法的緩存集合 #root.caches[0].name
參數名稱 評估上下文 任何方法參數的名稱。如果名稱不可用(可能是由於沒有調試信息),則參數名稱也可在#a<#arg> where#arg代表參數索引(從 開始0)下獲得。 #iban或#a0(您也可以使用#p0或#p<#arg>表示法作為別名)。
result 評估上下文 方法調用的結果(要緩存的值)。僅在unless 表達式、cache put表達式(計算key)或cache evict 表達式(when beforeInvocationis false)中可用。對於支持的包裝器(例如 Optional),#result指的是實際對象,而不是包裝器。 #result

核心原理

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 的父類,封裝瞭所有的緩存操作的主體邏輯。

主要流程如下:

  • 通過CacheOperationSource,獲取所有的CacheOperation列表
  • 如果有@CacheEvict註解、並且標記為在調用前執行,則做刪除/清空緩存的操作
  • 如果有@Cacheable註解,查詢緩存
  • 如果緩存未命中(查詢結果為null),則新增到cachePutRequests,後續執行原始方法後會寫入緩存
  • 緩存命中時,使用緩存值作為結果;緩存未命中、或有@CachePut註解時,需要調用原始方法,使用原始方法的返回值作為結果
  • 如果有@CachePut註解,則新增到cachePutRequests
  • 如果緩存未命中,則把查詢結果值寫入緩存;如果有@CachePut註解,也把方法執行結果寫入緩存
  • 如果有@CacheEvict註解、並且標記為在調用後執行,則做刪除/清空緩存的操作

今天就到這瞭,分享一些工作小技巧給大傢,後面碼哥會分享如何接入 Redis ,並且帶大傢實現一個基於 Sping Boot 實現一個 Caffeine 作為一級緩存、Redis 作為二級緩存的分佈式二級緩存框架。

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

參考資料

[1]https://www.jb51.net/article/242800.htm

[2]https://docs.spring.io/spring…

以上就是SpringBoot集成本地緩存性能之王Caffeine示例詳解的詳細內容,更多關於SpringBoot集成Caffeine的資料請關註WalkonNet其它相關文章!

推薦閱讀: