从零搭建电商缓存系统:Canal+Redis+Caffeine三剑客实战
从零构建电商缓存架构:Canal、Redis与Caffeine的协同作战
在电商系统的日常运营中,商铺信息的查询频率极高,每一次商品浏览、店铺主页访问都伴随着对后端数据库的密集请求。当流量洪峰来临时,单纯依赖数据库的架构往往不堪重负,响应延迟飙升,用户体验急剧下降。此时,引入缓存层成为缓解数据库压力、提升系统吞吐量的不二法门。然而,缓存的世界并非一片坦途,单层缓存容易引发雪崩、击穿等问题,而引入多级缓存后,数据一致性又成了新的挑战。如何让本地缓存与分布式缓存协同工作,并确保它们与源头数据库的数据保持同步,是每一位追求高性能与高可用的架构师必须直面的课题。
今天,我们将深入探讨一个在实战中经过检验的解决方案:利用 Canal 监听数据库变更,驱动 Redis 与 Caffeine 组成的二级缓存体系,实现数据的准实时同步。这套组合拳不仅能显著提升读取性能,更能优雅地解决多级缓存间的数据一致性问题。无论你是正在为现有系统寻找缓存优化方案,还是准备从零搭建一个高可用的新平台,这篇文章都将为你提供一条清晰的路径和可落地的实践细节。
1. 架构蓝图:为何选择Canal+Redis+Caffeine?
在深入代码之前,我们有必要厘清这套架构的核心价值与设计思想。一个优秀的缓存系统,绝不仅仅是技术的堆砌,而是对业务场景、数据特性和运维成本的综合考量。
1.1 多级缓存的必要性
想象一下一个典型的电商商铺信息查询场景:用户进入某个店铺首页。如果每次请求都直接查询数据库,在千万级日活的平台上,数据库连接池很快会被耗尽。引入 Redis 作为第一道防线,将热点数据存储在内存中,能抵挡住绝大部分的读请求。但 Redis 本身是网络服务,每一次 GET 操作都伴随着网络 I/O 的开销,在极端高并发下,这仍可能成为瓶颈。
此时,Caffeine 这类本地缓存的价值就凸显出来了。作为 JVM 进程内的缓存,它的访问速度是纳秒级的,几乎可以忽略不计。将最最热点的数据(例如,平台头部 Top 100 的商铺信息)存放在 Caffeine 中,可以让核心业务的响应速度达到极致。这就构成了经典的 L1(本地缓存) + L2(分布式缓存) 二级缓存架构。
然而,引入本地缓存后,一个棘手的问题随之而来:数据一致性。当后台管理员修改了某个商铺的信息后,数据库更新了,Redis 可以通过缓存失效策略(如设置TTL)或主动更新来同步,但分布在数十上百个应用服务器实例中的 Caffeine 缓存,如何能感知到这次变更呢?这就是我们引入 Canal 的根本原因。
1.2 Canal:基于数据库日志的增量订阅与消费
Canal 是阿里巴巴开源的一个基于 MySQL 数据库增量日志解析的数据同步工具。它的工作原理是伪装成 MySQL 的从库(Slave),向主库(Master)发送 dump 请求。主库接收到请求后,会将自己的二进制日志(binlog)推送给 Canal。Canal 解析这些 binlog,将其转化为结构化的变更事件(INSERT, UPDATE, DELETE),并发送给下游的订阅者。
提示:Canal 的名字来源于“管道”,寓意着数据像水流一样,从数据库源头通过这条管道,实时地流向需要它的各个目的地。
相较于传统的“双写”(在业务代码中同时更新数据库和缓存)或“失效”(更新数据库后删除缓存)方案,Canal 方案具有显著优势:
- 对业务代码零侵入:数据同步逻辑与业务逻辑完全解耦。业务代码只需关心数据库的 CRUD,缓存同步由独立的 Canal 客户端服务负责。
- 保证最终一致性:基于 binlog 的同步是可靠且有序的,只要数据库变更成功,最终缓存就会被同步,避免了在复杂事务中手动维护缓存状态可能导致的错误。
- 支持多订阅方:一份数据库变更日志,可以同时驱动缓存更新、刷新搜索引擎索引、同步到数据仓库等多个下游系统。
下表清晰地对比了不同缓存同步策略的优劣:
| 同步策略 | 原理 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| 缓存失效 (Cache-Aside) | 更新DB后,删除缓存;下次查询时回源DB并重新加载。 | 实现简单,缓存命中率尚可。 | 存在缓存击穿、短暂不一致窗口。 | 读多写少,对一致性要求不极端的场景。 |
| 双写 (Write-Through) | 更新DB的同时,同步更新缓存。 | 强一致性(如果事务成功)。 | 业务耦合度高,写入链路变长、变脆弱。 | 写多读也多,且要求强一致性的场景。 |
| 基于消息队列 | 更新DB后,发送MQ消息,消费者异步更新缓存。 | 解耦,异步化提升性能。 | 系统复杂度增加,需维护MQ。 | 大型分布式系统,有多个异构数据源需要同步。 |
| 基于Canal (本方案) | 监听DB binlog,解析后异步更新缓存。 | 完全解耦,对业务无侵入,可靠性高。 | 架构复杂度最高,需部署和维护Canal服务。 | 对一致性、性能和系统解耦有高要求的场景,如电商核心数据。 |
我们的选择正是基于最后一点:在电商核心的商铺信息这类对一致性和性能都有高要求的数据上,采用 Canal 驱动的二级缓存同步,是当前最优雅和可靠的方案之一。
2. 环境搭建:MySQL与Canal的配置实战
理论清晰后,我们开始动手搭建环境。整个过程分为两大步:配置 MySQL 以提供 binlog,以及配置 Canal 服务来消费它。
2.1 MySQL 配置:开启二进制日志
Canal 工作的前提是 MySQL 必须开启二进制日志(binlog),并且格式必须设置为 ROW。ROW 模式会记录每一行数据修改的细节,这对于我们精确同步缓存至关重要。
首先,找到你的 MySQL 配置文件。对于 Linux 系统,通常在 /etc/mysql/my.cnf 或 /etc/my.cnf;对于 Windows,则是 my.ini。如果你不确定位置,可以通过 MySQL 客户端命令查找:
-- 连接到MySQL后执行
SHOW VARIABLES LIKE 'datadir';
这个命令会显示数据目录,配置文件通常就在该目录的上一级或同级目录中。
找到配置文件后,在 [mysqld] 区块下添加或修改以下配置:
[mysqld]
# 启用二进制日志,并指定基础文件名
log-bin=mysql-bin
# 设置binlog格式为ROW,这是Canal必需的
binlog-format=ROW
# 为MySQL实例设置一个唯一的服务器ID,对于单机,设为1即可
server-id=1
# 可选:指定binlog的过期时间,避免磁盘被占满
expire_logs_days=7
保存并重启 MySQL 服务使配置生效。之后,你可以通过以下命令验证 binlog 是否已正确开启:
SHOW VARIABLES LIKE 'log_bin';
SHOW VARIABLES LIKE 'binlog_format';
如果 log_bin 的值为 ON,binlog_format 的值为 ROW,则配置成功。
2.2 创建Canal专属数据库用户
Canal 需要以一个具有特定权限的 MySQL 用户身份连接主库,模拟从库拉取 binlog。我们创建一个名为 canal 的用户。
-- 如果已存在,先删除(谨慎操作)
DROP USER IF EXISTS 'canal'@'%';
-- 创建用户,密码设为 'canal_password',请在生产环境中使用强密码
CREATE USER 'canal'@'%' IDENTIFIED BY 'canal_password';
-- 授予必要的权限
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%';
-- 刷新权限
FLUSH PRIVILEGES;
这里授予的 REPLICATION SLAVE 和 REPLICATION CLIENT 权限是进行主从复制所必需的,SELECT 权限用于获取表结构等元信息。
注意:MySQL 8.0 默认使用了
caching_sha2_password身份验证插件,一些较老的客户端(包括某些版本的 Canal 连接器)可能不支持。如果遇到认证失败,可以将用户密码插件改回mysql_native_password:ALTER USER 'canal'@'%' IDENTIFIED WITH mysql_native_password BY 'canal_password';
2.3 Canal 服务部署与配置
从 Canal 的 GitHub Releases 页面下载部署包(如 canal.deployer-1.1.5.tar.gz)。解压后,其目录结构如下:
canal.deployer-1.1.5/
├── bin/
│ ├── startup.sh # Linux启动脚本
│ └── startup.bat # Windows启动脚本
├── conf/
│ ├── canal.properties # Canal服务全局配置
│ └── example/ # 一个实例配置目录
│ └── instance.properties # 连接MySQL的实例配置
└── logs/
我们需要重点关注 conf/example/instance.properties 文件:
# 配置MySQL主库地址
canal.instance.master.address=127.0.0.1:3306
# 配置上一步创建的canal用户及密码
canal.instance.dbUsername=canal
canal.instance.dbPassword=canal_password
# 字符集
canal.instance.connectionCharset=UTF-8
# 需要监听的表,可以使用正则表达式。这里监听所有库的所有表
canal.instance.filter.regex=.*\\..*
# 可选:指定黑名单,忽略某些表的同步
# canal.instance.filter.black.regex=
配置完成后,进入 bin 目录,执行启动脚本。Linux 下使用 ./startup.sh,Windows 下双击 startup.bat。查看 logs/example/example.log 日志文件,如果看到类似 “start successful....” 的日志,说明 Canal 服务已成功启动并连接到了 MySQL。
3. 应用集成:Spring Boot中的缓存与监听
服务端就绪后,我们开始在 Spring Boot 应用中集成 Caffeine 本地缓存,并编写 Canal 客户端来监听数据变更。
3.1 构建二级缓存:Redis + Caffeine
首先,在 pom.xml 中引入必要的依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
</dependency>
<dependency>
<groupId>top.javatool</groupId>
<artifactId>canal-spring-boot-starter</artifactId>
<version>1.2.1-RELEASE</version>
</dependency>
接下来,配置 Caffeine 缓存。我们可以创建一个配置类来定义缓存管理器,这里我们直接定义一个 Caffeine 缓存 Bean 供后续注入使用。
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;
@Configuration
public class CacheConfig {
@Bean(name = "shopCache")
public Cache<String, Object> shopCache() {
return Caffeine.newBuilder()
// 初始容量
.initialCapacity(100)
// 最大容量,超过后会基于Window TinyLFU算法进行淘汰
.maximumSize(1000)
// 写入后过期时间
.expireAfterWrite(10, TimeUnit.MINUTES)
// 记录缓存命中率等统计信息
.recordStats()
.build();
}
}
在商铺查询服务中,我们实现二级缓存的查询逻辑。先查 Caffeine,再查 Redis,最后回源数据库。
@Service
@Slf4j
public class ShopServiceImpl implements IShopService {
@Autowired
private StringRedisTemplate redisTemplate;
@Resource
private Cache<String, Object> shopCache; // 注入Caffeine缓存
@Autowired
private ShopMapper shopMapper;
private static final ObjectMapper MAPPER = new ObjectMapper();
private static final String CACHE_SHOP_KEY = "cache:shop:";
@Override
public Shop queryById(Long id) {
String key = CACHE_SHOP_KEY + id;
// 1. 查询Caffeine本地缓存
Shop shop = (Shop) shopCache.getIfPresent(key);
if (shop != null) {
log.info("命中Caffeine本地缓存,店铺ID: {}", id);
return shop;
}
// 2. 查询Redis分布式缓存
String shopJson = redisTemplate.opsForValue().get(key);
if (StrUtil.isNotBlank(shopJson)) {
try {
shop = MAPPER.readValue(shopJson, Shop.class);
// 将数据加载到Caffeine中
shopCache.put(key, shop);
log.info("命中Redis缓存,并回种Caffeine,店铺ID: {}", id);
return shop;
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
// 3. 查询数据库
shop = shopMapper.selectById(id);
if (shop == null) {
// 缓存空值,防止缓存穿透
redisTemplate.opsForValue().set(key, "", 2, TimeUnit.MINUTES);
return null;
}
// 4. 写入Redis和Caffeine
try {
String json = MAPPER.writeValueAsString(shop);
redisTemplate.opsForValue().set(key, json, 30, TimeUnit.MINUTES); // 设置Redis过期时间
shopCache.put(key, shop);
} catch (JsonProcessingException e) {
log.error("序列化商铺信息失败", e);
}
log.info("回源数据库,并写入两级缓存,店铺ID: {}", id);
return shop;
}
}
3.2 编写Canal监听器:实现缓存同步
这是实现数据一致性的核心。我们使用 canal-spring-boot-starter 来简化开发。创建一个 ShopHandler 类,实现 EntryHandler<T> 接口。
import com.hmdp.entity.Shop;
import com.github.benmanes.caffeine.cache.Cache;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import top.javatool.canal.client.annotation.CanalTable;
import top.javatool.canal.client.handler.EntryHandler;
import com.fasterxml.jackson.databind.ObjectMapper;
import javax.annotation.Resource;
@Component
@CanalTable(value = "tb_shop") // 指定监听的表名
@Slf4j
public class ShopHandler implements EntryHandler<Shop> {
@Autowired
private StringRedisTemplate redisTemplate;
@Resource
private Cache<String, Object> shopCache; // 与上面配置的是同一个Bean
private static final ObjectMapper MAPPER = new ObjectMapper();
private static final String CACHE_SHOP_KEY = "cache:shop:";
@Override
public void insert(Shop shop) {
log.info("Canal监听到新增商铺: {}", shop.getId());
updateCache(shop);
}
@Override
public void update(Shop before, Shop after) {
log.info("Canal监听到更新商铺,ID: {}", after.getId());
// 我们只关心更新后的数据
updateCache(after);
}
@Override
public void delete(Shop shop) {
log.info("Canal监听到删除商铺,ID: {}", shop.getId());
String key = CACHE_SHOP_KEY + shop.getId();
// 删除两级缓存
redisTemplate.delete(key);
shopCache.invalidate(key);
}
private void updateCache(Shop shop) {
String key = CACHE_SHOP_KEY + shop.getId();
try {
// 1. 更新Redis
String json = MAPPER.writeValueAsString(shop);
redisTemplate.opsForValue().set(key, json, 30, TimeUnit.MINUTES);
// 2. 更新Caffeine
shopCache.put(key, shop);
log.info("成功同步商铺缓存,ID: {}", shop.getId());
} catch (JsonProcessingException e) {
log.error("同步商铺缓存失败,ID: {}", shop.getId(), e);
}
}
}
这个监听器会监听到 tb_shop 表的所有数据变更。当数据库发生增、删、改时,Canal 客户端会收到事件,并自动调用对应的 insert、update、delete 方法。我们在这些方法中,同步地更新或删除 Redis 和 Caffeine 中的缓存数据。
关键改造点:现在,你的业务更新服务(如 ShopServiceImpl.update())中,不再需要手动删除缓存了。业务代码只需专注于更新数据库,缓存的一致性由 Canal 监听器这个“旁观者”来保证,实现了彻底的解耦。
// ShopServiceImpl.java 中的更新方法
@Override
public Result updateShop(Shop shop) {
// 1. 参数校验...
// 2. 更新数据库
boolean success = updateById(shop);
if (!success) {
return Result.fail("更新失败");
}
// 3. 注意!这里不再有删除缓存的操作。
// 缓存更新已交由Canal监听器异步处理。
return Result.ok();
}
4. 进阶优化与生产环境考量
一个能跑通的 Demo 只是第一步,要将其应用于生产环境,还需要考虑更多关于性能、可靠性和可观测性的问题。
4.1 性能与可靠性优化
-
批量处理与异步化:在高并发写入场景下,Canal 监听器可能瞬间收到大量事件。直接在事件处理方法中同步写 Redis 和 Caffeine 可能会阻塞线程,影响 Canal 客户端的消费速度。一个更好的做法是将事件放入一个内存队列(如 Disruptor),由单独的线程池异步批量处理缓存更新操作。
-
缓存更新幂等性:网络抖动或服务重启可能导致 Canal 客户端重复收到同一个 binlog 事件。我们的缓存更新操作(
set)需要是幂等的,即多次执行的结果与一次执行相同。幸运的是,Redis 的SET命令和 Caffeine 的put方法本身都是幂等的。但如果你的逻辑更复杂(比如先查后改),就需要设计幂等键或使用分布式锁来保证。 -
监听器故障与位点恢复:Canal 客户端会记录消费 binlog 的位点(position)。如果监听器应用崩溃重启,它可以从上次记录的位点继续消费,避免数据丢失。
canal-spring-boot-starter通常已经帮你处理了位点的持久化(如存入内存或文件)。但在分布式部署多个监听器实例时,需要确保它们消费不同的 Canal 实例或使用集群模式,避免重复消费。 -
缓存预热与降级:应用启动时,Caffeine 是空的。可以考虑在系统启动后,主动从 Redis 加载一批热点数据到 Caffeine 中,这就是缓存预热。同时,要为 Caffeine 和 Redis 都设置合理的过期时间和淘汰策略,并在缓存不可用时(如 Redis 宕机),设计好降级方案,例如直接查询数据库并记录日志告警。
4.2 监控与告警
一个没有监控的系统就像在黑夜中航行。对于这套缓存同步体系,我们需要关注几个关键指标:
- Canal 服务健康度:监控 Canal 服务的进程状态、CPU/内存使用率,以及
example.log中是否有连接 MySQL 失败、解析 binlog 异常等错误日志。 - 同步延迟:监控从数据库变更发生到缓存最终更新成功之间的时间差。可以在监听器中打点,记录事件处理时间,并上报到监控系统(如 Prometheus)。
- 缓存命中率:监控 Caffeine 和 Redis 的缓存命中率。Caffeine 提供了
Cache.stats()方法可以获取命中率、加载时间等统计信息。低的命中率可能意味着缓存策略需要调整。 - 资源使用:监控 Redis 的内存使用情况,避免因缓存数据过多导致 OOM。同时监控应用服务器的堆内存,因为 Caffeine 会占用 JVM 堆空间。
可以在监听器中增加简单的监控日志,更专业的做法是集成 Micrometer 等指标库,将数据暴露给监控平台。
// 在ShopHandler的updateCache方法中加入简单的延迟监控
private void updateCache(Shop shop) {
long startTime = System.currentTimeMillis();
// ... 缓存更新逻辑
long cost = System.currentTimeMillis() - startTime;
log.info("缓存同步完成,ID: {}, 耗时: {}ms", shop.getId(), cost);
// 如果耗时过长,可以触发告警
if (cost > 100) { // 假设100ms为阈值
log.warn("缓存同步延迟过高,ID: {}, 耗时: {}ms", shop.getId(), cost);
}
}
4.3 扩展思考:更复杂的场景
- 多表关联更新:如果一个商铺信息的更新,需要同时失效其关联的商品列表缓存,该怎么办?你可以在监听器中解析更复杂的业务逻辑,或者将 binlog 事件发布到消息队列(如 RocketMQ、Kafka),由多个不同的消费者来处理不同的缓存更新逻辑,实现更彻底的解耦和扩展。
- 分库分表:如果业务数据库做了分库分表,Canal 可以配置多个数据源,或者使用 Canal Admin 进行集群管理,来监听多个 MySQL 实例。
- 非MySQL数据源:如果核心数据不在 MySQL,而在 PostgreSQL、MongoDB 中呢?Canal 主要针对 MySQL。对于其他数据源,你需要寻找类似的 CDC(Change Data Capture)工具,如 Debezium,它支持多种数据库,并能将变更事件输出到 Kafka,后续的缓存更新逻辑则可以复用。
构建这样一个系统,最初的动机往往是为了解决一个具体的性能瓶颈,但在这个过程中,你会被迫去思考数据流、系统边界、最终一致性等更深层次的架构问题。每一次调试 binlog 解析,每一次处理缓存并发更新,都是对分布式系统理解的一次加深。这套架构在我经历的几个高并发项目中稳定运行,它带来的不仅仅是性能的提升,更是一种数据驱动、职责清晰的架构美感。当然,没有银弹,引入 Canal 也增加了运维的复杂性,你需要权衡收益与成本,在合适的业务场景下做出选择。
更多推荐




所有评论(0)