Springboot集成一二级缓存(caffeine+redis)

目的：主要是实现查询效率上的优化，减少数据库方面的压力，提升系统的性能
L1：一级缓存，主要是本地内存缓存，不需要网络传输，实时性很高，适合存储数据量少的数据，不可以持久化存储。
L2：二级缓存，独立于服务器/程序之外的外部缓存，适合存储数据量大大一点的数据，可持久化存储，性能稍慢于一级缓存，如redis，支持集群部署，多节点共享数据。

1.maven依赖#

对于2.7.x及以上版本的无需指定caffeine版本号，spring会自动去引入兼容版本。

1
    <dependency>
2
        <groupId>org.springframework.boot</groupId>
3
        <artifactId>spring-boot-starter-cache</artifactId>
4
    </dependency>
5
    <dependency>
6
        <groupId>com.github.ben-manes.caffeine</groupId>
7
        <artifactId>caffeine</artifactId>
8
    </dependency>

2.开始配置#

2.1 添加@EnableCaching注解#

在启动类上添加@EnableCaching开关。

1
@EnableCaching
2
@SpringBootApplication
3
public class SystemApplication {
4
    .......
5
}

2.2 创建CacheConfig类，注入到spring管理中#

一个是Caffeine本地缓存管理器，一个是多级缓存管理器。

1
@Configuration
2
@EnableCaching
3
public class CacheConfig {
4

5
    @Bean
6
    public CacheManager caffeineCacheManager() {
7
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
8
        cacheManager.setCaffeine(Caffeine.newBuilder()
9
                // 初始化容量
10
                .initialCapacity(100)
11
                // 最大容量
12
                .maximumSize(1000)
13
                // 过期时间
14
                .expireAfterWrite(3600, TimeUnit.SECONDS)
15
                .recordStats());
16
        return cacheManager;
17
    }
18

19

20
    * 一二级缓存管理器
21
     *
22
     * @param caffeineCacheManager Caffeine缓存管理
23
     * @param redisCacheUtil       redis工具类
24
     * @return
25
     */
26
    @Primary
27
    @Bean
28
    public CacheManager levelCacheManager(@Qualifier(value = "caffeineCacheManager") CacheManager caffeineCacheManager,
29
            @Autowired RedisCacheUtil redisCacheUtil) {
30
        return new LevelCacheManager(caffeineCacheManager, redisCacheUtil);
31
    }
32

33

34
}

2.3 创建一二级缓存管理器#

里面同时实现了对每个key值自定义过期时间，默认是设置通用过期时长。

