JetCache 缓存开源组件设计精要

作者：阿里技术

2023-04-11
浙江
本文字数：8189 字
阅读完需：约 27 分钟

作者：张隆阿里电影演出技术中心团队

本文将为大家介绍 JetCache 缓存开源组件的前世今生，并剖析了 JetCache 的工作原理及设计优势。

一、JetCache 的前世今生

1.1 诞生-阿里彩票 JetCache 的伊甸园

2013 年，JetCache 诞生于 [ 阿里彩票 ]，作者是 [ huangli ] 凭借得天独厚的 Tair 支持和丰富的 Spring 生态注解支持，赢得了大家的喜爱。
2015 年，随着 SpringBoot 的大热和集团内 PandoraBoot 的彻底铺开，JetCache 以 Starter 的形式实现了扩展，优化了配置项，在架构设计和性能上更上一层楼。
2015 年同年，JetCache 开源至 Github，作为 alibaba 的开源缓存框架，其易用性和设计先进性吸引了大批国内外用户，截止当前在 github 上累计 3.7k star，870 fork。
2018 年 JetCache 最大版本更新，对整体的设计进行了调整，修改了默认的序列化方式，集成支持了 SpringData，RedisLettuce，Redisson 等更加高效以及功能更加灵活且高级的三方 SDK。

1.2 整合-开源界大放异彩

JetCache 原生支持的远程缓存是 Tair，但是 Tair 在集团外并不可用。JetCache 为了拥抱开源，实现了时下主流的 GuavaCache, CaffeineCache, Redis，MemCache 基本覆盖了国内的主流缓存中间件。
在功能性方面，JetCache 满足了用户一行注解解决 Method 缓存的刚需，同时也能通过叠加注解的方式非常高效的处理缓存穿透，缓存击穿，缓存雪崩，缓存失效等经典分布式缓存的问题，这让用户充分体验到了缓存框架的效率优势和设计先进性。
在扩展性方面，JetCache 满足了用户一行注解解决 Method 缓存的刚需，也提供了优秀的扩展能力。想要实现一个新的 Cache 类型，只需要实现 AbstractEmbeddedCache 或者 AbstractExternalCache 就可以以非常低廉的成本实现一个新的缓存框架。

1.3 挑战-SpringCache 江湖地位

在 2015 年最火的框架是 SpringBoot，SpringBoot 提供了非常丰富的组件支持以及模块化的组件管理，其中就包括基于 JSR-107--JCacheAPI 实现的 SpringCache 框架。
SpringCache 框架很好的实现了 JCacheAPI，在当时占据了非常有力的位置，几乎所有的 SpringBoot 初创项目，都选择了使用 SpringCache 来作为他们的第一个缓存框架。但随着软件工程的规模越来越大，分布式场景的经典问题也接踵而至，显然 SpringCache 在应对分布式环境的经典问题时显得太过于稚嫩。
对于分布式场景，缓存穿透，缓存击穿，缓存雪崩等经典问题，缺少足够成熟的方案。
高级特性上，如分布式锁，多级缓存滑动窗口，缓存序列化，异步 API 支持等实际工作场景经常会需要用到的核心能力，要么没有，要么不够用。
对于扩展性上，设计的不够开放和正交，很难低成本的完成一些高级功能的扩展。
JetCache 在这方面做的就不错，并且在迁移缓存方面基本上可以做到换注解平替，所以一旦工程规模达到一定量级，很多架构师会选择从 SpringCache 的方式切换到 JetCache 上。

二、JetCache 是如何工作的

完整的组件串联文档：

https://app.heptabase.com/w/db02907915c401c6e33ddcc47e4d67a589047a846be16f30de1644501d939787

2.1 JSR-107--缓存 JCache 标准抽象实现

Java 在 2012 的 JSR-107 协议中新增了关于缓存的抽象设计标准--JCache。

2.2 丰富注解-无侵入抽象设计

