项目中多级缓存设计实践总结

缓存的重要性

简而言之，缓存的原理就是利用空间来换取时间。通过将数据存到访问速度更快的空间里以便下一次访问时直接从空间里获取，从而节省时间。
我们以CPU的缓存体系为例：

CPU缓存体系是多层级的。分成了CPU -> L1 -> L2 -> L3 -> 主存。我们可以得到以下启示。

• 越频繁使用的数据，使用的缓存速度越快
  
• 越快的缓存，它的空间越小
  

而我们项目的缓存设计可以借鉴CPU多级缓存的设计。
关于多级缓存体系实现在开源项目中：https://github.com/valarchie/AgileBoot-Back-End
缓存分层

首先我们可以给缓存进行分层。在Java中主流使用的三类缓存主要有：

• Map(原生缓存)
  
• Guava/Caffeine(功能更强大的内存缓存)
  
• Redis/Memcached(缓存中间件)
  

在一些项目中，会一刀切将所有的缓存都使用Redis或者Memcached中间件进行存取。
使用缓存中间件避免不了网络请求成本和用户态和内核态的切换。 更合理的方式应该是根据数据的特点来决定使用哪个层级的缓存。
Map(一级缓存)

项目中的字典类型的数据比如：性别、类型、状态等一些不变的数据。我们完全可以存在Map当中。
因为Map的实现非常简单，效率上是非常高的。由于我们存的数据都是一些不变的数据，一次性存好并不会再去修改它们。所以不用担心内存溢出的问题。 以下是关于字典数据使用Map缓存的简单代码实现。

1. /**
2. * 本地一级缓存  使用Map
3. *
4. * @author valarchie
5. */
6. public class MapCache {
7.     private static final Map<String, List<DictionaryData>> DICTIONARY_CACHE = MapUtil.newHashMap(128);
9.     static {
10.         initDictionaryCache();
11.     }
13.     private static void initDictionaryCache() {
15.         loadInCache(BusinessTypeEnum.values());
16.         loadInCache(YesOrNoEnum.values());
17.         loadInCache(StatusEnum.values());
18.         loadInCache(GenderEnum.values());
19.         loadInCache(NoticeStatusEnum.values());
20.         loadInCache(NoticeTypeEnum.values());
21.         loadInCache(OperationStatusEnum.values());
22.         loadInCache(VisibleStatusEnum.values());
24.     }
26.     public static Map<String, List<DictionaryData>> dictionaryCache() {
27.         return DICTIONARY_CACHE;
28.     }
30.     private static void loadInCache(DictionaryEnum[] dictionaryEnums) {
31.         DICTIONARY_CACHE.put(getDictionaryName(dictionaryEnums[0].getClass()), arrayToList(dictionaryEnums));
32.     }
34.     private static String getDictionaryName(Class<?> clazz) {
35.         Objects.requireNonNull(clazz);
36.         Dictionary annotation = clazz.getAnnotation(Dictionary.class);
38.         Objects.requireNonNull(annotation);
39.         return annotation.name();
40.     }
42.     @SuppressWarnings("rawtypes")
43.     private static List<DictionaryData> arrayToList(DictionaryEnum[] dictionaryEnums) {
44.         if(ArrayUtil.isEmpty(dictionaryEnums)) {
45.             return ListUtil.empty();
46.         }
47.         return Arrays.stream(dictionaryEnums).map(DictionaryData::new).collect(Collectors.toList());
48.     }
49. }

复制代码

Guava（二级缓存）

项目中的一些自定义数据比如角色，部门。这种类型的数据往往不会非常多。而且请求非常频繁。比如接口中经常要校验角色相关的权限。我们可以使用Guava或者Caffeine这种内存框架作为二级缓存使用。
Guava或者Caffeine的好处可以支持缓存的过期时间以及缓存的淘汰，避免内存溢出。
以下是利用模板设计模式做的GuavaCache模板类。

