@Autowire
    private UserMapper userMapper;

    @Autowire
    private RedisCache redisCache;

    //查詢(xún)用戶(hù)
    public User getUserById(Long userId) {
        //定義緩存key
        String cacheKey = "userId_" + userId;
        //先查詢(xún)r(jià)edis緩存
        User user = redisCache.get(cacheKey);
        //如果緩存中有就直接返回，不再查詢(xún)數(shù)據(jù)庫(kù)
        if (user != null) {
            return user;
        }
        //沒(méi)有再查詢(xún)數(shù)據(jù)庫(kù)
        user = userMapper.getUserById(userId);

        //數(shù)據(jù)存入緩存，這樣下次查詢(xún)就能到緩存中獲取
        if (user != null) {
            stringCommand.set(cacheKey, user);
        }

        return user;
    }

@Mapper
public interface UserMapper  {
    
    /**
     * 根據(jù)用戶(hù)id獲取用戶(hù)信息
     *
     * 如果緩存中有直接返回緩存數(shù)據(jù)，如果沒(méi)有那么就去數(shù)據(jù)庫(kù)查詢(xún)，查詢(xún)完再插入緩存中，這里緩存的key前綴為cache_user_id_，+傳入的用戶(hù)ID
     */
    @Cacheable(key = "'cache_user_id_' + #userId")
    User getUserById(Long userId);
}

    @Autowire
    private UserMapper userMapper;

    //查詢(xún)用戶(hù)
    public User getUserById(Long userId) {
        return userMapper.getUserById(userId);
    }

package org.Springframework.cache;
import java.util.concurrent.Callable;

public interface Cache {

	// cacheName，緩存的名字，默認(rèn)實(shí)現(xiàn)中一般是CacheManager創(chuàng)建Cache的bean時(shí)傳入cacheName
	String getName();

	//得到底層使用的緩存，如Ehcache
	Object getNativeCache();

	// 通過(guò)key獲取緩存值，注意返回的是ValueWrapper，為了兼容存儲(chǔ)空值的情況，將返回值包裝了一層，通過(guò)get方法獲取實(shí)際值
	ValueWrapper get(Object key);

	// 通過(guò)key獲取緩存值，返回的是實(shí)際值，即方法的返回值類(lèi)型
	<T> T get(Object key, Class<T> type);

	// 通過(guò)key獲取緩存值，可以使用valueLoader.call()來(lái)調(diào)使用@Cacheable注解的方法。當(dāng)@Cacheable注解的sync屬性配置為true時(shí)使用此方法。
	// 因此方法內(nèi)需要保證回源到數(shù)據(jù)庫(kù)的同步性。避免在緩存失效時(shí)大量請(qǐng)求回源到數(shù)據(jù)庫(kù)
	<T> T get(Object key, Callable<T> valueLoader);

	// 將@Cacheable注解方法返回的數(shù)據(jù)放入緩存中
	void put(Object key, Object value);

	// 當(dāng)緩存中不存在key時(shí)才放入緩存。返回值是當(dāng)key存在時(shí)原有的數(shù)據(jù)
	ValueWrapper putIfAbsent(Object key, Object value);

	// 刪除緩存
	void evict(Object key);

	// 清空緩存
	void clear();

	// 緩存返回值的包裝
	interface ValueWrapper {

	// 返回實(shí)際緩存的對(duì)象
		Object get();
	}
}

package org.Springframework.cache;
import java.util.Collection;

public interface CacheManager {

	// 通過(guò)cacheName創(chuàng)建Cache的實(shí)現(xiàn)bean，具體實(shí)現(xiàn)中需要存儲(chǔ)已創(chuàng)建的Cache實(shí)現(xiàn)bean，避免重復(fù)創(chuàng)建，也避免內(nèi)存緩存
        //對(duì)象（如Caffeine）重新創(chuàng)建后原來(lái)緩存內(nèi)容丟失的情況
	Cache getCache(String name);

	// 返回所有的cacheName
	Collection<String> getCacheNames();
}