1
public class LevelCacheManager implements CacheManager {
2

3
    private final CaffeineCacheManager caffeineCacheManager;
4
    private final RedisCacheUtil redisCacheUtil;
5

6
    public LevelCacheManager(CacheManager caffeineCacheManager, RedisCacheUtil redisCacheUtil) {
7
        this.caffeineCacheManager = (CaffeineCacheManager) caffeineCacheManager;
8
        this.redisCacheUtil = redisCacheUtil;
9
    }
10

11
    @Override
12
    public Cache getCache(String name) {
13
        CaffeineCache caffeineCache = parseName(name);
14
        return new LevelCache(name, caffeineCache, redisCacheUtil);
15
    }
16

17
    @Override
18
    public Collection<String> getCacheNames() {
19
        return Collections.emptyList();
20
    }
21

22
    private CaffeineCache parseName(String name) {
23
        long duration = 0; // 默认60分钟
24
        if (name.contains("#")) {
25
            // 解析名称中的有效期信息
26
            String[] parts = name.split("#");
27
            name = parts[0];
28
            if (parts.length > 1) {
29
                try {
30
                    duration = Long.parseLong(parts[1]);
31
                } catch (NumberFormatException e) {
32
                    e.printStackTrace();
33
                }
34
            }
35
        }
36
        com.github.benmanes.caffeine.cache.Cache<Object, Object> build = Caffeine.newBuilder()
37
                // 初始化容量
38
                .initialCapacity(100)
39
                // 最大容量
40
                .maximumSize(1000)
41
                // 过期时间
42
                .expireAfterWrite(duration, TimeUnit.SECONDS).recordStats().build();
43
        CaffeineCache caffeineCache = (CaffeineCache) caffeineCacheManager.getCache(name);
44
        CaffeineCache caffeineCache2 = new CaffeineCache(name, build);
45
        if (duration > 0) {
46
            redisCacheUtil.setEXPIRE_TIME(duration);
47
            return caffeineCache2;
48
        }
49
        redisCacheUtil.setEXPIRE_TIME(3600L);
50
        return caffeineCache;
51
    }

2.4 自定义一,二级缓存操作类#

实现一二级缓存顺序读取，先查一级再查二级缓存，序列化方式保持一致。

1
public class LevelCache implements Cache {
2

3
    private final RedisCacheUtil redisCacheUtil;
4
    private final String name;
5
    private final CaffeineCache caffeineCache;
6

7

8
    public LevelCache(String name, CaffeineCache caffeineCache, RedisCacheUtil redisCacheUtil){
9
        this.name=name;
10
        this.caffeineCache = caffeineCache;
11
        this.redisCacheUtil = redisCacheUtil;
12
    }
13

14
    @Override
15
    public String getName() {
16
        return name;
17
    }
18

19

20
    /**
21
     * 仅当缓存中不存在指定键时，才将键值对存入缓存。若键已存在，不会进行覆盖操作，而是返回缓存中现有的值。
22
     * @param key
23
     * @param value
24
     * @return
25
     */
26
    @Override
27
    public ValueWrapper putIfAbsent(Object key, Object value) {
28
        ValueWrapper existingValue = this.get(key);
29
        if (existingValue == null) {
30
            caffeineCache.put(key, value);
31
        }
32
        Object obj = redisCacheUtil.get(String.valueOf(key));
33
        if (obj==null){
34
            redisCacheUtil.set(String.valueOf(key),value,redisCacheUtil.getEXPIRE_TIME());
35
        }
36
        return this.get(key);
37
    }
38

39
    @Override
40
    public Object getNativeCache() {
41
        return null;
42
    }
43

44
    /**
45
     * 获取缓存中的数据
46
     * @param key
47
     * @return
48
     */
49
    @Override
50
    public ValueWrapper get(Object key) {
51
        ValueWrapper valueWrapper = caffeineCache.get(key);
52
        if (valueWrapper != null){
53
            return valueWrapper;
54
        }
55
        Object value= redisCacheUtil.get(String.valueOf(key));
56
        if(value!=null){
57
            caffeineCache.put(key, value);
58
            return this.get(key);
59
        }
60
        return null;
61
    }
62

63
    /**
64
     * 获取缓存中数据，具体对象
65
     * @param key
66
     * @param type
67
     * @return
68
     * @param <T>
69
     */
70
    @Override
71
    public <T> T get(Object key, Class<T> type) {
72
        T value = caffeineCache.get(key, type);
73
        if (value != null){
74
            return value;
75
        }
76
        Object rValue = redisCacheUtil.get(String.valueOf(key));
77
        if (rValue != null){
78
            caffeineCache.put(key,rValue);
79
            return (T) rValue;
80
        }
81
        return null;
82
    }
83

84

85
    /**
86
     * 如果一二级缓存中都不存在情况下，使用自定义的valueLoader加载数据，并缓存到一级缓存和二级缓存中
87
     * @param key
88
     * @param valueLoader
89
     * @return
90
     * @param <T>
91
     */
92
    @Override
93
    public <T> T get(Object key, Callable<T> valueLoader) {
94
        ValueWrapper value=this.get(key);
95
        if (value!=null) {
96
            return (T) value.get();
97
        }else{
98
            Object obj;
99
            try {
100
                obj = valueLoader.call();
101
            } catch (Exception e) {
102
                throw new RuntimeException(e);
103
            }
104
            caffeineCache.put(key,obj);
105
            redisCacheUtil.set(String.valueOf(key),obj,redisCacheUtil.getEXPIRE_TIME());
106
            return (T)obj;
107
        }
108
    }
109

110
    /**
111
     * 填入一二级缓存
112
     * @param key
113
     * @param value
114
     */
115
    @Override
116
    public void put(Object key, Object value) {
117
        caffeineCache.put(key,value);
118
        redisCacheUtil.set(String.valueOf(key),value,redisCacheUtil.getEXPIRE_TIME());
119
    }
120

121

122
    /**
123
     * 移除指定key值的一二级缓存
124
     * @param key
125
     */
126
    @Override
127
    public void evict(Object key) {
128
        caffeineCache.evict(key);
129
        redisCacheUtil.del(String.valueOf(key));
130
    }
131

132

133
    /**
134
     * 删除所有一二级缓存
135
     */
136
    @Override
137
    public void clear() {
138
        caffeineCache.clear();
139
        redisCacheUtil.delByPrefix(CacheKeyGenerator.KEY_PREFIX);
140
    }
141
}

2.5 自定义key值前缀工具类#

在配合方法参数时，可以自己拼接前缀在key前面，实现统一管理。

1
public class CacheKeyGenerator {
2

3
    public static final String KEY_PREFIX = "levelCache:";
4
    public static final String USER_CACHE = "userCaches";
5

6
    public static String generateKey(String name) {
7
        return KEY_PREFIX + name;
8
    }
9
}

2.6 使用注解方式实现案例#

1
    @Override
2
    @Cacheable(cacheNames = CacheKeyGenerator.USER_CACHE+"#10",
3
            key= "T(com.makingTeam.config.cache.CacheKeyGenerator).generateKey(#name)")
4
    public Object login(String name, String pwd) {
5
        Map<Object, Object> objectObjectMap = new HashMap<>();
6
        objectObjectMap.put(name, pwd);
7
        log.info("login-----查找数据库");
8
        return objectObjectMap;
9
    }
10

11
    @Override
12
    @CachePut(cacheNames = CacheKeyGenerator.USER_CACHE+"#30",
13
            key= "T(com.makingTeam.config.cache.CacheKeyGenerator).generateKey(#name)")
14
    public Object updateLogin(String name, String pwd) {
15
        Map<Object, Object> objectObjectMap = new HashMap<>();
16
        objectObjectMap.put(name, pwd);
17
        log.info("updateLogin----查找数据库");
18
        return objectObjectMap;
19
    }
20

21
    @CacheEvict(cacheNames = CacheKeyGenerator.USER_CACHE,
22
            key= "T(com.makingTeam.config.cache.CacheKeyGenerator).generateKey(#name)")
23
    @Override
24
    public void del(String name) {
25
        log.info("del----删除");
26
    }

完结！

音乐

音乐