1. /**
2. * 缓存接口实现类  二级缓存
3. * @author valarchie
4. */
5. @Slf4j
6. public abstract class AbstractGuavaCacheTemplate<T> {
8.     private final LoadingCache<String, Optional<T>> guavaCache = CacheBuilder.newBuilder()
9.         // 基于容量回收。缓存的最大数量。超过就取MAXIMUM_CAPACITY = 1 << 30。依靠LRU队列recencyQueue来进行容量淘汰
10.         .maximumSize(1024)
11.         // 基于容量回收。但这是统计占用内存大小，maximumWeight与maximumSize不能同时使用。设置最大总权重
12.         // 没写访问下，超过5秒会失效(非自动失效，需有任意put get方法才会扫描过期失效数据。但区别是会开一个异步线程进行刷新，刷新过程中访问返回旧数据)
13.         .refreshAfterWrite(5L, TimeUnit.MINUTES)
14.         // 移除监听事件
15.         .removalListener(removal -> {
16.             // 可做一些删除后动作，比如上报删除数据用于统计
17.             log.info("触发删除动作，删除的key={}, value={}", removal.getKey(), removal.getValue());
18.         })
19.         // 并行等级。决定segment数量的参数，concurrencyLevel与maxWeight共同决定
20.         .concurrencyLevel(16)
21.         // 开启缓存统计。比如命中次数、未命中次数等
22.         .recordStats()
23.         // 所有segment的初始总容量大小
24.         .initialCapacity(128)
25.         // 用于测试，可任意改变当前时间。参考：https://www.geek-share.com/detail/2689756248.html
26.         .ticker(new Ticker() {
27.             @Override
28.             public long read() {
29.                 return 0;
30.             }
31.         })
32.         .build(new CacheLoader<String, Optional<T>>() {
33.             @Override
34.             public Optional<T> load(String key) {
35.                 T cacheObject = getObjectFromDb(key);
36.                 log.debug("find the local guava cache of key: {}  is {}", key, cacheObject);
37.                 return Optional.ofNullable(cacheObject);
38.             }
39.         });
41.     public T get(String key) {
42.         try {
43.             if (StrUtil.isEmpty(key)) {
44.                 return null;
45.             }
46.             Optional<T> optional = guavaCache.get(key);
47.             return optional.orElse(null);
48.         } catch (ExecutionException e) {
49.             log.error("get cache object from guava cache failed.");
50.             e.printStackTrace();
51.             return null;
52.         }
53.     }
55.     public void invalidate(String key) {
56.         if (StrUtil.isEmpty(key)) {
57.             return;
58.         }
60.         guavaCache.invalidate(key);
61.     }
63.     public void invalidateAll() {
64.         guavaCache.invalidateAll();
65.     }
67.     /**
68.      * 从数据库加载数据
69.      * @param id
70.      * @return
71.      */
72.     public abstract T getObjectFromDb(Object id);
73. }

复制代码

我们将getObjectFromDb方法留给子类自己去实现。以下是例子：

1. /**
2. * @author valarchie
3. */
4. @Component
5. @Slf4j
6. @RequiredArgsConstructor
7. public class GuavaCacheService {
9.     @NonNull
10.     private ISysDeptService deptService;
12.     public final AbstractGuavaCacheTemplate<SysDeptEntity> deptCache = new AbstractGuavaCacheTemplate<SysDeptEntity>() {
13.         @Override
14.         public SysDeptEntity getObjectFromDb(Object id) {
15.             return deptService.getById(id.toString());
16.         }
17.     };
18. }

复制代码

Redis（三级缓存）

项目中会持续增长的数据比如用户、订单等相关数据。这些数据比较多，不适合放在内存级缓存当中，而应放在缓存中间件Redis当中去。Redis是支持持久化的，当我们的服务器重新启动时，依然可以从Redis中加载我们原先存储好的数据。
但是使用Redis缓存还有一个可以优化的点。我们可以自己本地再做一个局部的缓存来缓存Redis中的数据来减少网络IO请求，提高数据访问速度。 比如我们Redis缓存中有一万个用户的数据，但是一分钟之内可能只有不到1000个用户在请求数据。我们便可以在Redis中嵌入一个局部的Guava缓存来提供性能。以下是RedisCacheTemplate.
[code]/** * 缓存接口实现类 三级缓存 * @author valarchie */@Slf4jpublic class RedisCacheTemplate {    private final RedisUtil redisUtil;    private final CacheKeyEnum redisRedisEnum;    private final LoadingCache guavaCache;    public RedisCacheTemplate(RedisUtil redisUtil, CacheKeyEnum redisRedisEnum) {        this.redisUtil = redisUtil;        this.redisRedisEnum = redisRedisEnum;        this.guavaCache = CacheBuilder.newBuilder()            // 基于容量回收。缓存的最大数量。超过就取MAXIMUM_CAPACITY = 1