前言

緩存可以通過將經常訪問的數據存儲在內存中，減少底層數據源如數據庫的壓力，從而有效提高系統的性能和穩定性。我想大家的項目中或多或少都有使用過，我們項目也不例外，但是最近在review公司的代碼的時候寫的很蠢且low, 大致寫法如下：

public User getById(String id) {
 User user = cache.getUser();
    if(user != null) {
        return user;
    }
    // 從數據庫獲取
    user = loadFromDB(id);
    cahce.put(id, user);
 return user;
}

其實Spring Boot 提供了強大的緩存抽象，可以輕松地向您的應用程序添加緩存。本文就講講如何使用 Spring 提供的不同緩存注解實現緩存的最佳實踐。

啟用緩存@EnableCaching

現在大部分項目都是是SpringBoot項目，我們可以在啟動類添加注解@EnableCaching來開啟緩存功能。

@SpringBootApplication
@EnableCaching
public class SpringCacheApp {

    public static void main(String[] args) {
        SpringApplication.run(Cache.class, args);
    }
}

既然要能使用緩存，就需要有一個緩存管理器Bean，默認情況下，@EnableCaching 將注冊一個ConcurrentMapCacheManager的Bean，不需要單獨的 bean 聲明。ConcurrentMapCacheManager將值存儲在ConcurrentHashMap的實例中，這是緩存機制的最簡單的線程安全實現。

自定義緩存管理器

默認的緩存管理器并不能滿足需求，因為她是存儲在jvm內存中的，那么如何存儲到redis中呢？這時候需要添加自定義的緩存管理器。

1. 添加依賴

<dependency>
  <groupId>org.springframework.boot<span class="hljs-name"groupId>
  <artifactId>spring-boot-starter-data-redis<span class="hljs-name"artifactId>
<span class="hljs-name"dependency>

2. 配置Redis緩存管理器

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory();
    }

    @Bean
    public CacheManager cacheManager() {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
            .disableCachingNullValues()
            .serializeValuesWith(SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory())
            .cacheDefaults(redisCacheConfiguration)
            .build();

        return redisCacheManager;
    }
}

現在有了緩存管理器以后，我們如何在業務層面操作緩存呢？

我們可以使用@Cacheable、@CachePut 或@CacheEvict 注解來操作緩存了。

@Cacheable

該注解可以將方法運行的結果進行緩存，在緩存時效內再次調用該方法時不會調用方法本身，而是直接從緩存獲取結果并返回給調用方。

例子1：緩存數據庫查詢的結果。

@Service
public class MyService {

    @Autowired
    private MyRepository repository;

    @Cacheable(value = "myCache", key = "#id")
    public MyEntity getEntityById(Long id) {
        return repository.findById(id).orElse(null);
    }
}

在此示例中，@Cacheable 注解用于緩存 getEntityById()方法的結果，該方法根據其 ID 從數據庫中檢索 MyEntity 對象。

但是如果我們更新數據呢？舊數據仍然在緩存中？

@CachePut

然后@CachePut 出來了, 與 @Cacheable 注解不同的是使用 @CachePut 注解標注的方法，在執行前不會去檢查緩存中是否存在之前執行過的結果，而是每次都會執行該方法，并將執行結果以鍵值對的形式寫入指定的緩存中。@CachePut 注解一般用于更新緩存數據，相當于緩存使用的是寫模式中的雙寫模式。

@Service
public class MyService {

    @Autowired
    private MyRepository repository;

    @CachePut(value = "myCache", key = "#entity.id")
    public void saveEntity(MyEntity entity) {
        repository.save(entity);
    }
}

@CacheEvict

標注了 @CacheEvict 注解的方法在被調用時，會從緩存中移除已存儲的數據。@CacheEvict 注解一般用于刪除緩存數據，相當于緩存使用的是寫模式中的失效模式。

@Service
public class MyService {

    @Autowired
    private MyRepository repository;

     @CacheEvict(value = "myCache", key = "#id")
    public void deleteEntityById(Long id) {
        repository.deleteById(id);
    }
}

@Caching

@Caching 注解用于在一個方法或者類上，同時指定多個 Spring Cache 相關的注解。

例子1：@Caching注解中的evict屬性指定在調用方法 saveEntity 時失效兩個緩存。

@Service
public class MyService {

    @Autowired
    private MyRepository repository;

    @Cacheable(value = "myCache", key = "#id")
    public MyEntity getEntityById(Long id) {
        return repository.findById(id).orElse(null);
    }

    @Caching(evict = {
        @CacheEvict(value = "myCache", key = "#entity.id"),
        @CacheEvict(value = "otherCache", key = "#entity.id")
    })
    public void saveEntity(MyEntity entity) {
        repository.save(entity);
    }

}

例子2：調用getEntityById方法時，Spring會先檢查結果是否已經緩存在myCache緩存中。如果是，Spring 將返回緩存的結果而不是執行該方法。如果結果尚未緩存，Spring 將執行該方法并將結果緩存在 myCache 緩存中。方法執行后，Spring會根據@CacheEvict注解從otherCache緩存中移除緩存結果。

@Service
public class MyService {

    @Caching(
        cacheable = {
            @Cacheable(value = "myCache", key = "#id")
        },
        evict = {
            @CacheEvict(value = "otherCache", key = "#id")
        }
    )
    public MyEntity getEntityById(Long id) {
        return repository.findById(id).orElse(null);
    }

}

