@Autowire
    private UserMapper userMapper;

    @Autowire
    private RedisCache redisCache;

    //查詢用戶
    public User getUserById(Long userId) {
        //定義緩存key
        String cacheKey = "userId_" + userId;
        //先查詢redis緩存
        User user = redisCache.get(cacheKey);
        //如果緩存中有就直接返回，不再查詢數據庫
        if (user != null) {
            return user;
        }
        //沒有再查詢數據庫
        user = userMapper.getUserById(userId);

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

        return user;
    }

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

    @Autowire
    private UserMapper userMapper;

    //查詢用戶
    public User getUserById(Long userId) {
        return userMapper.getUserById(userId);
    }

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

public interface Cache {

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

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

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

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

	// 通過key獲取緩存值，可以使用valueLoader.call()來調使用@Cacheable注解的方法。當@Cacheable注解的sync屬性配置為true時使用此方法。
	// 因此方法內需要保證回源到數據庫的同步性。避免在緩存失效時大量請求回源到數據庫
	<T> T get(Object key, Callable<T> valueLoader);

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

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

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

	// 清空緩存
	void clear();

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

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

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

public interface CacheManager {

	// 通過cacheName創(chuàng)建Cache的實現bean，具體實現中需要存儲已創(chuàng)建的Cache實現bean，避免重復創(chuàng)建，也避免內存緩存
        //對象（如Caffeine）重新創(chuàng)建后原來緩存內容丟失的情況
	Cache getCache(String name);

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

public @interface Cacheable {

    // cacheNames，CacheManager就是通過這個名稱創(chuàng)建對應的Cache實現bean
	@AliasFor("cacheNames")
	String[] value() default {};

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

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

	// 緩存key生成器，默認實現是SimpleKeyGenerator
	String keyGenerator() default "";

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

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

	// 緩存的條件，支持SpEL表達式，當達到滿足的條件時才緩存數據。在調用方法前后都會判斷
	String condition() default "";
        
    // 滿足條件時不更新緩存，支持SpEL表達式，只在調用方法后判斷
	String unless() default "";

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

}

public @interface CacheEvict {

  // ...相同屬性說明請參考@Cacheable中的說明
	// 是否要清除所有緩存的數據，為false時調用的是Cache.evict(key)方法；為true時調用的是Cache.clear()方法
	boolean allEntries() default false;

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

FIFO：先進先出。選擇最先進入的數據優(yōu)先淘汰。
LRU：最近最少使用。選擇最近最少使用的數據優(yōu)先淘汰。
LFU：最不經常使用。選擇在一段時間內被使用次數最少的數據優(yōu)先淘汰。

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

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

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

/**
 *  啟動類
 */
@EnableCaching
@SpringBootApplication
public class CacheApplication {

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

}

/**
 *  測試
 */
@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", "趙六"));
    }

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


    /**
     * 獲取或加載緩存項
     * <p>
     * 注：因底層是基于caffeine來實現一級緩存，所以利用的caffeine本身的同步機制來實現
     * sync=true 則表示并發(fā)場景下同步加載緩存項，
     * sync=true，是通過get(Object key, Callable<T> valueLoader)來獲取或加載緩存項，此時valueLoader（加載緩存項的具體邏輯）會被緩存起來，所以CaffeineCache在定時刷新過期緩存時，緩存項過期則會重新加載。
     * sync=false，是通過get(Object key)來獲取緩存項，由于沒有valueLoader（加載緩存項的具體邏輯），所以CaffeineCache在定時刷新過期緩存時，緩存項過期則會被淘汰。
     * <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("加載數據:{}", 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;
    }
}