两级缓存 Caffeine + Redis 架构：原理、实现与实践

一、前言

在高性能服务架构设计里，缓存是关键环节。常规做法是将热点数据存于 Redis/MemCache 等远程缓存，缓存未命中时再查数据库，以此提升访问速度、降低数据库压力 。

随着发展，架构有了改进，部分场景下单纯远程缓存不够，需结合本地缓存（如 Guava cache、Caffeine ），形成本地缓存（一级缓存） + 远程缓存（二级缓存）的两级缓存架构，进一步提升程序响应与服务性能，其基础访问流程如下（暂不考虑并发等复杂问题）：

[此处插入原流程图片，替换路径为合理展示形式，如保留./assets/2.jpeg，若为线上展示需处理为可访问链接]

二、优点与待解决问题

（一）优势

相比单纯远程缓存，两级缓存有以下优势：

• 访问速度快：本地缓存基于内存，对变更 / 实时性要求低的数据，存入本地可大幅提升访问速度。
• 减少网络开销：降低与远程缓存的数据交互，减少网络 I/O 耗时，节省网络通信成本。

（二）需解决问题

设计时要考虑诸多问题，核心是数据一致性：

• 两级缓存与数据库需同步，数据修改时，本地、远程缓存应同步更新。
• 分布式环境下，一级缓存节点间存在一致性问题。一个节点修改本地缓存后，需通知其他节点刷新，否则会读过期数据，可借 Redis 发布 / 订阅功能解决。

此外，缓存过期时间、策略及多线程访问等问题也需关注，本文先聚焦两级缓存的代码实现。

三、准备工作

（一）技术选型

整合Caffeine（最强本地缓存） 为一级缓存、Redis（性能优） 为二级缓存，搭建 SpringBoot 项目，引入依赖：

<dependency><groupId>com.github.ben-manes.caffeine</groupId><artifactId>caffeine</artifactId><version>2.9.2</version>
</dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId><version>2.8.1</version>
</dependency>

（二）Redis 配置

配置RedisTemplate ，处理连接工厂、序列化等：

/*** Redis缓存配置类* @author ZhuZiKai* @date 2022/3/31 0014*/
@Configuration
@EnableCaching
@EnableAspectJAutoProxy 
public class RedisConfig extends CachingConfigurerSupport {@Beanpublic FastJsonRedisSerializer fastJson2JsonRedisSerializer() {return new FastJsonRedisSerializer(Object.class);}@Beanpublic StringRedisSerializer StringRedisSerializer() {return new StringRedisSerializer();}@Bean("redis")@Primarypublic RedisTemplate initRedisTemplate(RedisConnectionFactory redisConnectionFactory,StringRedisSerializer stringRedisSerializer,FastJsonRedisSerializer fastJson2JsonRedisSerializer) throws Exception {RedisTemplate redisTemplate = new RedisTemplate();redisTemplate.setConnectionFactory(redisConnectionFactory);redisTemplate.setKeySerializer(stringRedisSerializer);redisTemplate.setValueSerializer(stringRedisSerializer);redisTemplate.setHashKeySerializer(stringRedisSerializer);redisTemplate.setHashValueSerializer(fastJson2JsonRedisSerializer);redisTemplate.setDefaultSerializer(stringRedisSerializer);redisTemplate.afterPropertiesSet();return redisTemplate;}
}

四、代码实战：两级缓存管理实现

（一）V1.0 版本：Spring 缓存注解方案

Spring 提供CacheManager 接口与注解（@Cacheable/@CachePut/@CacheEvict ），简化缓存操作。

1. 注解说明

• @Cacheable：按 key 查缓存，命中则直接返回；未命中则执行方法，结果入缓存。
• @CachePut：无论缓存是否存在，执行方法并强制更新缓存。
• @CacheEvict：执行方法后，移除对应缓存数据。

2. 配置CacheManager

@Configuration
public class CacheManagerConfig {@Beanpublic CacheManager cacheManager(){CaffeineCacheManager cacheManager=new CaffeineCacheManager();cacheManager.setCaffeine(Caffeine.newBuilder().initialCapacity(128).maximumSize(1024).expireAfterWrite(60, TimeUnit.SECONDS));return cacheManager;}
}

启动类添加@EnableCaching ，开启缓存支持。

3. Service 层改造

• 查询方法：用@Cacheable ，保留业务与 Redis 操作逻辑，Caffeine 缓存交 Spring 管理：

@Cacheable(value = "order",key = "#id")
public Order getOrderById(Long id) {String key= CacheConstant.ORDER + id;// 查RedisObject obj = redisTemplate.opsForValue().get(key);if (Objects.nonNull(obj)){log.info("get data from redis");return (Order) obj;}// Redis无则查DBlog.info("get data from database");Order myOrder = orderMapper.selectOne(new LambdaQueryWrapper<Order>().eq(Order::getId, id));// 结果入RedisredisTemplate.opsForValue().set(key,myOrder,120, TimeUnit.SECONDS);return myOrder;
}

• 更新方法：用@CachePut ，移除手动更新 Caffeine 操作（由 Spring 管理）：

@CachePut(cacheNames = "order",key = "#order.id")
public Order updateOrder(Order order) {log.info("update order data");orderMapper.updateById(order);// 更新RedisredisTemplate.opsForValue().set(CacheConstant.ORDER + order.getId(),order, 120, TimeUnit.SECONDS);return order;
}

