Spring缓存是如何实现的？如何扩展使其支持过期删除功能？ ...

前言：在我们的应用中，有一些数据是通过rpc获取的远端数据，该数据不会经常变化，允许客户端在本地缓存一定时间。
该场景逻辑简单，缓存数据较小，不需要持久化，所以不希望引入其他第三方缓存工具加重应用负担，非常适合使用Spring Cache来实现。
但有个问题是，我们希望将这些rpc结果数据缓存起来，并在一定时间后自动删除，以实现在一定时间后获取到最新数据。类似Redis的过期时间。
接下来是我的调研步骤和开发过程。
Spring Cache 是什么？

Spring Cache 是 Spring 的一个缓存抽象层，作用是在方法调用时自动缓存返回结果，以提高系统性能和响应速度。
目标是简化缓存的使用，提供一致的缓存访问方式，使开发人员能够轻松快速地将缓存添加到应用程序中。
应用于方法级别，在下次调用相同参数的方法时，直接从缓存中获取结果，而不必执行实际的方法体。
适用场景？

包括但不限于：

• 频繁访问的方法调用，可以通过缓存结果来提高性能
  
• 数据库查询结果，可以缓存查询结果以减少数据库访问
  
• 外部服务调用结果，可以缓存外部服务的响应结果以减少网络开销
  
• 计算结果，可以缓存计算结果以加快后续计算速度
  

优缺点

优点：

• 提高应用的性能，避免重复计算或查询。
  
• 减少对底层资源的访问，如数据库或远程服务，从而减轻负载。
  
• 简化代码，通过注解的方式实现缓存逻辑，而不需要手动编写缓存代码。
  

缺点：

• 需要占用一定的内存空间来存储缓存数据。
  
• 可能导致数据不一致问题，如果缓存的数据发生变化，但缓存没有及时更新，可能会导致脏数据的问题。（所以需要及时更新缓存）
  
• 可能引发缓存穿透问题，当大量请求同时访问一个不存在于缓存中的键时，会导致请求直接落到底层资源，增加负载。
  

重要组件

• CacheManager：缓存管理器，用于创建、配置和管理缓存对象。可以配置具体的缓存实现，如 Ehcache、Redis。
  
• Cache：缓存对象，用于存储缓存数据，提供了读取、写入和删除缓存数据的方法。
  
• 常用注解：
  
  
  
  • @Cacheable：被调用时，会检查缓存中是否已存在，若有，则直接返回缓存结果，否则执行方法并将结果存入缓存，适用于只读操作。
    
  • @CachePut：则每次都会执行方法体，并将结果存入缓存，即每次都会更新缓存中的数据，适用于写操作。
    
  • @CacheEvict：被调用时，Spring Cache 会清除对应的缓存数据。
    
  
  

使用方式

• 配置缓存管理器（CacheManager）：使用 @EnableCaching 注解启用缓存功能，并配置具体的缓存实现。
  
• 在方法上添加缓存注解：使用 @Cacheable、@CacheEvict、@CachePut 等注解标记需要被缓存的方法。
  
• 调用被缓存的方法：当调用被标记为缓存的方法时，Spring Cache 会检查缓存中是否已有该方法的缓存结果。
  
• 根据缓存结果返回数据：如果缓存中已有结果，则直接从缓存中返回；否则，执行方法并将结果存入缓存。
  
• 根据需要清除或更新缓存：使用 @CacheEvict、@CachePut 注解可以在方法调用后清除或更新缓存。
  通过以上步骤，Spring Cache 可以自动管理缓存的读写操作，从而简化缓存的使用和管理。
  

Spring Boot默认使用哪种实现，及其优缺点：

Spring Boot默认使用ConcurrentMapCacheManager作为缓存管理器的实现，适用于简单的、单机的、对缓存容量要求较小的应用场景。

• 优点：
  
  
  
  • 简单轻量：没有外部依赖，适用于简单的应用场景。
    
  • 内存存储：缓存数据存储在内存中的ConcurrentMap中，读写速度快，适用于快速访问和频繁更新的数据。
    
  • 多缓存实例支持：支持配置多个命名缓存实例，每个实例使用独立的ConcurrentMap存储数据，可以根据不同的需求配置多个缓存实例。
    
  
  
