SpringBoot使用Caffeine实现内存缓存示例详解

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

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
/**
 * @author qinxun
 * @date 2023-06-05
 * @Descripion: caffeine使用
 */
@SpringBootTest
public class CacheTest {
    /**
     * 手动加载
     */
    @Test
    void test1() throws InterruptedException {
        Cache<Object, Object> cache = Caffeine.newBuilder()
                // 设置写入2分钟后失效
                .expireAfterWrite(2, TimeUnit.MINUTES)
                // 设置最多缓存数量
                .maximumSize(50)
                .build();
        // getIfPresent:获取指定key的数据 不存在返回null
        Object id = cache.getIfPresent("id");
        System.out.println(id);
        // get: 如果数据不存在就使用lambda表达式返回的数据设置缓存 并返回缓存数据
        Object obj = cache.get("id", (e) -> 10);
        System.out.println(obj);
        // put: 添加缓存
        cache.put("id", 20);
        Object obj1 = cache.getIfPresent("id");
        System.out.println(obj1);
        // put:添加缓存
        cache.put("name", "qq");
        // asMap: 获取缓存所有数据
        ConcurrentMap<@NonNull Object, @NonNull Object> map = cache.asMap();
        System.out.println(map);
        // invalidate: 移除指定key缓存
        cache.invalidate("name");
        ConcurrentMap<@NonNull Object, @NonNull Object> map1 = cache.asMap();
        System.out.println(map1);
        // invalidateAll: 移除所有缓存
        cache.invalidateAll();
        ConcurrentMap<@NonNull Object, @NonNull Object> map2 = cache.asMap();
        System.out.println(map2);
    }
}

    /**
     * 自动加载
     */
    @Test
    void test2(){
        AtomicInteger atomicInteger = new AtomicInteger(1);
        LoadingCache<String, Integer> cache = Caffeine.newBuilder()
                // 设置数据写入2分钟后过期
                .expireAfterWrite(2, TimeUnit.MINUTES)
                // 设置最多缓存数量
                .maximumSize(50)
                .build(new CacheLoader<String, Integer>() {
                    @Override
                    public @Nullable Integer load(@NonNull String s) throws Exception {
                        // 如果缓存的数据不存在 就返回这个自动加载的数据
                        return atomicInteger.get();
                    }
                });
        // get:如果缓存的数据不存在 就使用自动加载的数据
        Integer data1 = cache.get("id");
        System.out.println(data1);
        cache.put("age",2);
        //getAll:和get类似 如果缓存的key不存在就自动加载默认数据 否则返回缓存数据
        List<String> keyList = Lists.newArrayList("id","age");
        Map<@NonNull String, @NonNull Integer> map = cache.getAll(keyList);
        System.out.println(map);
    }

/**
     * 异步手动加载
     */
    @Test
    void test3() throws ExecutionException, InterruptedException {
        AsyncCache<Object, Object> asyncCache = Caffeine.newBuilder()
                .expireAfterWrite(2, TimeUnit.MINUTES)
                .maximumSize(50)
                .buildAsync();
        // getIfPresent(key): 不存在就返回null
        CompletableFuture<Object> idData = asyncCache.getIfPresent("id");
        System.out.println(idData);
        //get(key,(key)->{}):第二个参数表示当不存在时，初始化一个，并写入缓存中
        CompletableFuture<Object> idData2 = asyncCache.get("id", (key) -> 5);
        System.out.println(idData2.get());
        //put(key,CompletableFuture): 手动写入一个缓存
        asyncCache.put("id", CompletableFuture.supplyAsync(() -> 10));
        //asMap:返回所有缓存的数据
        ConcurrentMap<@NonNull Object, @NonNull CompletableFuture<Object>> map = asyncCache.asMap();
        for (Map.Entry<Object, CompletableFuture<Object>> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "==>" + entry.getValue().get());
        }
        //synchronous().invalidate(key): 移除缓存
        asyncCache.synchronous().invalidate("id");
        asyncCache.put("age", CompletableFuture.supplyAsync(() -> 20));
        ConcurrentMap<@NonNull Object, @NonNull CompletableFuture<Object>> map1 = asyncCache.asMap();
        for (Map.Entry<Object, CompletableFuture<Object>> entry : map1.entrySet()) {
            System.out.println(entry.getKey() + "==>" + entry.getValue().get());
        }
    }

   /**
     * 异步自动加载
     */
    @Test
    void test4() throws ExecutionException, InterruptedException {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        AsyncLoadingCache<String, Integer> asyncLoadingCache = Caffeine.newBuilder()
                .expireAfterWrite(2, TimeUnit.MINUTES)
                .maximumSize(50)
                .buildAsync(new CacheLoader<String, Integer>() {
                    @Override
                    public @Nullable Integer load(@NonNull String s) throws Exception {
                        // 缓存不存在的时候 自动加载这个数据
                        return atomicInteger.get();
                    }
                });
        //getIfPresent(key): 不存在就返回null
        CompletableFuture<Integer> idData = asyncLoadingCache.getIfPresent("id");
        System.out.println(idData);
        // get(key): 缓存不存在就使用自动加载的数据
        CompletableFuture<Integer> idData2 = asyncLoadingCache.get("id");
        System.out.println(idData2.get());
        // put:手动添加缓存
        asyncLoadingCache.put("age", CompletableFuture.supplyAsync(() -> 20));
        //asMap:返回所有缓存的数据
        ConcurrentMap<@NonNull String, @NonNull CompletableFuture<Integer>> map = asyncLoadingCache.asMap();
        for (Map.Entry<String, CompletableFuture<Integer>> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "==>" + entry.getValue().get());
        }
        // synchronous().invalidateAll(): 移除所有缓存
        asyncLoadingCache.synchronous().invalidateAll();
        CompletableFuture<Integer> ageData = asyncLoadingCache.getIfPresent("age");
        System.out.println(ageData);
    }