<dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
        </dependency>

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.cuzue.common.core.exception.BusinessException;
import com.cuzue.dao.cache.redis.RedisClient;
import org.redisson.api.RBucket;
import org.redisson.api.RKeys;
import org.redisson.api.RedissonClient;

import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

public class RedisCacheProvider {

    private static RedissonClient redissonClient;

    public RedisCacheProvider(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    /**
     * 從redissonClient緩存中取數(shù)據(jù)，如果沒有，查數(shù)據(jù)后存入
     *
     * @param key         redis key
     * @param dataFetcher 獲取數(shù)據(jù)
     * @param ttl         緩存時間
     * @param timeUnit    緩存時間單位
     * @param <T>
     * @return 數(shù)據(jù)
     */
    public <T> List<T> getCachedList(String key, Supplier<List<T>> dataFetcher, long ttl, TimeUnit timeUnit) {
        if (ObjectUtil.isNotNull(redissonClient)) {
            // 嘗試從緩存中獲取數(shù)據(jù)
            List<T> cachedData = redissonClient.getList(key);
            if (cachedData.size() > 0) {
                // 緩存中有數(shù)據(jù)，直接返回
                return cachedData;
            } else {
                // 緩存中沒有數(shù)據(jù)，調(diào)用數(shù)據(jù)提供者接口從數(shù)據(jù)庫中獲取
                List<T> data = dataFetcher.get();
                cachedData.clear();
                cachedData.addAll(data);
                // 將數(shù)據(jù)存入緩存，并設(shè)置存活時間
                // 獲取 bucket 對象，為了設(shè)置過期時間
                RBucket<List<T>> bucket = redissonClient.getBucket(key);
                // 為整個列表設(shè)置過期時間
                bucket.expire(ttl, timeUnit);
                // 返回新獲取的數(shù)據(jù)
                return data;
            }
        } else {
            throw new BusinessException("redissonClient has not initialized");
        }
    }

    /**
     * 刪除緩存
     *
     * @param key redis key
     */
    public void deleteCachedList(String systemName, String key) {
        if (ObjectUtil.isNotNull(redissonClient)) {
            RKeys keys = redissonClient.getKeys();
            keys.deleteByPattern(key);
        } else {
            throw new BusinessException("redis client has not initialized");
        }
    }
}

@Resource
private RedissonClient redissonClient;

//緩存數(shù)據(jù)獲取
public List<MatMaterialsResp> listCache(ListQO qo) {
    RedisCacheProvider cache = new RedisCacheProvider(redissonClient);
    List<MatMaterialsResp> resps = cache.getCachedList("testList", () -> {
        // 緩存數(shù)據(jù)查詢
    }, 20, TimeUnit.SECONDS);
    return resps;
}

       <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>3.0.5</version>
        </dependency>

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Weigher;

import java.util.concurrent.TimeUnit;
import java.util.function.Function;

public class CaffeineCache<K, V> {
    private final Cache<K, V> cache;

    /**
     * 不過期緩存
     *
     * @param maxSize 緩存條目數(shù)量 注意對象大小不要超過jvm內(nèi)存
     */
    public CaffeineCache(long maxSize) {
        this.cache = Caffeine.newBuilder()
                .maximumSize(maxSize)
                .build();
    }

    /**
     * 初始化Caffeine
     *
     * @param maxSize
     * @param expireAfterWriteDuration
     * @param unit
     */
    public CaffeineCache(long maxSize, long expireAfterWriteDuration, TimeUnit unit) {
        this.cache = Caffeine.newBuilder()
                .maximumSize(maxSize)
                .expireAfterWrite(expireAfterWriteDuration, unit)
                .build();
    }

    /**
     * 初始化Caffeine 帶權(quán)重
     *
     * @param maxSize
     * @param weigher                  權(quán)重
     * @param expireAfterWriteDuration
     * @param unit
     */
    public CaffeineCache(long maxSize, Weigher weigher, long expireAfterWriteDuration, TimeUnit unit) {
        this.cache = Caffeine.newBuilder()
                .maximumSize(maxSize)
                .weigher(weigher)
                .expireAfterWrite(expireAfterWriteDuration, unit)
                .build();
    }

    public V get(K key) {
        return cache.getIfPresent(key);
    }

    public void put(K key, V value) {
        cache.put(key, value);
    }

    public void remove(K key) {
        cache.invalidate(key);
    }

    public void clear() {
        cache.invalidateAll();
    }

    // 如果你需要一個加載功能（當(dāng)緩存miss時自動加載值），你可以使用這個方法
    public V get(K key, Function<? super K, ? extends V> mappingFunction) {
        return cache.get(key, mappingFunction);
    }

    // 添加獲取緩存統(tǒng)計信息的方法
    public String stats() {
        return cache.stats().toString();
    }
}

import cn.hutool.core.util.ObjectUtil;
import com.cuzue.dao.cache.localcache.CaffeineCache;

import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 本地緩存
 */
public class LocalCacheProvider {

    private static CaffeineCache cache;

    /**
     * 無過期時間
     * @param maxSize 緩存最大條數(shù)
     */
    public LocalCacheProvider(long maxSize) {
        cache = new CaffeineCache(maxSize);
    }

    /**
     * 帶過期時間
     * @param maxSize 緩存最大條數(shù)
     * @param ttl 過期時間
     * @param timeUnit 時間單位
     */
    public LocalCacheProvider(long maxSize, long ttl, TimeUnit timeUnit) {
        cache = new CaffeineCache(maxSize, ttl, timeUnit);
    }

    public static <T> List<T> getCachedList(String key, Supplier<List<T>> dataFetcher) {
        if (ObjectUtil.isNotNull(cache.get(key))) {
            return (List<T>) cache.get(key);
        } else {
            List<T> data = dataFetcher.get();
            cache.put(key, data);
            return data;
        }
    }

    public static <T> List<T> getCachedList(String key, Function<String, List<T>> dataFetcher) {
        return (List<T>) cache.get(key, dataFetcher);
    }

    /**
     * 刪除緩存
     *
     * @param key redis key
     */
    public void deleteCachedList(String key) {
        cache.remove(key);
    }
}

//初始化caffeine對象
LocalCacheProvider cache = new LocalCacheProvider(5000, 20, TimeUnit.SECONDS);

//緩存數(shù)據(jù)獲取
public List<MatMaterialsResp> listLocalCache(ListQO qo) {
    List<MatMaterialsResp> resps = cache.getCachedList("testList", (s) -> {
	  // 緩存數(shù)據(jù)查詢
    });
    return resps;
}

db > 1s
redis > 468ms
local > 131ms

db > 208ms
redis > 428ms
local > 96ms