【Caffeine入门】浅谈缓存框架Caffeine_caffeine 入门

Caffeine是一个基于Java8的高性能缓存框架，号称趋于完美。Caffeine受启发于Guava Cache的API，使用API和Guava是一致的。它借鉴了Guava Cache和ConcurrentLinkedHashMap的设计经验。

在Springboot中使用Caffeine

在工程的pom文件引入caffeine的依赖，如下：

<dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>2.6.2</version>
        </dependency>
1
2
3
4
5

创建一个抽象类AbstractCaffineCache，该类使用范型来约束缓存的数据类型，并实现了三个方法，put、get、clear。

/**
 * @Author ZhuZiKai
 * @Description
 * @date 2022/3/7 10:44
 */
public abstract class AbstractCaffeineCache<T> {

    protected LoadingCache<String, T> loadingCache;

    abstract LoadingCache<String, T> createLoadingCache();

    public boolean put(String key, T value) {
        if (loadingCache == null) {
            loadingCache = createLoadingCache();
        }
        loadingCache.put(key, value);

        return Boolean.TRUE;
    }

    public T get(String key) {
        if (loadingCache == null) {
            loadingCache = createLoadingCache();
        }
        try {

            return loadingCache.get(key);
        } catch (Exception e) {
            return null;
        }
    }

    public boolean clear(String key) {
        if (loadingCache == null) {
            loadingCache = createLoadingCache();
        }
        loadingCache.invalidate(key);
        return Boolean.TRUE;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

创建MyCaffeineCache的缓存类，该类缓存类。创建LoadingCache类，该类设置了缓存过期的时间，最大的缓存个数。

/**
 * @Author ZhuZiKai
 * @Description
 * @date 2022/3/7 10:44
 */

public class MyCaffeineCache extends AbstractCaffeineCache {

    /**
     * Caffeine配置说明：
     * initialCapacity=[integer]: 初始的缓存空间大小
     * maximumSize=[long]: 缓存的最大条数
     * maximumWeight=[long]: 缓存的最大权重
     * expireAfterAccess=[duration]: 最后一次写入或访问后经过固定时间过期
     * expireAfterWrite=[duration]: 最后一次写入后经过固定时间过期
     * refreshAfterWrite=[duration]: 创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存
     * recordStats：开发统计功能
     *
     * @return
     */
    @Override
    LoadingCache createLoadingCache() {
        loadingCache = Caffeine.newBuilder()
                .expireAfterWrite(1000L, TimeUnit.MILLISECONDS)
                .initialCapacity(10)
                .maximumSize(100)
                .recordStats()
                .build((CacheLoader<String, String>) key -> null);
        return loadingCache;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

将MyCaffeineCache注入到spring ioc中，代码如下：

/**
 * @Author ZhuZiKai
 * @Description
 * @date 2022/3/7 10:45
 */
@Configuration
public class CaffeineCacheConfig {
    @Bean
    public MyCaffeineCache MyCaffeineCache(){
        return new MyCaffeineCache();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

如何使用。

/**
 * @Author ZhuZiKai
 * @Description
 * @date 2022/1/6 9:45
 */
@Aspect
@Component
@Slf4j
public class IdempotentAspect extends BaseController {

    @Resource
    private MyCaffeineCache cache;

    private static final ThreadLocalUtil threadLocalUtil = new ThreadLocalUtil();

    @Around(value = "@annotation(idempotent)")
    public Object around(ProceedingJoinPoint joinPoint, Idempotent idempotent) throws Throwable {

        UserBO user = getUserBO(request);
        Integer userId = user.getUserId();

        String userRequest = userId + request.getRequestURI();

        threadLocalUtil.setLocalUserRequest(userRequest);

        Object uuid = cache.get(userRequest);
        VerifyUtils.throwWhen(uuid != null, idempotent.value());

        return joinPoint.proceed();

    }

    @AfterReturning(value = "@annotation(idempotent)")
    public void afterReturning(JoinPoint point, Idempotent idempotent) {
        try {
            cache.put(threadLocalUtil.getLocalUserRequest(), UUIDUtil.simpleUUID());
        } finally {
            threadLocalUtil.clearLocalUserRequest();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

使用本地缓存可以加快页面响应速度，缓存分布式缓存读压力，大量、高并发请求的网站比较适用

Caffeine配置说明：

• initialCapacity=[integer]: 初始的缓存空间大小
• maximumSize=[long]: 缓存的最大条数
• maximumWeight=[long]: 缓存的最大权重
• expireAfterAccess=[duration]: 最后一次写入或访问后经过固定时间过期
• expireAfterWrite=[duration]: 最后一次写入后经过固定时间过期
• refreshAfterWrite=[duration]: 创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存
• recordStats：开发统计功能

注意：
expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准。