2.3 启动器和配置-Bean 方式

@Configuration@EnableMethodCache(basePackages = "com.taobao.film.tfmind")@EnableCreateCacheAnnotationpublic class JetCacheConfig {    @Beanpublic GlobalCacheConfig config(  @Qualifier("ldbTairManager") TairManager tairLdbManager,  @Qualifier("mdbTairManager") TairManager tairMdbManager,  @Qualifier("rdb3CacheCompose") Rdb3CacheCompose rdb3CacheCompose) {  Map<String, CacheBuilder> localBuilders = new HashMap<>();  Map<String, CacheBuilder> remoteBuilders = new HashMap<>();  // 本地缓存 CaffeineCache  EmbeddedCacheBuilder<?> localBuilder = CaffeineCacheBuilder    .createCaffeineCacheBuilder()    .keyConvertor(FastjsonKeyConvertor.INSTANCE);  localBuilders.put(CacheConsts.DEFAULT_AREA, localBuilder);  // 远程缓存 LDB  TairCacheBuilder<?> ldbCacheBuilder = TairCacheBuilder.createTairCacheBuilder()    .keyConvertor(FastjsonKeyConvertor.INSTANCE)    .valueEncoder(KryoValueEncoder.INSTANCE)    .valueDecoder(KryoValueDecoder.INSTANCE)    .tairManager(tairLdbManager)    .namespace(SysConstants.NEW_TAIR_AREA)    .cacheNullValue(true);  remoteBuilders.put(CacheConsts.DEFAULT_AREA, ldbCacheBuilder);  // 远程缓存 MDB  TairCacheBuilder<?> ldbCacheBuilder = TairCacheBuilder.createTairCacheBuilder()    .keyConvertor(FastjsonKeyConvertor.INSTANCE)    .valueEncoder(KryoValueEncoder.INSTANCE)    .valueDecoder(KryoValueDecoder.INSTANCE)    .tairManager(tairLdbManager)    .namespace(SysConstants.NEW_TAIR_AREA)    .cacheNullValue(true);  remoteBuilders.put("MDB", mdbCacheBuilder);  // 远程缓存 RDB  TairRdb3CacheBuilder<?> rdb3CacheBuilder = TairRdb3CacheBuilder.createRedisCacheBuilder()    .keyConvertor(FastjsonKeyConvertor.INSTANCE)    .valueEncoder(KryoValueEncoder.INSTANCE)    .valueDecoder(KryoValueDecoder.INSTANCE)    .jedisPool(rdb3CacheCompose.getJedisPool())    .cacheNullValue(true);  remoteBuilders.put("RDB3", rdb3CacheBuilder);  // 构建全局缓存配置  GlobalCacheConfig globalCacheConfig = new GlobalCacheConfig();  globalCacheConfig.setConfigProvider(springConfigProvider());  globalCacheConfig.setLocalCacheBuilders(localBuilders);  globalCacheConfig.setRemoteCacheBuilders(remoteBuilders);  globalCacheConfig.setStatIntervalMinutes(5);  globalCacheConfig.setAreaInCacheName(false);  return globalCacheConfig;}}

复制代码

2.4 注解模式-AOP-缓存

基于 AOP 的方法级缓存，最常用最直观的 CacheAside 模式。

  public interface UserService {      @Cached(expire = 3600, cacheType = CacheType.REMOTE)      User getUserById(long userId);  }

复制代码

2.5 注解模式-Cache-API 缓存

基于 CacheAPI 的缓存形式，复杂场景下最灵活的模式。

  @CreateCache(expire = 3600, cacheType = CacheType.REMOTE)  private Cache<Long, UserDO> userCache;

复制代码

2.6 高级 API 模式-手动创建 CacheAPI

  @Autowired  private CacheManager cacheManager;  private Cache<String, UserDO> userCache;    public UserDO getTestCacheValue() {    if(userCache == null) {      QuickConfig qc = QuickConfig.newBuilder("userCache")          .expire(Duration.ofSeconds(100))          .cacheType(CacheType.BOTH)          .syncLocal(true) // invalidate local cache in all jvm process after update          .build();      userCache = cacheManager.getOrCreateCache(qc);    }    return userCache.get("TestCacheKey")  }

复制代码

2.7 Cache 基础缓存操作

  // 数据存储  void put(K key, V value); // 数据录入  void putAll(Map<? extends K,? extends V> map); // 批量数据录入  boolean putIfAbsent(K key, V value); // 卫语句的数据存储    // 数据读取  V get(K key); // 数据读取  Map<K,V> getAll(Set<? extends K> keys); // 批量数据读取    // 数据删除  void remove(K key);  void removeAll(Set<? extends K> keys);    // 异步高级缓存API  V computeIfAbsent(K key, Function<K, V> loader);  V computeIfAbsent(K key, Function<K, V> loader, boolean cacheNullWhenLoaderReturnNull);  V computeIfAbsent(K key, Function<K, V> loader, boolean cacheNullWhenLoaderReturnNull, long expire, TimeUnit timeUnit);    // 分布式锁  AutoReleaseLock tryLock(K key, long expire, TimeUnit timeUnit);  boolean tryLockAndRun(K key, long expire, TimeUnit timeUnit, Runnable action);    // 原始缓存API （一般不用）  CacheGetResult<V> GET(K key);  MultiGetResult<K, V> GET_ALL(Set<? extends K> keys);  CacheResult PUT(K key, V value);  CacheResult PUT(K key, V value, long expireAfterWrite, TimeUnit timeUnit);  CacheResult PUT_ALL(Map<? extends K, ? extends V> map);  CacheResult PUT_ALL(Map<? extends K, ? extends V> map, long expireAfterWrite, TimeUnit timeUnit);  CacheResult REMOVE(K key);  CacheResult REMOVE_ALL(Set<? extends K> keys);  CacheResult PUT_IF_ABSENT(K key, V value, long expireAfterWrite, TimeUnit timeUnit);

复制代码

2.8 分布式-缓存穿透

分布式场景下的热点数据通常都保存在缓存当中，以减少数据库的压力，提升服务的性能。
缓存击穿是指，攻击者利用随机访问的方式短时间大量的访问不存在的数据，由于数据不存在，所以缓存中查不到，请求越过缓存层直达数据库，造成数据库的压力激增。
通常的解法有：[空值缓存] 及 [布隆过滤器]
JetCache 使用了较为轻量级的 [空值缓存] 方式，来解决这个问题。

@Cached(cacheNullValue=true)、@CreateCache(cacheNullValue=true)

// AbstractCache.classstatic <K, V> V computeIfAbsentImpl(K key, Function<K, V> loader, boolean cacheNullWhenLoaderReturnNull,                                               long expireAfterWrite, TimeUnit timeUnit, Cache<K, V> cache) {  .......    Consumer<V> cacheUpdater = (loadedValue) -> {    if(needUpdate(loadedValue, cacheNullWhenLoaderReturnNull, newLoader)) {        if (timeUnit != null) {          cache.PUT(key, loadedValue, expireAfterWrite, timeUnit).waitForResult();        } else {          cache.PUT(key, loadedValue).waitForResult();        }     }  };  ......  }

复制代码

2.9 分布式-缓存击穿

CacheAside 模式的缓存由于本身有淘汰策略，在数据失效后，缓存组件会直接访问数据库尝试重建缓存。
在大规模分布式热点的情况下，一旦热点数据失效，会有大量的请求同时尝试重建缓存，这不但会导致资源浪费，更加危险的是会造成数据库瞬时极大的压力。
JetCache 通过注解@CachePenetrationProtect实现了 JVM 内存锁级的击穿保护，使并发重建的请求限制到可控范围。( 如果数据利用率高还可以使用@CacheRefresh的方式来实现基于分布式锁的缓存重建能力 )

// AbstractCache.classstatic <K, V> V computeIfAbsentImpl(K key, Function<K, V> loader, boolean cacheNullWhenLoaderReturnNull,                                               long expireAfterWrite, TimeUnit timeUnit, Cache<K, V> cache) {  ....    if (cache.config().isCachePenetrationProtect()) {      loadedValue = synchronizedLoad(cache.config(), abstractCache, key, newLoader, cacheUpdater);    } else {      loadedValue = newLoader.apply(key);      cacheUpdater.accept(loadedValue);    }  ....}

复制代码

2.10 分布式-缓存雪崩

缓存雪崩与缓存击穿类似，但是情况更为危机后果更为严重，有可能导致整个集群服务瘫痪。
当大量热点缓存同时失效的时候，大量的缓存重建请求会直达数据库，造成服务节点瘫痪形成服务雪崩。
缓存雪崩的处理方式较为复杂，但简单来说：
可以建立多级缓存，通过设置不同的过期时间，形成重叠数据滑动窗口。
通过服务主动维护异步任务的形式，维护一块永固缓存，防止热点失效。
JetCache 可以通过多级缓存来避免这种情况。
JetCache 还提供了@CacheRefresh和CacheLoader的方式，使服务有能力创建内建的时间块任务，来达到维护分布式环境下永固缓存的目的。

// RefreshCache.classpublic void run() {  try {    if (config.getRefreshPolicy() == null || (loader == null && !hasLoader())) {      cancel();      return;    }    long now = System.currentTimeMillis();    long stopRefreshAfterLastAccessMillis = config.getRefreshPolicy().getStopRefreshAfterLastAccessMillis();    if (stopRefreshAfterLastAccessMillis > 0) {      if (lastAccessTime + stopRefreshAfterLastAccessMillis < now) {        logger.debug("cancel refresh: {}", key);        cancel();        return;      }    }    logger.debug("refresh key: {}", key);    Cache concreteCache = concreteCache();    if (concreteCache instanceof AbstractExternalCache) {      externalLoad(concreteCache, now);    } else {      load();    }  } catch (Throwable e) {    logger.error("refresh error: key=" + key, e);  }}

复制代码

2.11 分布式-缓存失效/更新

缓存数据也需要维护，尤其是缓存和实际数据不一致的情况下。
例如用户数据，就非常需要缓存失效和缓存更新的能力，及时的在用户做了数据操作之后更新公共缓存的数据。
JetCache 通过@CacheInvalid和@CacheUpdate提供了这种能力，极大程度的避免了缓存数据不一致的情况，同时也增强了缓存操作的灵活性。

public interface UserService {    @Cached(name="userCache.", key="#userId", expire = 3600)    User getUserById(long userId);    @CacheUpdate(name="userCache.", key="#user.userId", value="#user")    void updateUser(User user);    @CacheInvalidate(name="userCache.", key="#userId")    void deleteUser(long userId);}

复制代码

三、JetCache 框架设计剖析优势有哪些？

3.1 支持多种 KV 序列化方式

CacheKey Convertor ：用来进行缓存 Key 的加工处理
环境隔离： CacheKey 在影演使用最广泛方式，抽象实现环境前缀 Convertor 就可以当前环境进行缓存前缀的拼接，从而达到数据隔离的目的。
长短缓存： 长短缓存通常使用对象缓存作为 Key，为了容灾短缓存和长缓存通常使用了不同的缓存 Key。通过实现长短缓存 Convertor 可以实现相同对象，可以控制长、短缓存的 Key 使用对象中的不同属性构造，从而达到短缓存提升性能，长缓存降级的目的。
ValueEncode、ValueDecode：用来提升缓存性能的绝佳方式
高性能序列化：选择 JavaSerialize、kyro、Kyro5 的序列化方式可以极大程度的提升我们系统对性能的要求，很适合应对高并发环境的大流量压力。
兼容性序列化：选择 JSON（FastJson、FastJson2、Jackson）的方式，可以为缓存提供良好的兼容性。在架构设计的初期，完全可以采用这种方式来实现平稳迭代。
加密序列化：当我们使用外部数据库的时候，我们可以自己实现 ValueEncode 和 ValueDecode 来保障我们数据的安全。

3.2 支持多种本地，远程缓存

3.3 多级缓存-乐高积木

长短缓存：通过多级缓存加上 KeyConvertor 可以快速构建成本最低效率最高的长短缓存组件。
用户缓存：互动用户数据很多，配合用户路由，可以结合 LocalCache + LDB 的方式既保证数据的可靠性，又能将性能从 10ms -> 1ms 级。
自定义多级“缓存”：由于 JetCache 缓存的实现相当方便，我们甚至可以实现 Mysql，Opensearch 的 Cache 实现，并且把它组转到多级缓存之中，形成一种结构稳固的数据读写组件。

3.4 高级特性-加载器

// AOP 缓存 Example@Cached(expireTime= 5 * 60)public Long loadOrderSumFromDatabase(String orderType);

复制代码

@CreateCache(expireTime= 5 * 60)private Cache<String, Order> orderSumCache;// 每分钟拉取订单总数，形成持久缓存@PostConstructpublic void init(){  RefreshPolicy policy = RefreshPolicy.newPolicy(1, TimeUnit.MINUTES)    .stopRefreshAfterLastAccess(30, TimeUnit.MINUTES);  orderSumCache.config().setLoader(this::loadOrderSumFromDatabase);  orderSumCache.config().setRefreshPolicy(policy);}

复制代码

3.5 高级特性-监听器

官方实现-数据报告

// 数据报告Monitor的代码实现public class DefaultCacheMonitor implements CacheMonitor {    public synchronized void afterOperation(CacheEvent event) {        if (event instanceof CacheGetEvent) {            CacheGetEvent e = (CacheGetEvent) event;            afterGet(e.getMillis(), e.getKey(), e.getResult());        } else if (event instanceof CachePutEvent) {            CachePutEvent e = (CachePutEvent) event;            afterPut(e.getMillis(), e.getKey(), e.getValue(), e.getResult());        } else if (event instanceof CacheRemoveEvent) {            CacheRemoveEvent e = (CacheRemoveEvent) event;            afterRemove(e.getMillis(), e.getKey(), e.getResult());        } else if (event instanceof CacheLoadEvent) {            CacheLoadEvent e = (CacheLoadEvent) event;            afterLoad(e.getMillis(), e.getKey(), e.getLoadedValue(), e.isSuccess());        } else if (event instanceof CacheGetAllEvent) {            CacheGetAllEvent e = (CacheGetAllEvent) event;            afterGetAll(e.getMillis(), e.getKeys(), e.getResult());        } else if (event instanceof CacheLoadAllEvent) {            CacheLoadAllEvent e = (CacheLoadAllEvent) event;            afterLoadAll(e.getMillis(), e.getKeys(), e.getLoadedValue(), e.isSuccess());        } else if (event instanceof CachePutAllEvent) {            CachePutAllEvent e = (CachePutAllEvent) event;            afterPutAll(e.getMillis(), e.getMap(), e.getResult());        } else if (event instanceof CacheRemoveAllEvent) {            CacheRemoveAllEvent e = (CacheRemoveAllEvent) event;            afterRemoveAll(e.getMillis(), e.getKeys(), e.getResult());        }    }}

复制代码

// 数据报告Monitor 的注册public void addMonitors(CacheManager cacheManager, Cache cache, QuickConfig quickConfig) {    if (metricsManager == null) {        return;    }    DefaultCacheMonitor monitor = new DefaultCacheMonitor(quickConfig.getName());    cache.config().getMonitors().add(monitor);}

复制代码

效果：