注意：方法需定义返回值，否则可能缓存空对象，影响后续查询。

• 删除方法：用@CacheEvict ，仅处理 Redis 缓存删除：

@CacheEvict(cacheNames = "order",key = "#id")
public void deleteOrder(Long id) {log.info("delete order");orderMapper.deleteById(id);redisTemplate.delete(CacheConstant.ORDER + id);
}

此方案将本地缓存交 Spring 管理，Redis 缓存手动操作，降低业务入侵性。

（二）V2.0 版本：自定义注解 + 切面方案

进一步解耦，通过自定义注解与切面，实现对业务无入侵的缓存管理。

1. 自定义注解

定义@DoubleCache ，支持缓存存取、删除，适配 SpringEL 表达式：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DoubleCache {String cacheName();String key(); // 支持SpringELlong l2TimeOut() default 120;CacheType type() default CacheType.FULL;
}// 缓存操作类型枚举
public enum CacheType {FULL,   // 存取PUT,    // 只存DELETE  // 删除
}

2. SpringEL 表达式解析

解析注解中key 的表达式，适配方法参数：

public static String parse(String elString, TreeMap<String,Object> map){elString=String.format("#{%s}",elString);ExpressionParser parser = new SpelExpressionParser();EvaluationContext context = new StandardEvaluationContext();map.entrySet().forEach(entry->context.setVariable(entry.getKey(),entry.getValue()));Expression expression = parser.parseExpression(elString, new TemplateParserContext());return expression.getValue(context, String.class);
}

3. 配置 Caffeine 缓存

@Configuration
public class CaffeineConfig {@Beanpublic Cache<String,Object> caffeineCache(){return Caffeine.newBuilder().initialCapacity(128)// 初始容量.maximumSize(1024)// 最大容量.expireAfterWrite(60, TimeUnit.SECONDS)// 过期时间.build();}
}

4. 切面实现缓存逻辑

通过切面拦截@DoubleCache 注解，统一处理缓存读写、删除：

@Slf4j 
@Component 
@Aspect 
@AllArgsConstructor
public class CacheAspect {private final Cache<String,Object> cache;private final RedisTemplate redisTemplate;@Pointcut("@annotation(com.cn.dc.annotation.DoubleCache)")public void cacheAspect() {}@Around("cacheAspect()")public Object doAround(ProceedingJoinPoint point) throws Throwable {MethodSignature signature = (MethodSignature) point.getSignature();Method method = signature.getMethod();// 解析方法参数，封装SpringEL上下文String[] paramNames = signature.getParameterNames();Object[] args = point.getArgs();TreeMap<String, Object> treeMap = new TreeMap<>();for (int i = 0; i < paramNames.length; i++) {treeMap.put(paramNames[i],args[i]);}DoubleCache annotation = method.getAnnotation(DoubleCache.class);String elResult = ElParser.parse(annotation.key(), treeMap);String realKey = annotation.cacheName() + CacheConstant.COLON + elResult;// 按操作类型处理if (annotation.type()== CacheType.PUT){Object object = point.proceed();redisTemplate.opsForValue().set(realKey, object,annotation.l2TimeOut(), TimeUnit.SECONDS);cache.put(realKey, object);return object;} else if (annotation.type()== CacheType.DELETE){redisTemplate.delete(realKey);cache.invalidate(realKey);return point.proceed();}// 读写流程：先查CaffeineObject caffeineCache = cache.getIfPresent(realKey);if (Objects.nonNull(caffeineCache)) {log.info("get data from caffeine");return caffeineCache;}// 再查RedisObject redisCache = redisTemplate.opsForValue().get(realKey);if (Objects.nonNull(redisCache)) {log.info("get data from redis");cache.put(realKey, redisCache);return redisCache;}// 都无则查数据库，结果入缓存log.info("get data from database");Object object = point.proceed();if (Objects.nonNull(object)){redisTemplate.opsForValue().set(realKey, object,annotation.l2TimeOut(), TimeUnit.SECONDS);cache.put(realKey, object);        }return object;}
}

5. Service 层简化

只需添加自定义注解，专注业务逻辑：

@DoubleCache(cacheName = "order", key = "#id",type = CacheType.FULL)
public Order getOrderById(Long id) {return orderMapper.selectOne(new LambdaQueryWrapper<Order>().eq(Order::getId, id));
}@DoubleCache(cacheName = "order",key = "#order.id",type = CacheType.PUT)
public Order updateOrder(Order order) {orderMapper.updateById(order);return order;
}@DoubleCache(cacheName = "order",key = "#id",type = CacheType.DELETE)
public void deleteOrder(Long id) {orderMapper.deleteById(id);
}

五、总结与思考

本文按业务入侵程度，介绍两种两级缓存实现：

• V1.0：借 Spring 缓存注解，半入侵式管理，本地缓存交 Spring，Redis 手动操作。
• V2.0：自定义注解 + 切面，完全解耦缓存逻辑，业务代码更简洁。

实际项目中，是否用两级缓存需结合业务。若 Redis 满足需求，无需强制引入，因实际使用涉及并发、事务回滚、缓存策略适配等复杂问题。需权衡数据特性（如哪些适合一级 / 二级缓存）、一致性保障成本，再决定架构方案，让缓存真正成为服务性能的 “助推器” 而非 “负担” 。