public @interface Cacheable {

    // cacheNames，CacheManager就是通過(guò)這個(gè)名稱(chēng)創(chuàng)建對(duì)應(yīng)的Cache實(shí)現(xiàn)bean
	@AliasFor("cacheNames")
	String[] value() default {};

	@AliasFor("value")
	String[] cacheNames() default {};

    // 緩存的key，支持SpEL表達(dá)式。默認(rèn)是使用所有參數(shù)及其計(jì)算的hashCode包裝后的對(duì)象（SimpleKey）
	String key() default "";

	// 緩存key生成器，默認(rèn)實(shí)現(xiàn)是SimpleKeyGenerator
	String keyGenerator() default "";

	// 指定使用哪個(gè)CacheManager,如果只有一個(gè)可以不用指定
	String cacheManager() default "";

	// 緩存解析器
	String cacheResolver() default "";

	// 緩存的條件，支持SpEL表達(dá)式，當(dāng)達(dá)到滿(mǎn)足的條件時(shí)才緩存數(shù)據(jù)。在調(diào)用方法前后都會(huì)判斷
	String condition() default "";
        
    // 滿(mǎn)足條件時(shí)不更新緩存，支持SpEL表達(dá)式，只在調(diào)用方法后判斷
	String unless() default "";

	// 回源到實(shí)際方法獲取數(shù)據(jù)時(shí)，是否要保持同步，如果為false，調(diào)用的是Cache.get(key)方法；如果為true，調(diào)用的是Cache.get(key, Callable)方法
	boolean sync() default false;

}

public @interface CacheEvict {

  // ...相同屬性說(shuō)明請(qǐng)參考@Cacheable中的說(shuō)明
	// 是否要清除所有緩存的數(shù)據(jù)，為false時(shí)調(diào)用的是Cache.evict(key)方法；為true時(shí)調(diào)用的是Cache.clear()方法
	boolean allEntries() default false;

	// 調(diào)用方法之前或之后清除緩存
	boolean beforeInvocation() default false;
}

FIFO：先進(jìn)先出。選擇最先進(jìn)入的數(shù)據(jù)優(yōu)先淘汰。
LRU：最近最少使用。選擇最近最少使用的數(shù)據(jù)優(yōu)先淘汰。
LFU：最不經(jīng)常使用。選擇在一段時(shí)間內(nèi)被使用次數(shù)最少的數(shù)據(jù)優(yōu)先淘汰。

   <dependency>
            <groupId>com.jincou</groupId>
            <artifactId>redis-caffeine-cache-starter</artifactId>
            <version>1.0.0</version>
   </dependency>

# 二級(jí)緩存配置
# 注：caffeine 不適用于數(shù)據(jù)量大，并且緩存命中率極低的業(yè)務(wù)場(chǎng)景，如用戶(hù)維度的緩存。請(qǐng)慎重選擇。
l2cache:
  config:
    # 是否存儲(chǔ)空值，默認(rèn)true，防止緩存穿透
    allowNullValues: true
    # 組合緩存配置
    composite:
      # 是否全部啟用一級(jí)緩存，默認(rèn)false
      l1AllOpen: false
      # 是否手動(dòng)啟用一級(jí)緩存，默認(rèn)false
      l1Manual: true
      # 手動(dòng)配置走一級(jí)緩存的緩存key集合，針對(duì)單個(gè)key維度
      l1ManualKeySet:
      - userCache:user01
      - userCache:user02
      - userCache:user03
      # 手動(dòng)配置走一級(jí)緩存的緩存名字集合，針對(duì)cacheName維度
      l1ManualCacheNameSet:
      - userCache
      - goodsCache
    # 一級(jí)緩存
    caffeine:
      # 是否自動(dòng)刷新過(guò)期緩存 true 是 false 否
      autoRefreshExpireCache: false
      # 緩存刷新調(diào)度線(xiàn)程池的大小
      refreshPoolSize: 2
      # 緩存刷新的頻率(秒)
      refreshPeriod: 10
      # 寫(xiě)入后過(guò)期時(shí)間(秒)
      expireAfterWrite: 180
      # 訪(fǎng)問(wèn)后過(guò)期時(shí)間(秒)
      expireAfterAccess: 180
      # 初始化大小
      initialCapacity: 1000
      # 最大緩存對(duì)象個(gè)數(shù)，超過(guò)此數(shù)量時(shí)之前放入的緩存將失效
      maximumSize: 3000

    # 二級(jí)緩存
    redis:
      # 全局過(guò)期時(shí)間，單位毫秒，默認(rèn)不過(guò)期
      defaultExpiration: 300000
      # 每個(gè)cacheName的過(guò)期時(shí)間，單位毫秒，優(yōu)先級(jí)比defaultExpiration高
      expires: {userCache: 300000,goodsCache: 50000}
      # 緩存更新時(shí)通知其他節(jié)點(diǎn)的topic名稱(chēng) 默認(rèn) cache:redis:caffeine:topic
      topic: cache:redis:caffeine:topic