• 缺点：
  
  
  
  • 单机应用限制：ConcurrentMapCacheManager适用于单机应用，缓存数据存储在应用的内存中，无法实现分布式缓存。
    
  • 有限的容量：由于缓存数据存储在内存中，ConcurrentMapCacheManager的容量受限于应用的内存大小，对于大规模数据或高并发访问的场景可能存在容量不足的问题。
    
  • 缺乏持久化支持：ConcurrentMapCacheManager不支持将缓存数据持久化到磁盘或其他外部存储介质，应用重启后缓存数据会丢失。
    
  
  

如何让ConcurrentMapCacheManager支持过期自动删除

前言也提到了，我们的场景逻辑简单，缓存数据较小，不需要持久化，不希望引入其他第三方缓存工具加重应用负担，适合使用ConcurrentMapCacheManager。所以扩展下ConcurrentMapCacheManager也许是最简单的实现。
方案设计

为此，我设计了三种方案：

• 开启定时任务，扫描缓存，定时删除所有缓存；该方式简单粗暴，统一定时删除，但不能针对单条数据进行过期操作。
  
• 开启定时任务，扫描缓存，并将单条过期的缓存数据删除。
  
• 访问缓存数据之前，判断是否过期，若过期则重新执行方法体，并将结果覆盖原缓存数据。
  

上述2、3方案都更贴近目标，且都有一个共同的难点，即如何判断该缓存是否过期？或如何存放缓存的过期时间？
既然没有好办法，那就走一波源码找找思路吧！
源码解析

ConcurrentMapCacheManager 中定义了一个cacheMap(如下代码)，用于存储所有缓存名及对应缓存对象。

1. private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<>(16);

复制代码

cacheMap 中的存放的Cache的具体类型为ConcurrentMapCache，
而ConcurrentMapCache的内部定义了一个store(如下代码)，用于存储该缓存下所有key、value，即真正的缓存数据。

1. private final ConcurrentMap<Object, Object> store;

复制代码

其关系图为：

以下为测试代码，为一个查询增加缓存操作：cacheName=getUsersByName,key为参数name的值，value为查询用户集合。

1. @Service
2. public class UserServiceImpl implements UserService {
3.     @Autowired
4.     private UserMapper userMapper;
6.     @Override
7.     @Cacheable(value = "getUsersByName", key = "#name")
8.     public List<GyhUser> getUsersByName(String name) {
9.         return userMapper.getUsersByName(name);
10.     }
11. }

复制代码

当程序调用到此方法前，会自动进入缓存拦截器CacheInterceptor，进而进入ConcurrentMapCacheManager的getCache方法，获取对应的缓存实例，若不存在，则生成一个。

然后从缓存实例中查找缓存数据，找到则返回，找不到则执行目标方法。

执行完目标方法后，将返回结果放到缓存中。

实现自动过期删除

根据上面的代码跟踪可以发现，缓存数据key/value存放在具体的缓存实例ConcurrentMapCache的store中，且get和put前后，有我可以操作的空间。

• 那么，如果我将value重新包装一下，将缓存时间封装进去，并在get和put前后，将真正的缓存数据解析出来，供开发者使用，是否可以实现呢？说干就干！
  

1. /**
2. * 缓存数据包装类，保证缓存数据及插入时间
3. */
4. public class ExpireCacheWrap {
5.     /**
6.      * 缓存数据
7.      */
8.     private final Object value;
9.     /**
10.      * 插入时间
11.      */
12.     private final Long insertTime;
14.     public ExpireCacheWrap(Object value, Long insertTime) {
15.         this.value = value;
16.         this.insertTime = insertTime;
17.     }
19.     public Object getValue() {
20.         return value;
21.     }
23.     public Long getInsertTime() {
24.         return this.insertTime;
25.     }
26. }

复制代码

• 自定义一个Cache类，继承ConcurrentMapCache，扩展get、put方法，实现对缓存时间的记录和解析
  