例子3：當調用saveData方法時，Spring會根據@CacheEvict注解先從otherCache緩存中移除數據。然后，Spring 將執行該方法并將結果保存到數據庫或外部 API。

方法執行后，Spring 會根據@CachePut注解將結果添加到 myCache、myOtherCache 和 myThirdCache 緩存中。Spring 還將根據@Cacheable注解檢查結果是否已緩存在 myFourthCache 和 myFifthCache 緩存中。如果結果尚未緩存，Spring 會將結果緩存在適當的緩存中。如果結果已經被緩存，Spring 將返回緩存的結果，而不是再次執行該方法。

@Service
public class MyService {

    @Caching(
        put = {
            @CachePut(value = "myCache", key = "#result.id"),
            @CachePut(value = "myOtherCache", key = "#result.id"),
            @CachePut(value = "myThirdCache", key = "#result.name")
        },
        evict = {
            @CacheEvict(value = "otherCache", key = "#id")
        },
        cacheable = {
            @Cacheable(value = "myFourthCache", key = "#id"),
            @Cacheable(value = "myFifthCache", key = "#result.id")
        }
    )
    public MyEntity saveData(Long id, String name) {
        // Code to save data to a database or external API
        MyEntity entity = new MyEntity(id, name);
        return entity;
    }

}

@CacheConfig

通過@CacheConfig 注解，我們可以將一些緩存配置簡化到類級別的一個地方，這樣我們就不必多次聲明相關值：

@CacheConfig(cacheNames={"myCache"})
@Service
public class MyService {

    @Autowired
    private MyRepository repository;

    @Cacheable(key = "#id")
    public MyEntity getEntityById(Long id) {
        return repository.findById(id).orElse(null);
    }

    @CachePut(key = "#entity.id")
    public void saveEntity(MyEntity entity) {
        repository.save(entity);
    }

    @CacheEvict(key = "#id")
    public void deleteEntityById(Long id) {
        repository.deleteById(id);
    }
}

Condition & Unless

• condition作用：指定緩存的條件（滿足什么條件才緩存），可用 SpEL 表達式（如 #id>0，表示當入參 id 大于 0 時才緩存）
• unless作用 : 否定緩存，即滿足 unless 指定的條件時，方法的結果不進行緩存，使用 unless 時可以在調用的方法獲取到結果之后再進行判斷（如 #result == null，表示如果結果為 null 時不緩存）

//when id >10, the @CachePut works. 
@CachePut(key = "#entity.id", condition="#entity.id > 10")
public void saveEntity(MyEntity entity) {
 repository.save(entity);
}


//when result != null, the @CachePut works.
@CachePut(key = "#id", condition="#result == null")
public void saveEntity1(MyEntity entity) {
 repository.save(entity);
}

清理全部緩存

通過allEntries、beforeInvocation屬性可以來清除全部緩存數據，不過allEntries是方法調用后清理，beforeInvocation是方法調用前清理。

//方法調用完成之后，清理所有緩存
@CacheEvict(value="myCache",allEntries=true)
public void delectAll() {
    repository.deleteAll();
}

//方法調用之前，清除所有緩存
@CacheEvict(value="myCache",beforeInvocation=true)
public void delectAll() {
    repository.deleteAll();
}

SpEL表達式

Spring Cache注解中頻繁用到SpEL表達式，那么具體如何使用呢？

SpEL 表達式的語法

Spring Cache可用的變量

最佳實踐

通過Spring緩存注解可以快速優雅地在我們項目中實現緩存的操作，但是在雙寫模式或者失效模式下，可能會出現緩存數據一致性問題（讀取到臟數據），Spring Cache 暫時沒辦法解決。最后我們再總結下Spring Cache使用的一些最佳實踐。

• 只緩存經常讀取的數據：緩存可以顯著提高性能，但只緩存經常訪問的數據很重要。很少或從不訪問的緩存數據會占用寶貴的內存資源，從而導致性能問題。
• 根據應用程序的特定需求選擇合適的緩存提供程序和策略。SpringBoot 支持多種緩存提供程序，包括 Ehcache、Hazelcast 和 Redis。
• 使用緩存時請注意潛在的線程安全問題。對緩存的并發訪問可能會導致數據不一致或不正確，因此選擇線程安全的緩存提供程序并在必要時使用適當的同步機制非常重要。
• 避免過度緩存。緩存對于提高性能很有用，但過多的緩存實際上會消耗寶貴的內存資源，從而損害性能。在緩存頻繁使用的數據和允許垃圾收集不常用的數據之間取得平衡很重要。
• 使用適當的緩存逐出策略。使用緩存時，重要的是定義適當的緩存逐出策略以確保在必要時從緩存中刪除舊的或陳舊的數據。
• 使用適當的緩存鍵設計。緩存鍵對于每個數據項都應該是唯一的，并且應該考慮可能影響緩存數據的任何相關參數，例如用戶 ID、時間或位置。
• 常規數據（讀多寫少、即時性與一致性要求不高的數據）完全可以使用 Spring Cache，至于寫模式下緩存數據一致性問題的解決，只要緩存數據有設置過期時間就足夠了。
• 特殊數據（讀多寫多、即時性與一致性要求非常高的數據），不能使用 Spring Cache，建議考慮特殊的設計（例如使用 Cancal 中間件等）。