
Hello,我是小兔大白糖。 读完能按域与键选择拆分策略,并预见到跨片查询与扩容迁移的代价。
估计阅读时间:30 分钟
从单体 MySQL 到分布式数据层的架构跃迁:垂直拆分、水平拆分、分片键设计、扩容迁移与风控场景实战。
TL;DR
数据库分片(Sharding)是将海量数据与访问压力分散到多个数据库实例的核心手段。垂直拆分按业务解耦(用户库、订单库、风控库),水平拆分按数据行分散(user_id % 64)。选对分片键比分片本身更重要;雪花算法解决全局 ID;双写 + 增量同步实现平滑扩容。在风控场景下,交易流水表通常按用户 ID 哈希分片 + 时间维度归档,兼顾查询性能与数据生命周期管理。
1. 概念定义(是什么)
1.1 数据库分片的本质
当单库单表的数据量、并发量或存储容量触及瓶颈时,将数据分散到多个数据库实例(或表)中的技术,称为数据库分片(Database Sharding)。它是** Scale-Out(横向扩展)** 在数据层的具体实现。
分片的核心目标:
- 分散存储压力:单表 5000 万行以上时,B+ 树高度增加,索引效率下降
- 分散读写压力:将 QPS 从 10k 拆分到 10 个库的 1k
- 提升可用性:单库故障不影响全局(配合多副本)
1.2 类比:图书馆分馆系统
想象一座市级图书馆藏书 1000 万册,一座大楼放不下,检索也慢。分片就是建分馆:
- 垂直拆分:按学科建分馆——科技书去科技园分馆,文学书去文艺分馆,法律书去政法分馆。每个分馆的书架结构(表结构)不同,但藏书量少了。
- 水平拆分:科技书还是太多,科技园分馆再按书名首字母 A-M、N-Z 拆成两个分馆。书架结构完全一样,但每个分馆的藏书量是原来的一半。
风控类比:风控系统积累了 10 亿条交易流水。垂直拆分把用户画像、交易流水、规则执行日志分到不同库;水平拆分把交易流水按用户 ID 哈希到 64 张表,查询某用户历史时直接路由到单表。
2. 核心原理与图解
2.1 垂直拆分(Vertical Sharding)
定义:按业务模块拆分表到不同数据库,每个库表结构不同。
Before (单库): After (垂直拆分):
┌─────────────────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ db_main │ │ db_user │ │ db_trade │ │ db_risk │
│ ├── users │ │ ├── users │ │ ├── orders │ │ ├── rules │
│ ├── orders │ → │ ├── kyc │ │ ├── trades │ │ ├── alerts │
│ ├── trades │ │ └── auth │ │ └── settlements │ └── logs │
│ ├── risk_rules │ └─────────────┘ └─────────────┘ └─────────────┘
│ └── risk_logs │
└─────────────────────────┘适用场景:
- 业务耦合度低,不同模块数据增长独立
- 需要按业务维度隔离权限与资源
- 某些表字段极宽(如 JSON 大字段),频繁访问小字段时拖慢整行
痛点:
- 跨库 Join 无法直接执行,需在应用层聚合
- 分布式事务复杂度上升
- 一个业务热点可能仍会导致单库瓶颈(如订单库仍然太大)
2.2 水平拆分(Horizontal Sharding)
定义:将同一张表的数据按某种规则分散到多个库/表中,每个分片表结构完全相同。
Before (单表 trades): After (水平拆分 trades_00 ~ trades_63):
┌─────────────────────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ trades (10亿行) │ │trades_00 │ │trades_01 │ ... │trades_63 │
│ ├── id │ → │(user_id%64=0)│(user_id%64=1)│ │(user_id%64=63)│
│ ├── user_id │ └──────────┘ └──────────┘ └──────────┘
│ ├── amount │
│ └── created_at │
└─────────────────────────┘分片策略对比:
| 策略 | 原理 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| Hash 取模 | shard = hash(key) % N | 数据分布均匀,单分片查询快 | 扩容需迁移数据(N 变) | 用户 ID、订单 ID 等均匀键 |
| Range 范围 | 按时间/ID 区间划分 | 扩容简单(追加新分片),范围查询友好 | 热点风险(新分片压力大) | 日志、流水按月份分表 |
| 一致性 Hash | Hash 环 + 虚拟节点 | 扩容只影响相邻节点,迁移量小 | 实现复杂,数据分布需调虚拟节点数 | 缓存分片(Redis Cluster) |
| 混合策略 | 先 Range 再 Hash | 兼顾扩展性与均匀性 | 路由复杂 | 金融交易:按月 Range,月内按 Hash |
2.3 ShardingSphere 架构解析
Apache ShardingSphere 是业界最常用的数据库中间件方案,定位数据库增强引擎,提供分片、加密、读写分离、影子库等能力。
核心组件:
- SQL Parser:基于 ANTLR 将 SQL 解析为 AST,识别表名、WHERE 条件、聚合函数
- Router:根据分片规则计算目标分片(如
user_id = 12345→ds1.trade_01) - Rewriter:改写 SQL,将逻辑表
trade替换为物理表trade_01,并补充分片键 - Executor:多线程并行执行路由后的 SQL,默认连接池隔离
- Merger:将多分片结果集归并(内存排序、流式聚合、分组计算)
路由类型:
- 标准路由:单分片键等值查询(
WHERE user_id = ?)→ 精确路由到单分片 - 笛卡尔积路由:多分片键不在同一维度(
WHERE user_id = ? AND order_id = ?且分片键不同)→ 全分片扫描,性能灾难 - 全库表路由:无分片键条件(
SELECT * FROM trade)→ 全部分片广播
2.4 全局唯一 ID:雪花算法(Snowflake)
分片后自增 ID 会冲突,需全局唯一 ID 生成器。Twitter Snowflake 是业界标准方案。
┌─ 1 bit ─┬──── 41 bit ─────┬─── 10 bit ───┬──── 12 bit ────┐
│ 符号位 │ 时间戳(毫秒) │ 机器/数据中心 │ 序列号(自增) │
│ 0 │ 69 年范围 │ 1024 节点 │ 每毫秒 4096 │
└─────────┴─────────────────┴──────────────┴────────────────┘
63bit 长整型(Long)
核心思想:用时间戳 + 机器标识 + 序列号组合生成趋势递增的 64 位 Long 型 ID。
- 趋势递增:非严格连续,但总体递增,对 B+ 树友好(减少页分裂)
- 去中心化:各节点本地生成,无需中心节点协调
- 时钟回拨风险:依赖系统时钟,回拨会导致 ID 重复——需兜底(等待、异常或序列号预留)
改良版(美团 Leaf / 百度 UidGenerator):
- Leaf-Segment:号段模式,从 DB 批量获取 ID 区间,内存分配
- Leaf-Snowflake:ZK 协调 workerId,解决时钟回拨
- UidGenerator:用 RingBuffer 缓存,支持秒级/毫秒级时间戳
2.5 扩容迁移方案:双写 + 增量同步
分库分表后最痛苦的场景是扩容——从 4 库 4 表扩到 8 库 8 表。直接停机迁移不可接受。
关键步骤:
| 阶段 | 动作 | 风险点 |
|---|---|---|
| 1. 存量迁移 | 历史数据按新规则导入新分片 | 全量扫描旧库压力大,需限速 |
| 2. 增量同步 | Canal / Debezium 实时同步 Binlog | DDL 变更需同步处理;延迟监控 |
| 3. 数据校验 | 抽样比对 + Checksum 全量校验 | 数据量大时分片校验;不一致修复 |
| 4. 双写阶段 | 应用同时写新旧两套分片 | 双写一致性(本地事务 + 异步补偿) |
| 5. 灰度切读 | 按用户维度灰度读新分片 | 异常回滚机制;监控延迟/错误率 |
| 6. 旧库下线 | 停止同步,保留只读或归档 | 确保无业务依赖后再删除 |
3. 语法详解与代码示例(怎么用)
3.1 ShardingSphere-JDBC 配置:交易流水分片
以风控系统的 trade_record 表为例,按 user_id 取模分 4 库,每库 16 表。
application-sharding.yml:
spring:
shardingsphere:
datasource:
names: ds0, ds1, ds2, ds3
ds0:
type: com.zaxxer.hikari.HikariDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
jdbc-url: jdbc:mysql://db-risk-0:3306/risk_db?serverTimezone=UTC
username: ${DB_USER}
password: ${DB_PASS}
ds1:
type: com.zaxxer.hikari.HikariDataSource
jdbc-url: jdbc:mysql://db-risk-1:3306/risk_db?serverTimezone=UTC
ds2:
type: com.zaxxer.hikari.HikariDataSource
jdbc-url: jdbc:mysql://db-risk-2:3306/risk_db?serverTimezone=UTC
ds3:
type: com.zaxxer.hikari.HikariDataSource
jdbc-url: jdbc:mysql://db-risk-3:3306/risk_db?serverTimezone=UTC
rules:
sharding:
tables:
trade_record:
# 实际数据节点:ds{0..3}.trade_record_{0..15}
actual-data-nodes: ds${0..3}.trade_record_${0..15}
table-strategy:
standard:
sharding-column: user_id
sharding-algorithm-name: trade-record-hash
database-strategy:
standard:
sharding-column: user_id
sharding-algorithm-name: trade-record-db-hash
key-generate-strategy:
column: id
key-generator-name: snowflake
sharding-algorithms:
trade-record-hash:
type: INLINE
props:
algorithm-expression: trade_record_${user_id % 16}
trade-record-db-hash:
type: INLINE
props:
algorithm-expression: ds${user_id % 4}
key-generators:
snowflake:
type: SNOWFLAKE
props:
worker-id: ${WORKER_ID:0}
max-vibration-offset: 1Java 实体类:
@Data
@TableName("trade_record") // 逻辑表名
public class TradeRecord {
@TableId(type = IdType.INPUT) // 使用 ShardingSphere 生成的雪花 ID
private Long id;
private Long userId; // 分片键
private String tradeNo; // 业务单号,唯一索引
private BigDecimal amount; // 交易金额
private String currency; // 币种
private Integer tradeType; // 1-充值 2-提现 3-转账 4-合约
private String counterpartyAddress; // 对手方地址(风控关注)
private Integer riskStatus; // 0-待审核 1-通过 2-拦截 3-人工复核
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
}Mapper 接口:
@Mapper
public interface TradeRecordMapper extends BaseMapper<TradeRecord> {
// 精确分片键查询 → 精确路由到单分片
@Select("SELECT * FROM trade_record WHERE user_id = #{userId} AND trade_no = #{tradeNo}")
TradeRecord selectByUserAndTradeNo(@Param("userId") Long userId, @Param("tradeNo") String tradeNo);
// 范围查询 → 全分片广播 + 内存归并(需分页限制)
@Select("SELECT * FROM trade_record WHERE created_at BETWEEN #{start} AND #{end} " +
"ORDER BY created_at DESC LIMIT #{limit}")
List<TradeRecord> selectByTimeRange(@Param("start") LocalDateTime start,
@Param("end") LocalDateTime end,
@Param("limit") int limit);
// 聚合查询 → ShardingSphere 自动分页归并,但大数据量性能差
@Select("SELECT COUNT(*), SUM(amount) FROM trade_record WHERE user_id = #{userId}")
Map<String, Object> selectStatsByUser(@Param("userId") Long userId);
}3.2 自定义分片算法:按月 + 哈希混合
风控场景常需按时间归档旧数据,同时保证当前月内查询均匀。
/**
* 风控交易流水混合分片算法
* 先按月 Range 定位表,再按 user_id Hash 定位分片
* 表名格式:trade_record_202501_00 ~ trade_record_202501_15
*/
public class TradeRecordComplexShardingAlgorithm implements
ComplexKeysShardingAlgorithm<String> {
private static final int TABLE_PER_MONTH = 16; // 每月 16 张表
@Override
public Collection<String> doSharding(Collection<String> availableTargetNames,
ComplexKeysShardingValue<String> shardingValue) {
Map<String, Collection<Comparable<?>>> columnNameAndShardingValuesMap =
shardingValue.getColumnNameAndShardingValuesMap();
Collection<Comparable<?>> userIds = columnNameAndShardingValuesMap.get("user_id");
Collection<Comparable<?>> createTimes = columnNameAndShardingValuesMap.get("created_at");
Set<String> result = new HashSet<>();
// 提取月份,如 "2025-01"
String month = getMonthFromCreateTime(createTimes);
// 计算哈希分片
for (Comparable<?> userId : userIds) {
long uid = ((Number) userId).longValue();
int tableIndex = (int) (Math.abs(uid) % TABLE_PER_MONTH);
String tableName = String.format("trade_record_%s_%02d", month, tableIndex);
// 过滤可用节点(动态表名需匹配)
for (String target : availableTargetNames) {
if (target.contains(tableName)) {
result.add(target);
}
}
}
return result.isEmpty() ? availableTargetNames : result;
}
private String getMonthFromCreateTime(Collection<Comparable<?>> createTimes) {
if (createTimes == null || createTimes.isEmpty()) {
// 无时间条件时扫描最近 3 个月(兜底,性能差)
return getCurrentMonth();
}
Comparable<?> time = createTimes.iterator().next();
LocalDateTime dt = (LocalDateTime) time;
return dt.format(DateTimeFormatter.ofPattern("yyyyMM"));
}
}3.3 雪花算法实现(带时钟回拨防护)
/**
* 风控场景优化的 Snowflake ID 生成器
* 特性:
* 1. 支持 1024 个 Worker 节点
* 2. 时钟回拨时等待或抛异常(可配置)
* 3. 序列号每毫秒 4096,单机 TPS 上限约 400 万
*/
public class RiskSnowflakeIdGenerator {
// 起始时间戳(2024-01-01),可用 69 年
private static final long START_TIMESTAMP = 1704067200000L;
// 各部分位数
private static final long DATA_CENTER_BITS = 5L;
private static final long WORKER_BITS = 5L;
private static final long SEQUENCE_BITS = 12L;
// 最大值
private static final long MAX_DATA_CENTER = ~(-1L << DATA_CENTER_BITS); // 31
private static final long MAX_WORKER = ~(-1L << WORKER_BITS); // 31
private static final long MAX_SEQUENCE = ~(-1L << SEQUENCE_BITS); // 4095
// 位移
private static final long WORKER_SHIFT = SEQUENCE_BITS;
private static final long DATA_CENTER_SHIFT = SEQUENCE_BITS + WORKER_BITS;
private static final long TIMESTAMP_SHIFT = DATA_CENTER_SHIFT + DATA_CENTER_BITS;
private final long dataCenterId;
private final long workerId;
private long lastTimestamp = -1L;
private long sequence = 0L;
// 时钟回拨容忍阈值(毫秒)
private static final long CLOCK_BACKWARD_TOLERANCE = 5L;
public RiskSnowflakeIdGenerator(long dataCenterId, long workerId) {
if (dataCenterId > MAX_DATA_CENTER || dataCenterId < 0) {
throw new IllegalArgumentException("Data center ID out of range");
}
if (workerId > MAX_WORKER || workerId < 0) {
throw new IllegalArgumentException("Worker ID out of range");
}
this.dataCenterId = dataCenterId;
this.workerId = workerId;
}
public synchronized long nextId() {
long currentTimestamp = System.currentTimeMillis();
// 时钟回拨检测
if (currentTimestamp < lastTimestamp) {
long offset = lastTimestamp - currentTimestamp;
if (offset <= CLOCK_BACKWARD_TOLERANCE) {
try {
wait(offset << 1); // 等待 2 倍差值
currentTimestamp = System.currentTimeMillis();
if (currentTimestamp < lastTimestamp) {
throw new RuntimeException("Clock moved backwards too far");
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Interrupted while waiting for clock");
}
} else {
throw new RuntimeException(
String.format("Clock moved backwards by %d ms", offset));
}
}
if (currentTimestamp == lastTimestamp) {
sequence = (sequence + 1) & MAX_SEQUENCE;
if (sequence == 0) {
// 当前毫秒内序列号用完,等待下一毫秒
currentTimestamp = waitNextMillis(lastTimestamp);
}
} else {
sequence = 0L; // 新毫秒,序列号重置
}
lastTimestamp = currentTimestamp;
return ((currentTimestamp - START_TIMESTAMP) << TIMESTAMP_SHIFT)
| (dataCenterId << DATA_CENTER_SHIFT)
| (workerId << WORKER_SHIFT)
| sequence;
}
private long waitNextMillis(long lastTimestamp) {
long timestamp = System.currentTimeMillis();
while (timestamp <= lastTimestamp) {
timestamp = System.currentTimeMillis();
}
return timestamp;
}
// 解析 ID 成分(调试用)
public static IdComponents parse(long id) {
IdComponents c = new IdComponents();
c.timestamp = (id >> TIMESTAMP_SHIFT) + START_TIMESTAMP;
c.dataCenterId = (id >> DATA_CENTER_SHIFT) & MAX_DATA_CENTER;
c.workerId = (id >> WORKER_SHIFT) & MAX_WORKER;
c.sequence = id & MAX_SEQUENCE;
return c;
}
@Data
public static class IdComponents {
private long timestamp;
private long dataCenterId;
private long workerId;
private long sequence;
}
}3.4 双写组件:平滑扩容的抽象层
/**
* 分片双写路由组件
* 扩容期间同时写入新旧两套分片,读操作根据灰度配置切换
*/
@Component
public class ShardingDualWriteRouter {
@Autowired
private TradeRecordMapper oldMapper; // 旧分片(4库4表)
@Autowired
private TradeRecordMapperNew newMapper; // 新分片(8库16表)
@Value("${sharding.dual-write.enabled:false}")
private boolean dualWriteEnabled;
@Value("${sharding.dual-write.read-new-percent:0}")
private int readNewPercent; // 0~100,灰度读新分片
private final ThreadLocalRandom random = ThreadLocalRandom.current();
/**
* 写操作:双写或单写
*/
public void insert(TradeRecord record) {
// 始终写旧分片(保证稳定)
oldMapper.insert(record);
// 扩容期间异步写新分片(不阻塞主流程)
if (dualWriteEnabled) {
CompletableFuture.runAsync(() -> {
try {
newMapper.insert(record);
} catch (Exception e) {
// 新分片写入失败不影响主流程,记录日志异步补偿
log.error("Dual write to new shard failed: {}", record.getTradeNo(), e);
// 可投递死信队列或告警
}
}, dualWriteExecutor);
}
}
/**
* 读操作:按灰度比例路由
*/
public TradeRecord selectByUserAndTradeNo(Long userId, String tradeNo) {
boolean readNew = random.nextInt(100) < readNewPercent;
if (readNew) {
try {
TradeRecord result = newMapper.selectByUserAndTradeNo(userId, tradeNo);
if (result != null) {
// 异步对比新旧分片结果(数据一致性校验)
CompletableFuture.runAsync(() ->
validateConsistency(userId, tradeNo, result));
return result;
}
} catch (Exception e) {
log.warn("Read from new shard failed, fallback to old: {}", tradeNo);
}
}
return oldMapper.selectByUserAndTradeNo(userId, tradeNo);
}
private void validateConsistency(Long userId, String tradeNo, TradeRecord newResult) {
try {
TradeRecord oldResult = oldMapper.selectByUserAndTradeNo(userId, tradeNo);
if (!Objects.equals(newResult, oldResult)) {
log.error("Data inconsistency detected: tradeNo={}", tradeNo);
// 投递不一致告警
}
} catch (Exception e) {
log.error("Consistency check failed", e);
}
}
}4. 业界案例
4.1 阿里巴巴:淘宝订单库从 1 库到 1000+ 分片的演进
背景:2007 年淘宝日均订单 100 万,单库 Oracle 性能到顶。
演进路线:
- 2007-2009 垂直拆分:按业务拆用户库、商品库、交易库。交易库仍是瓶颈。
- 2010-2012 水平拆分:交易表按买家 ID 取模分 16 库 64 表。但卖家查询性能差(需跨分片)。
- 2013-2015 异构索引表:同一份数据按买家 ID 和卖家 ID 各建一套分片表,异步同步。查询卖家订单走卖家维度分片。
- 2016+ 单元化:按用户维度拆分整个应用 + 数据,形成自包含单元(Cell),异地多活。
关键教训:
- 分片键选择要匹配查询模式。淘宝订单按买家分片,但卖家查询成了跨分片灾难,最终用空间换时间做异构索引。
- 阿里巴巴开源了 ShardingSphere(原 Sharding-JDBC)和 Canal,将内部能力产品化。
风控启示:交易流水表若需按用户和按时间两种维度查询,可设计异构表——主表按用户 ID 分片,归档表按月份分片,通过 Canal 异步同步。
4.2 美团:外卖订单分库分表与 Leaf 全局 ID
背景:美团外卖高峰期 QPS 数十万,订单表单日增量 3000 万+。
方案:
- 分片策略:订单表按
user_id % 64分 64 库,每库 64 表,共 4096 张表 - 全局 ID:自研 Leaf 号段模式(Leaf-Segment)+ 雪花模式(Leaf-Snowflake)
- Leaf-Segment:从 DB 批量获取 ID 区间(如 [1, 1000]),内存分配,QPS 可达几十万
- Leaf-Snowflake:ZK 协调 workerId,解决时钟回拨,适合高并发无序场景
- 扩容迁移:采用一拆二策略,每次扩容翻倍(64 → 128),减少迁移复杂度
踩过的坑:
- 热点用户:某些商家订单量极大,导致单分片热点。解决:对商家维度再做二级哈希,或热点数据单独分片。
- 分布式事务:跨分片订单 + 优惠券 + 支付,最终采用本地消息表 + 异步对账保证最终一致。
4.3 LinkedIn:时间序列数据库的分片哲学
LinkedIn 的监控数据系统 Espresso 和 Ambry 处理 PB 级数据:
- 消息流(Kafka):按
partition_key哈希分片,保证同用户消息顺序 - 图数据库(Espresso):用户关系数据按用户 ID 范围分片,本地查询为主
- 对象存储(Ambry):文件按一致性 Hash 分布,虚拟节点数 100+,扩容时迁移量 < 5%
LinkedIn 的经验:
"The hardest part of sharding is not the algorithm, but the operational tooling for rebalancing and failure recovery." (分片最难的不是算法,而是再平衡和故障恢复的运营工具。)
5. 业务场景对照与注意事项
5.1 风控场景下的分片设计
场景:大型加密货币交易所 交易流水表 trade_record
| 维度 | 设计决策 | 理由 |
|---|---|---|
| 垂直拆分 | trade_record 独立库,与用户/KYC 库分离 | 交易数据增长最快,独立扩容 |
| 水平拆分键 | user_id(主)、created_at(辅) | 90% 查询按用户查历史;风控规则按时间窗口扫描 |
| 分片数 | 16 库 × 64 表 = 1024 分片 | 支持 10 亿级数据,单分片 < 1000 万行 |
| 全局 ID | 改良 Snowflake(毫秒级 + 10 bit 节点) | 趋势递增,支持 1024 节点,用于 trace 串联 |
| 跨分片查询 | 禁止无分片键的全表扫描;时间范围查询走归档表 | 风控实时规则查询必须带 user_id |
| 数据归档 | 3 个月前数据按月份迁移到 StarRocks / Hive | OLTP 只保留热数据,冷数据用于离线模型训练 |
风控特殊考量:
-
关联分析查询:风控需查 "某地址关联的所有用户",但表按用户分片,地址查询需全分片扫描。解决方案:
- 建立异构索引表:
address_index按地址分片,存储address → user_id映射 - 使用 Elasticsearch 做二级索引,MySQL 只存主事务数据
- 建立异构索引表:
-
时间窗口聚合:实时规则需统计 "过去 1 小时某用户交易金额"。按用户分片时单分片可计算;若按时间分片则需跨分片。解决方案:
- 实时特征用 Redis 滑动窗口预聚合,不走 DB
- 离线特征用 StarRocks MPP 计算
-
黑名单/名单查询:全局名单(如制裁地址)需全量匹配。解决方案:
- 名单量小(< 1000 万):全量加载到本地缓存(Caffeine)
- 名单量大:用 Redis BloomFilter 预过滤,DB 只查可疑命中
5.2 常见误区 vs 正确做法
| ❌ 误区 | ✅ 正确做法 |
|---|---|
| 分片数越多越好(1024 张表) | 根据数据量规划,单表 500-1000 万行为宜;过多表增加元数据开销 |
| 用自增 ID 做主键 | 分片后必须全局唯一 ID(Snowflake/Leaf),自增 ID 会冲突 |
| 分片键选 UUID | UUID 随机导致页分裂严重;应选趋势递增的雪花 ID |
| 跨分片 Join 交给中间件 | 中间件只能做内存归并,大数据量会 OOM;应在应用层聚合或冗余字段 |
| 扩容时直接停机迁移 | 必须双写 + 灰度切流,风控系统 7×24 不可停 |
| 忽略分片后的索引设计 | 分片后单表数据量减少,但仍需覆盖索引;特别注意全局唯一约束需改分布式约束 |
5.3 选型建议
| 场景 | 推荐方案 | 不推荐 |
|---|---|---|
| 数据量 < 500 万,QPS < 1000 | 单库单表 + 读写分离 | 过早分片 |
| 数据量 500 万-5000 万 | 单库分表(按月/哈希) | 跨库事务 |
| 数据量 > 5000 万,多业务模块 | 垂直拆分 + 水平拆分 | 单库扛所有 |
| 需要复杂 OLAP 查询 | StarRocks/ClickHouse 做分析库,MySQL 做事务库 | MySQL 做大宽表聚合 |
| 全球化部署(大型加密货币交易所) | 单元化分片(按地域 + 用户) | 全球单库 |
6. FAQ 与高频追问
Q1:为什么分片键的选择比分片算法更重要?如果选错了会怎样?
答:分片键决定数据分布和查询路由。选错会导致:
- 数据倾斜:如按
country分片,中国用户占 80%,导致某个分片成为热点 - 查询无法路由:若分片键是
user_id,但业务常按trade_no查,则每次查询需全分片扫描 - 扩容困难:选错后改分片键需全量迁移,等于重建分片
正确做法:分析业务查询模式,选最高频查询条件作为分片键;若多维度高频查询,考虑异构索引表或二级索引。
Q2:雪花算法的时钟回拨问题怎么解决?生产环境有什么兜底方案?
答:时钟回拨是指服务器 NTP 同步导致本地时钟倒退,可能生成重复 ID。解决方案:
- 等待策略:检测到回拨时阻塞等待至上次时间戳(适合小幅回拨 < 5ms)
- 异常策略:回拨超过阈值直接抛异常,上层重试或降级(美团 Leaf-Snowflake)
- 序列号预留:每毫秒序列号只用 0-2047,回拨时用 2048-4095 区间(百度 UidGenerator)
- 硬件时钟:使用 Chrony 精细同步,避免大幅回拨
生产兜底:
- 多机部署时,某节点时钟异常可快速摘除(健康检查)
- ID 生成服务独立部署,不依赖业务机器时钟
- 数据库唯一索引兜底,即使重复 ID 写入也会报错
Q3:分片后如何做全局唯一约束?比如 trade_no 必须全局唯一。
答:分片后单库唯一索引只能保证本分片唯一,需额外机制:
- 全局表(Global Table):建一张
trade_no_unique全局表,所有分片写之前先查/插全局表。缺点:全局表成瓶颈。 - 分布式锁 + 唯一索引:用 Redis RedLock 获取锁,再插入本分片唯一索引。缺点:引入外部依赖。
- Snowflake 融入业务码:将业务标识(如币种、交易类型)编码进 ID,保证全局唯一,无需额外校验。
- 后置对账:允许短暂重复,异步对账修复(最终一致)。适合风控日志等非强一致场景。
推荐:方案 3 为主(ID 天然唯一),方案 4 为辅(核心业务对账兜底)。
Q4:分片后扩容从 4 库扩到 8 库,数据怎么迁移?如何做到不停机?
答:标准流程(见 2.5 节时序图):
- 存量同步:用 Apache SeaTunnel / DataX 按新规则(user_id % 8)全量导出导入
- 增量同步:Canal / Debezium 订阅旧库 Binlog,实时写入新库
- 数据校验:抽样比对 + MD5 校验全量数据
- 双写阶段:应用同时写新旧库,读旧库
- 灰度切读:按用户维度(如 user_id % 1000 < 10)逐步切读新库,观察延迟和错误率
- 全量切换:100% 读新库,停止写旧库,旧库保留只读
关键:风控系统可用性要求极高,灰度周期可能持续 1-2 周,期间需监控新旧库数据延迟(< 100ms)和一致性差异率(< 0.001%)。
Q5:ShardingSphere 的 SQL 执行流程是怎样的?什么情况下会触发全分片扫描?
答:执行流程(见 2.3 Mermaid 图):
SQL → Parser(AST)→ Router(计算分片)→ Rewriter(改写表名)→ Executor(多线程执行)→ Merger(结果归并)
触发全分片扫描的情况:
- WHERE 条件不包含分片键(如
SELECT * FROM trade WHERE status = 1) - 分片键在函数中(如
WHERE YEAR(created_at) = 2024),中间件无法提取值 - 使用 OR 条件跨分片键(如
WHERE user_id = 1 OR user_id = 2且 user_id 分片,部分中间件优化后可精准路由,但复杂条件不行) - 聚合排序无分片键(如
ORDER BY amount DESC LIMIT 10)需全分片排序后内存归并
优化:
- 强制要求分片键查询(风控查询必须带 user_id)
- 分页查询用 "分片键 + 游标" 替代深分页
LIMIT 1000000, 10 - 聚合统计走 StarRocks / Hive,不走 OLTP 分片库
Q6:分库分表后,分布式事务怎么解决?风控场景对一致性要求高,能用最终一致吗?
答:分片后单机事务变成分布式事务,方案按一致性强度排序:
- 强一致(2PC/XA):Seata AT 模式,性能差(RT + 2-3 倍),风控实时拦截链路不适合
- 柔性事务(TCC/Saga):业务层实现 Try/Confirm/Cancel,复杂度高,适合资金结算
- 本地消息表:事务内写业务表 + 消息表,异步投递,最终一致。适合风控事件推送
- 最大努力通知 + 对账:允许短暂不一致,日终对账修复
风控场景决策:
- 实时拦截(< 50ms):单分片事务 + 异步补偿,不强求跨分片事务
- 资金冻结/扣减:TCC 或 Saga,确保扣减可回滚
- 日志/特征写入:本地消息表 + Kafka,最终一致即可
核心原则:风控系统的决策链路尽量设计为单分片操作(按用户维度聚合),从根本上避免分布式事务。
Q7:如果某用户是超级大户,交易频率极高,导致单分片热点怎么办?
答:分片热点是 Hash 分片的经典问题,解决方案:
- 热点探测 + 自动分片:监控单分片 QPS,超过阈值时将热点用户数据迁移到独立分片(类似 Redis Cluster 的 resharding)
- 二级哈希:对热点用户再细分,如
user_id = 123的数据再按trade_no % 4拆成 4 张子表 - 读写分离 + 缓存:热点数据全量缓存到 Redis,读请求走缓存,写请求仍走主分片
- 业务限流:对单用户交易频率做硬限流(如 100 TPS),从源头控制
大型加密货币交易所 场景:交易所对 API 高频交易有明确限频(如 1200 weight/min),天然限制了单用户热点。
附录:分片选型决策树
数据量是否超过 5000 万?
├── 否 → 单库优化(索引 + 缓存 + 读写分离)
└── 是 → 业务模块是否多?
├── 是 → 垂直拆分(按业务分库)
└── 否 → 查询是否以某字段为主?
├── 否 → reconsider 是否真的需要分片
└── 是 → 该字段是否离散均匀?
├── 否 → 考虑一致性 Hash 或 Range
└── 是 → Hash 取模分片
→ 是否需要跨维度查询?
├── 是 → 异构索引表 / ES 二级索引
└── 否 → 标准分片 + 全局 ID
记忆口诀:
- 垂直拆 = 分学科建分馆(业务解耦)
- 水平拆 = 同科书分两馆(数据分散)
- 分片键 = 查书时先想按什么找(查询模式决定)
- 雪花 ID = 时间 + 地点 + 编号(三要素全局唯一)
- 扩容 = 先开新馆同步书,再逐步引导读者(双写灰度)