/**
 *  啟動(dòng)類(lèi)
 */
@EnableCaching
@SpringBootApplication
public class CacheApplication {

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

}

/**
 *  測(cè)試
 */
@Service
public class CaffeineCacheService {

    private final Logger logger = LoggerFactory.getLogger(CaffeineCacheService.class);

    /**
     * 用于模擬db
     */
    private static Map<String, UserDTO> userMap = new HashMap<>();

    {
        userMap.put("user01", new UserDTO("1", "張三"));
        userMap.put("user02", new UserDTO("2", "李四"));
        userMap.put("user03", new UserDTO("3", "王五"));
        userMap.put("user04", new UserDTO("4", "趙六"));
    }

    /**
     * 獲取或加載緩存項(xiàng)
     */
    @Cacheable(key = "'cache_user_id_' + #userId", value = "userCache")
    public UserDTO queryUser(String userId) {
        UserDTO userDTO = userMap.get(userId);
        try {
            Thread.sleep(1000);// 模擬加載數(shù)據(jù)的耗時(shí)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("加載數(shù)據(jù):{}", userDTO);
        return userDTO;
    }


    /**
     * 獲取或加載緩存項(xiàng)
     * <p>
     * 注：因底層是基于caffeine來(lái)實(shí)現(xiàn)一級(jí)緩存，所以利用的caffeine本身的同步機(jī)制來(lái)實(shí)現(xiàn)
     * sync=true 則表示并發(fā)場(chǎng)景下同步加載緩存項(xiàng)，
     * sync=true，是通過(guò)get(Object key, Callable<T> valueLoader)來(lái)獲取或加載緩存項(xiàng)，此時(shí)valueLoader（加載緩存項(xiàng)的具體邏輯）會(huì)被緩存起來(lái)，所以CaffeineCache在定時(shí)刷新過(guò)期緩存時(shí)，緩存項(xiàng)過(guò)期則會(huì)重新加載。
     * sync=false，是通過(guò)get(Object key)來(lái)獲取緩存項(xiàng)，由于沒(méi)有valueLoader（加載緩存項(xiàng)的具體邏輯），所以CaffeineCache在定時(shí)刷新過(guò)期緩存時(shí)，緩存項(xiàng)過(guò)期則會(huì)被淘汰。
     * <p>
     */
    @Cacheable(value = "userCache", key = "#userId", sync = true)
    public List<UserDTO> queryUserSyncList(String userId) {
        UserDTO userDTO = userMap.get(userId);
        List<UserDTO> list = new ArrayList();
        list.add(userDTO);
        logger.info("加載數(shù)據(jù):{}", list);
        return list;
    }

    /**
     * 更新緩存
     */
    @CachePut(value = "userCache", key = "#userId")
    public UserDTO putUser(String userId, UserDTO userDTO) {
        return userDTO;
    }

    /**
     * 淘汰緩存
     */
    @CacheEvict(value = "userCache", key = "#userId")
    public String evictUserSync(String userId) {
        return userId;
    }
}