1. /**
2. * 缓存过期删除
3. */
4. public class ExpireCache extends ConcurrentMapCache {
5.     public ExpireCache(String name) {
6.         super(name);
7.     }
9.     @Override
10.     public ValueWrapper get(Object key) {
11.         // 解析缓存对象时，拿到value，去掉插入时间。对于业务中缓存的使用逻辑无感知无侵入，无需调整相关代码
12.         ValueWrapper valueWrapper = super.get(key);
13.         if (valueWrapper == null) {
14.             return null;
15.         }
16.         Object storeValue = valueWrapper.get();
17.         storeValue = storeValue != null ? ((ExpireCacheWrap) storeValue).getValue() : null;
18.         return super.toValueWrapper(storeValue);
19.     }
21.     @Override
22.     public void put(Object key, @Nullable Object value) {
23.         // 插入缓存对象时，封装对象信息：缓存内容+插入时间
24.         value = new ExpireCacheWrap(value, System.currentTimeMillis());
25.         super.put(key, value);
26.     }
27. }

复制代码

• 自定义缓存管理器，将自定义的ExpireCache，替换默认的ConcurrentMapCache
  

1. /**
2. * 缓存管理器
3. */
4. public class ExpireCacheManager extends ConcurrentMapCacheManager {
5.     @Override
6.     protected Cache createConcurrentMapCache(String name) {
7.         return new ExpireCache(name);
8.     }
9. }

复制代码

• 将自定义的缓存管理器ExpireCacheManager注入到容器中
  

1. @Configuration
2. class ExpireCacheConfiguration {
3.     @Bean
4.     public ExpireCacheManager cacheManager() {
5.         ExpireCacheManager cacheManager = new ExpireCacheManager();
6.         return cacheManager;
7.     }
8. }

复制代码

• 开启定时任务，自动删除过期缓存
  

1. /**
2. * 定时执行删除过期缓存
3. */
4. @Component
5. @Slf4j
6. public class ExpireCacheEvictJob {
8.     @Autowired
9.     private ExpireCacheManager cacheManager;
10.     /**
11.      * 缓存名与缓存时间
12.      */
13.     private static Map<String, Long> cacheNameExpireMap;
14.     // 可以优化到配置文件或字典中
15.     static {
16.         cacheNameExpireMap = new HashMap<>(5);
17.         cacheNameExpireMap.put("getUserById", 180000L);
18.         cacheNameExpireMap.put("getUsersByName", 300000L);
19.     }
21.     /**
22.      * 5分钟执行一次
23.      */
24.     @Scheduled(fixedRate = 300000)
25.     public void cacheEvict() {
26.         Long now = System.currentTimeMillis();
27.         // 获取所有缓存
28.         Collection<String> cacheNames = cacheManager.getCacheNames();
29.         for (String cacheName : cacheNames) {
30.             // 该类缓存设置的过期时间
31.             Long expire = cacheNameExpireMap.get(cacheName);
32.             // 获取该缓存的缓存内容集合
33.             Cache cache = cacheManager.getCache(cacheName);
34.             ConcurrentMap<Object, Object> store = (ConcurrentMap) cache.getNativeCache();
35.             Set<Object> keySet = store.keySet();
36.             // 循环获取缓存键值对，根据value中存储的插入时间，判断key是否已过期，过期则删除
37.             keySet.stream().forEach(key -> {
38.                 // 缓存内容包装对象
39.                 ExpireCacheWrap value = (ExpireCacheWrap) store.get(key);
40.                 // 缓存内容插入时间
41.                 Long insertTime = value.getInsertTime();
42.                 if ((insertTime + expire) < now) {
43.                     cache.evict(key);
44.                     log.info("key={},insertTime={},expire={},过期删除", key, insertTime, expire);
45.                 }
46.             });
47.         }
49.     }
50. }

复制代码

通过以上操作，实现了让ConcurrentMapCacheManager支持过期自动删除，并且对开发者
基本无感知无侵入，只需要在配置文件中配置缓存时间即可。
但是如果我的项目已经支持了第三方缓存如Redis，秉着不用白不用的原则，又该如何将该功能嫁接到Redis上呢？
正正好我们的项目最近在引入R2m，就试着搞一下吧-。
未完待续~  Thanks~

作者：京东科技 郭艳红
来源：京东云开发者社区

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！