目录
(三)数据源路由:AbstractRoutingDataSource
六、代码实操二:基于ShardingSphere-JDBC落地
干货分享,感谢您的阅读!
分库分表常被当成"数据量大了就该做"的标准动作,但真正让团队付出代价的,从来不是拆分本身,而是拆分之后的每一条查询、每一次扩容、每一个跨库事务。
本文基于 Java 8 技术栈,先回答"要不要拆、按什么拆、拆成多少"这三个方法论问题,再用两套可编译运行的代码——手写路由层与 ShardingSphere-JDBC——把路由、分布式 ID、跨分片查询、不停机迁移与扩容逐一落地。文中的数字均来自配套工程的实际运行输出,算法与配置可直接对照源码复核。
一、先别急着拆:分库分表要解决的究竟是什么问题
很多团队在单表行数刚过千万时就开始讨论分库分表,理由往往是"听说 MySQL 单表超过两千万就不行了"。这句话有一定来历,但把它当成决策依据是危险的:分库分表是一项不可逆程度很高的架构决策,一旦落地,SQL 能力、事务语义、运维方式都会被永久改变。所以第一件事不是选中间件,而是准确描述瓶颈。
(一)单库单表的四类瓶颈
单机数据库在业务增长中遇到的压力,可以归结为四类,它们对应的解法截然不同。
第一类是存储容量瓶颈。 单表数据量增长到一定规模后,B+ 树层高增加,索引与热数据无法完整驻留在 Buffer Pool 中,随机 IO 显著上升;同时单实例磁盘容量、备份与恢复时长也会逼近上限。一个 3TB 的实例做一次全量恢复可能需要数小时,这本身就是可用性风险。
第二类是写入吞吐瓶颈。 读压力可以用从库和缓存横向分摊,写入却只能落在主库上。当峰值写入 TPS 接近单主库的安全水位时,redo log 刷盘、行锁竞争、主从复制延迟会同时恶化,这是读写分离无法解决的问题,也是分库最硬的理由。
第三类是连接数瓶颈。 微服务化之后,几十个服务、每个服务几十个实例、每个实例一个连接池,很容易让单个 MySQL 实例的连接数突破上千。连接本身消耗内存与线程调度资源,大量空闲连接还会放大故障时的"连接风暴"。
第四类是运维变更瓶颈。 大表加字段、加索引、归档清理的耗时与单表体积线性相关。即便有 Online DDL 与 gh-ost 这类工具,对几亿行的表做一次变更仍然需要数小时,期间的主从延迟和磁盘占用都是风险点。

识别瓶颈类型的意义在于:容量瓶颈可以靠分表解决,写入与连接瓶颈必须靠分库解决,运维瓶颈往往靠归档就能缓解。 如果只是查询慢,那多半根本不需要拆。
(二)拆分之前先走完降级阶梯
分库分表的代价是把一个"数据库问题"变成了一个"分布式系统问题"。在此之前,有一串成本更低的手段值得依次尝试,可以把它想象成一级一级的台阶,每上一级,复杂度和不可逆程度都会提高。
1. SQL 与索引治理:慢查询里有相当比例是索引缺失、隐式类型转换、深分页 LIMIT 100000, 20、SELECT * 回表造成的,这一级的收益常常超出预期。
2. 读写分离:用一主多从承接读流量,配合"写后读主"的路由规则解决复制延迟带来的读不到问题。
3. 缓存:热点读交给 Redis,注意缓存一致性与击穿防护。
4. 冷热分离与归档:订单、流水类数据通常只有最近几个月是热的,把历史数据迁到归档库或对象存储,单表立即"瘦身"。
5. 垂直拆分:按业务域把不同的表拆到不同的库,分摊写入与连接。
6. 水平分片:最后才是把同一张表的数据按行拆到多个库表中。
7. 更换存储:如果业务强依赖跨分片的复杂查询和强一致事务,也可以评估 TiDB、OceanBase 这类分布式数据库,把分片的复杂度交给存储层。

这张阶梯有两个用法。其一是作为评审清单:提出分库分表方案时,需要说明前面几级为什么不够。其二是作为组合方案:水平分片落地后,读写分离、缓存和归档依然要做,它们不是互斥关系。阿里巴巴 Java 开发手册给出的建议是"单表行数超过 500 万行或者单表容量超过 2GB,才推荐进行分库分表",同时强调如果预计三年后的数据量根本达不到这个级别,请不要在创建表时就分库分表。这条建议背后的逻辑正是:先评估增长,再决定是否承担复杂度。
(三)用数字而不是经验判断"该拆了"
"两千万"这个数字的出处是 InnoDB 的 B+ 树结构。与其背诵结论,不如把计算过程拿出来,才能针对自己的表得出合理阈值。
1、B+树层高与单表行数
InnoDB 默认页大小为 16KB。以 BIGINT 主键为例,非叶子节点每个条目由主键(8 字节)和页指针(6 字节)组成,理想情况下一页可以容纳约 16384 ÷ 14 ≈ 1170 个条目,这就是扇出。叶子节点存放整行数据,若平均行宽 1KB,一页约存 16 行。于是三层 B+ 树的理论容量约为 1170 × 1170 × 16 ≈ 2190 万行——"两千万"由此而来。
但这个估算过于理想:每条记录还有约 5 字节的记录头,页本身有页头、页尾和页目录等固定开销,而且页不会被填满(顺序插入约 15/16,随机插入更低)。把这些因素考虑进去之后,配套工程里的 CapacityPlanner 给出的结果是:
三层 B+ 树, 行宽 1KB : 约 8300600 行
三层 B+ 树, 行宽 300B : 约 28459200 行
也就是说,对于行宽 1KB 的宽表,三层树的真实上限可能只有八百多万行;而对于行宽 300 字节的窄表,接近三千万行也仍是三层。阈值取决于行宽,而不是一个固定数字。

2、真正的约束:热数据能否留在内存
即使树高从三层变成四层,单次主键查询也只多一次页访问,而且上层节点几乎总在内存中,性能并不会断崖式下跌。真正决定性能的是工作集(热数据 + 热索引)能否放进 Buffer Pool。一个 5 亿行的表,如果每天只访问最近一周的数据,工作集可能只有几个 GB;而一个 3000 万行但访问完全随机的表,Buffer Pool 命中率可能会惨不忍睹。所以评估时要同时看两个指标:Innodb_buffer_pool_reads 与 Innodb_buffer_pool_read_requests 之比(物理读比例),以及热点时间窗内的数据体积。
3、一个可复核的触发阈值
综合上面的分析,可以用下面这组条件来触发分库分表评审,满足任意一条就应当启动方案设计,而不是等到故障发生:
- 按当前增速推算,12 个月内单表数据量将超过"三层 B+ 树 + 行宽"计算出的上限,且无法通过归档控制;
- 峰值写入 TPS 持续超过压测得到的单主库安全水位(通常取压测极限值的 50%~60%);
- 单实例数据量超过 1TB~2TB,全量恢复时长超出 RTO 要求;
- 大表 DDL 耗时超过一个变更窗口。
二、拆分方式全景:垂直、水平与组合演进
确定要拆之后,第二个问题是怎么拆。所有拆分方式都可以归到两个正交的维度里:按列(业务)切,还是按行(数据)切;切的对象是库,还是表。
(一)垂直拆分:按业务边界切
垂直拆分的本质是"把不相干的东西分开放",它不改变单张表的数据量,但能分摊实例压力、隔离故障域。
1、垂直分库
把用户、商品、订单、支付这些业务域的表分别放到独立的数据库(通常也是独立的实例)中。它和微服务拆分天然契合:每个服务只访问自己的库,跨域数据通过接口获取而不是跨库 JOIN。垂直分库落地的前提是业务边界清晰,否则会出现大量跨库关联,把问题转移到应用层。
2、垂直分表
把一张宽表按访问频率拆成主表和扩展表。例如商品表里的名称、价格、状态访问频繁,而长描述、规格参数等大字段很少读取,拆成 t_product 与 t_product_ext 后,主表行宽变小,一页能存更多行,Buffer Pool 能缓存更多热数据。上一节的计算已经说明,行宽从 1KB 降到 300B,三层树容量能提升三倍多——垂直分表是被低估的"免费扩容"。
(二)水平拆分:按数据行切
水平拆分把同一张逻辑表的数据按某种规则分散到多个物理表中。只拆表不拆库(水平分表)可以解决单表过大,但所有表仍在同一个实例上,写入与连接瓶颈没有缓解;拆到多个库(水平分库)才能真正横向扩展写入能力。生产上最常见的是"分库 + 分表"两级结构,例如 8 个库、每库 64 张表:库解决吞吐,表解决单表体积,而且表的数量为日后扩容预留了搬迁单位。

水平拆分的代价全部来自"数据不在一起了":没有分片键的查询需要广播到所有分片;排序、分页、聚合需要在应用层归并;跨分片的写入需要分布式事务;唯一约束只能在分片内保证。后文第七节会逐一给出解法,但读者此刻应当意识到:水平拆分的方案质量,几乎完全取决于分片键选得好不好。
(三)从单库到分片集群的演进路径
实际项目里,拆分很少一步到位,而是随着业务阶段逐步演进:
1. 单库单表:业务初期,一切从简;
2. 读写分离:读流量增长,一主多从;
3. 垂直分库:业务域增多,按服务拆库;
4. 水平分表:核心大表单表过大,先在库内分表;
5. 水平分库分表:写入瓶颈出现,分库分表并引入分片中间件;
6. 单元化或分布式数据库:多地域、多活或极致规模时的进一步选择。

这条路径给出的一个重要启示是:在第四步时就按第五步的方式设计。 例如在库内分 64 张表时,就把"槽位 → 库"的映射抽象出来,哪怕当前只有一个库;这样当写入瓶颈到来时,分库只是把一部分槽位搬到新实例,而不是重新做一次数据重分布。
三、分片键与路由算法:方法论的核心
分片键决定数据怎么分布,路由算法决定分片键如何映射到物理位置。这两个选择一旦上线就极难更改,是整个方案中最需要慎重的部分。
(一)分片键的选择准则
1、五条准则
准则一:覆盖核心查询。 分片键必须出现在绝大多数高频查询的 WHERE 条件中,否则这些查询都会变成全分片广播。评估时应当把线上 SQL 按执行次数排序,统计 Top N 查询中分片键的覆盖率,目标是 90% 以上。
准则二:分布均匀。 分片键的取值要足够离散,不能有明显的热点值。以商家 ID 分片的电商订单表就是反例:头部大商家的订单量可能是长尾商家的上万倍,会造成严重的数据倾斜和热点分片。
准则三:不可变。 分片键一旦写入就不应再修改。修改分片键意味着数据要从一个分片迁到另一个分片,这是一次跨分片的"删除 + 插入",需要分布式事务保护。
准则四:事务边界内聚。 需要在同一个事务中修改的数据,应当落在同一个分片上。例如订单主表和订单明细都按 user_id 分片,一次下单的写入就是一个本地事务。
准则五:面向未来的查询。 除了当前查询,还要考虑未来一两年可能出现的访问模式,例如是否会有"按商家查询订单"的 B 端需求,这决定了是否需要提前规划异构索引。
2、以订单系统为例做一次评估
订单系统通常有三个候选分片键:订单号、用户 ID、商家 ID。C 端最高频的查询是"我的订单列表"和"订单详情",B 端是"商家订单管理",运营侧是"按时间统计"。
| 候选分片键 | 我的订单列表 | 订单详情 | 商家订单管理 | 分布均匀度 | 结论 |
|---|---|---|---|---|---|
| 订单号 | 需广播 | 单分片 | 需广播 | 均匀 | 列表查询不可接受 |
| 用户 ID | 单分片 | 需映射或基因 | 需异构索引 | 较均匀 | 推荐 |
| 商家 ID | 需广播 | 需映射 | 单分片 | 严重倾斜 | 不推荐 |
用户 ID 胜出的原因是它覆盖了 C 端最核心、量最大的查询,同时"订单详情只有订单号"这个缺口可以通过第四节的基因法补上,而 B 端的商家查询则交给异构的检索引擎或按商家分片的冗余表承接。

(二)四类路由算法的取舍
1、哈希取模
shard = hash(key) % N,分布均匀、实现简单、点查高效,是互联网业务最常用的方式。它的缺点在扩容:N 变成 N+1 时,绝大部分数据的归属都会改变。配套工程的实测显示,从 4 个分片扩到 5 个,需要搬迁 80% 的数据;如果坚持翻倍扩容(4 → 8),搬迁比例降为 50%,而且每条数据只会从分片 i 搬到分片 i+4,搬迁路径是确定的。
2、范围分片
按分片键的取值区间划分,例如按月份分表、按用户 ID 每 1000 万一段。优点是扩容天然友好(新数据落新表,老数据不动)、范围查询只命中少数分片;缺点是写入热点集中在最新的分片上。它最适合流水、日志、归档这类"按时间写、按时间查、按时间删"的数据,不适合作为高并发交易表的唯一分片方式。
3、一致性哈希与虚拟槽
一致性哈希把节点和数据都映射到同一个哈希环上,数据归属于顺时针方向的第一个节点,增删节点只影响相邻区间。配套工程用 160 个虚拟节点测试从 4 个节点扩到 5 个,只需搬迁 18.3% 的数据,接近理论值 1/5。Redis Cluster 采用的是它的一种变体——固定的 16384 个哈希槽,节点只是槽的持有者。
数据库分片场景更推荐"固定槽位 + 映射表"而不是纯一致性哈希。 原因有三:一是槽位固定后,"某条数据在哪"可以直接计算和审计,而一致性哈希的归属依赖环上的节点分布;二是槽位是天然的搬迁单位,可以按槽做数据迁移、按槽做灰度切换;三是槽位可以嵌入业务 ID(见基因法),一致性哈希的环坐标做不到这一点。本文后续的全部代码都采用固定槽位方案。
4、目录映射
维护一张"分片键 → 分片"的映射表,路由时先查表。它最灵活,可以对单个大客户做单独的分片安排,但映射表本身成为关键依赖,需要高可用与缓存。实践中常把它与哈希结合:绝大多数数据按哈希路由,少数特殊租户走映射表覆盖。

(三)库表两级路由的倾斜陷阱
"分库 + 分表"时,一个极其常见的错误写法是分别对库数和表数取模:
int db = (int) (userId % 2); // 2 个库
int table = (int) (userId % 4); // 每库 4 张表
直觉上这会均匀地用满 2 × 4 = 8 张表,但配套工程跑出来的结果是:
db = id%2, table = id%4 : ds0=[250000, 0, 250000, 0] ds1=[0, 250000, 0, 250000]
先算全局槽位再拆库表 : [125555, 124699, 125126, 124673, 124809, 125004, 124870, 125264]
8 张表里只有 4 张有数据。原因是库数 2 和表数 4 有公因子:userId % 2 == 0 的数据,其 userId % 4 只可能是 0 或 2。正确做法是先把分片键映射到全局槽位 slot = hash(key) % (库数 × 每库表数),再用 db = slot / 每库表数 推导库号、用 slot % 每库表数(或直接用全局槽位编号)推导表号。

另一个隐蔽的倾斜来源是分片键本身的规律。如果用户 ID 是按步长发放的(例如多个发号节点各自以固定步长递增),或者订单号末位受生成算法影响总是偶数,直接取模也会倾斜。配套代码在取模前先做一次 MurmurHash3 的 fmix64 混淆,把任何规律打散:
public int slotOf(long shardingKey) {
return (int) (fmix64(shardingKey) & slotMask); // slotMask = 总表数 - 1
}
static long fmix64(long k) {
k ^= k >>> 33;
k *= 0xff51afd7ed558ccdL;
k ^= k >>> 33;
k *= 0xc4ceb9fe1a85ec53L;
k ^= k >>> 33;
return k;
}
总表数是 2 的幂时,& slotMask 等价于取模但更快,这也是分片数量建议取 2 的幂的原因之一。
(四)分片数量规划
分片数量要从数据量和写入量两个维度分别计算,取较大者,再向上取 2 的幂。以一个日增 300 万订单、热数据保留 3 年、峰值写入 12000 TPS 的订单系统为例:
- 按数据量:300 万 × 365 × 3 ≈ 32.85 亿行,单表目标取 1000 万行(窄表、三层 B+ 树且留有余量),需要约 329 张表,向上取 2 的幂为 512 张;
- 按写入量:压测得到单主库安全写入 2000 TPS,12000 ÷ 2000 = 6,向上取 2 的幂为 8 个库;
- 组合:8 库 × 64 表 = 512 张物理表。
配套的 CapacityPlanner.plan 输出与手算一致:
按数据量需要分表 512 张;按写入峰值需要分库 8 个;建议 8 库 × 64 表 = 512 张物理表
这里还有一个关键设计:逻辑库与物理实例解耦。8 个逻辑库在初期完全可以部署在 2 个物理实例上(每个实例 4 个库)。当写入压力增长时,把其中 4 个逻辑库整体迁到新实例,只需要修改数据源配置里的 JDBC 地址,路由算法、表名、业务 ID 里的基因全部不变。这比"先建 2 个库、以后再拆"要从容得多——分片数量一次规划到位,物理资源按需投入。

四、全局唯一ID:分布式主键的选型与实现
分片之后,数据库自增主键不再可用:每个分片各自从 1 开始自增,主键会重复。设置不同的起始值与步长可以勉强规避,但扩容时步长无法调整。因此需要一个全局唯一、趋势递增、高性能的 ID 生成方案。
(一)五种方案对比
| 方案 | 唯一性 | 有序性 | 性能 | 依赖 | 主要问题 |
|---|---|---|---|---|---|
| UUID | 全局唯一 | 无序 | 本地生成极快 | 无 | 36 字符太长,无序写入导致页分裂 |
| 数据库号段 | 唯一 | 趋势递增 | 批量取号后很快 | 数据库 | 号段表是单点,需双号段预加载 |
| Redis INCR | 唯一 | 严格递增 | 快 | Redis | 持久化丢数据时可能重复 |
| Snowflake | 唯一 | 趋势递增 | 本地生成极快 | 时钟、workerId | 时钟回拨、workerId 分配 |
| 美团 Leaf | 唯一 | 趋势递增 | 快 | 数据库或 ZooKeeper | 需要独立部署发号服务 |
对于主键来说,有序性很重要。InnoDB 的聚簇索引按主键排序存储,趋势递增的主键总是追加到最右侧叶子页,而 UUID 这种随机主键会让插入散落在整棵树上,频繁引发页分裂和随机 IO。Java 8 项目里最常见的选择是 Snowflake(本地生成、零依赖)或 Leaf 的号段模式(有序、可读性好)。
(二)Snowflake的工程细节
Snowflake 的经典位布局是:1 位符号位 + 41 位毫秒时间戳 + 10 位工作节点 + 12 位序列号。41 位毫秒时间戳可用约 69 年,10 位节点支持 1024 个实例,12 位序列号支持单节点每毫秒 4096 个 ID。原理简单,但生产实现有三个细节必须处理。
1、时钟回拨
NTP 校时或虚拟机迁移可能让系统时钟回退。如果不处理,同一毫秒可能被使用两次,产生重复 ID。配套实现的策略是:回拨在容忍阈值(默认 5ms)以内时等待追平,超过阈值直接拒绝发号——宁可发号失败,也绝不发出重复 ID:
private long waitForClockCatchUp(long now) {
long offset = lastMs - now;
if (offset > maxBackwardMs) {
throw new IllegalStateException("时钟回拨 " + offset + "ms,超过容忍阈值,拒绝发号");
}
try {
TimeUnit.MILLISECONDS.sleep(offset << 1);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("等待时钟追平时被中断", e);
}
long retry = clock.getAsLong();
if (retry < lastMs) {
throw new IllegalStateException("时钟回拨未恢复,拒绝发号");
}
return retry;
}
时钟来源通过 LongSupplier 注入,单元测试里可以直接模拟回拨场景并断言拒绝发号。更彻底的方案是像 Leaf 那样,把每个节点最近一次的时间戳定期上报到 ZooKeeper,启动时校验本机时间不早于上报值。
2、workerId分配
workerId 重复是比时钟回拨更隐蔽的问题:两个实例用了同一个 workerId,在同一毫秒内就可能生成相同的 ID。容器化部署下,实例的 IP 和主机名都是动态的,靠配置文件写死 workerId 很容易出错。常见做法有三种:K8s StatefulSet 的序号、启动时向 Redis 或 ZooKeeper 申请一个带租约的编号、或者从数据库里抢占一个编号并定期续期。需要特别提醒的是,ShardingSphere 5.x 起,内置 Snowflake 的 worker-id 不再在算法属性里配置,Standalone 模式下固定为 0,多实例部署必须使用 Cluster 模式由注册中心分配。
3、低并发下的末位倾斜
如果每毫秒的序列号都从 0 开始,低并发时大部分 ID 的序列号都是 0,ID 的低位几乎恒定。一旦有人直接用 orderId % 表数 做路由,数据会严重集中到少数几张表。配套实现把每毫秒的起始序列号随机化为 0~3,同时在路由层先做哈希混淆,从两端同时规避这个问题。
(三)基因法:让订单号自带路由信息
按用户 ID 分片后,"只有订单号"的查询(例如支付回调、客服按单号查询)就无法直接路由。最直接的办法是建一张"订单号 → 用户 ID"的映射表,但这多了一次查询和一份需要维护一致性的数据。
基因法的思路是:既然订单号是我们自己生成的,那就在生成时把用户 ID 算出的槽位嵌进订单号的低位。 分片总数为 512 时槽位需要 9 位、1024 时需要 10 位,这些位就是订单号的"基因"。按订单号查询时,取低位即得槽位,路由结果与按用户 ID 完全一致。
配套的 GeneIdGenerator 采用"41 位毫秒时间戳 + 7 位节点 + 5 位序列 + N 位基因"的布局,基因位宽由分片规则决定:
public synchronized long nextId(int slot) {
long now = clock.getAsLong();
if (now < lastMs) {
throw new IllegalStateException("时钟回拨 " + (lastMs - now) + "ms,拒绝发号");
}
if (now == lastMs) {
sequence = (sequence + 1) & SEQ_MASK;
if (sequence == 0) {
while (now <= lastMs) {
now = clock.getAsLong();
}
}
} else {
sequence = 0;
}
lastMs = now;
int shift = geneBits;
long id = slot; // 最低 geneBits 位:槽位基因
id |= sequence << shift;
shift += SEQ_BITS;
id |= workerId << shift;
shift += WORKER_BITS;
id |= (now - SnowflakeIdGenerator.EPOCH) << shift;
return id;
}
运行结果验证了路由一致性:
按 user_id=10086 路由 : slot=452 -> ds_07.t_order_0452
生成订单号 181807914491625924 , 按订单号路由 : slot=452 -> ds_07.t_order_0452
两者落在同一张表 : true

基因法有三个必须想清楚的约束。第一,基因位挤占了节点位与序列位:上述布局单节点每秒约 3.2 万个 ID、128 个节点合计约 400 万个,对订单类业务绰绰有余,但对日志类超高频写入就不合适了。第二,基因位宽决定了分片数量的上限:10 位基因最多支持 1024 个槽位,所以分片数量规划必须一次到位,后续扩容只能在槽位之内搬迁,不能增加槽位。第三,基因必须来自"槽位"而不是原始用户 ID 的低位,这样路由层可以自由选择哈希函数,基因与路由永远口径一致。
五、代码实操一:不依赖中间件手写分片路由层
在引入 ShardingSphere 之前,先手写一个轻量的路由层是非常值得的:它让团队真正理解"一条 SQL 从业务方法出发,是如何落到某个库的某张表上的",也能帮助判断什么时候中间件是必需的。配套工程的 sharding-handwritten 模块基于 Spring Boot 2.7 + MyBatis,总代码量不到 400 行。
(一)整体结构与调用链
手写方案由四个组件组成,各自只负责一件事:
@ShardBy注解与切面:声明方法按哪个参数路由,在方法执行前算出路由目标并压入上下文;ShardContextHolder:基于 ThreadLocal 的路由上下文,用栈结构支持嵌套调用;ShardRoutingDataSource:继承 Spring 的AbstractRoutingDataSource,在获取连接时按上下文选择逻辑库;TableShardInterceptor:MyBatis 插件,在 SQL 预编译前把逻辑表名改写为物理表名。
一次 createOrder(userId, ...) 调用的完整链路是:切面解析 userId → 路由器算出槽位 452 → 上下文压入 ds_07 / t_order_0452 → 事务拦截器开启事务并获取连接,路由数据源返回 ds_07 的连接 → MyBatis 执行 INSERT INTO t_order,拦截器改写为 t_order_0452 → 方法返回,切面弹出上下文。

手写分片路由层的调用链
(二)路由核心:分片规则与槽位计算
路由核心放在零依赖的 sharding-core 模块中,手写方案、ShardingSphere 方案、ID 生成器三者共用,这是保证"算槽位的口径全系统唯一"的工程手段。ShardingRule 描述一张逻辑表的规则,强制库数和每库表数都是 2 的幂:
public ShardingRule(String logicTable, int dbCount, int tablesPerDb, String dataSourcePrefix) {
if (!isPowerOfTwo(dbCount) || !isPowerOfTwo(tablesPerDb)) {
throw new IllegalArgumentException("dbCount 与 tablesPerDb 必须是 2 的幂: " + dbCount + ", " + tablesPerDb);
}
...
}
/** 由全局槽位推导库号:连续的 tablesPerDb 个槽位落在同一个库。 */
public int dbIndexOf(int slot) {
return slot / tablesPerDb;
}
public String physicalTableOf(int slot) {
return logicTable + "_" + String.format("%04d", slot);
}
这里有一个值得展开的命名决策:物理表按全局槽位编号(t_order_0000 到 t_order_0511),而不是每个库里都从 t_order_0 开始。全局编号的好处是表名在整个集群内唯一,某张表从 ds_03 搬到 ds_11 时名字不变,扩容只需修改"槽位 → 库"的映射;排查问题时看到表名就能反推槽位和基因。代价是每个库里的表名不连续,配置时需要用生成器而不是简单的区间表达式。后文 ShardingSphere 示例采用了库内编号,两种方式可以对照理解。
ShardRouter 负责把分片键翻译为路由目标,同时提供按基因路由与全路由两个入口:
public ShardTarget routeBySlot(int slot) {
int db = rule.dbIndexOf(slot);
return new ShardTarget(slot, db, slot, rule.dataSourceKeyOf(db), rule.physicalTableOf(slot));
}
public ShardTarget route(long shardingKey) {
return routeBySlot(slotOf(shardingKey));
}
public ShardTarget routeByGeneId(long geneId) {
return routeBySlot((int) (geneId & slotMask));
}
/** 不带分片键时只能全路由(广播扫描),调用方应当把它当作需要审批的"昂贵操作"。 */
public List<ShardTarget> allTargets() { ... }
(三)数据源路由:AbstractRoutingDataSource
Spring 的 AbstractRoutingDataSource 是实现多数据源路由最标准的扩展点:它持有一组目标数据源,每次 getConnection() 时调用 determineCurrentLookupKey() 决定使用哪一个。
public class ShardRoutingDataSource extends AbstractRoutingDataSource {
private final boolean strict;
@Override
protected Object determineCurrentLookupKey() {
ShardTarget target = ShardContextHolder.peek();
if (target != null) {
return target.getDataSourceKey();
}
if (strict) {
throw new IllegalStateException("缺少分片路由上下文:请在入口方法上声明 @ShardBy,或显式访问非分片数据源");
}
return null;
}
}
两个细节决定了这个类是否可靠。第一,严格模式。 没有路由上下文时,默认实现会落到默认数据源,这意味着一条忘记声明分片键的 SQL 会悄悄写进某个库,数据从此"失踪"。严格模式下直接抛异常,问题在测试阶段就会暴露;装配时同时设置 setLenientFallback(false),防止找不到键时回退到默认库。第二,连接获取时机。 determineCurrentLookupKey() 只在获取连接的那一刻被调用,Spring 事务开启后连接会绑定到线程上,整个事务内复用。因此路由上下文必须在事务开始之前设置好,并且一个事务只能落在一个库里——这正是分片键选择准则中"事务边界内聚"的代码级体现。
数据源装配时,逻辑库名称作为查找键,每个逻辑库一个 Hikari 连接池:
@Bean
@Primary
public DataSource dataSource(ShardingProperties props, ShardRouter router) {
int expected = router.getRule().getDbCount();
if (props.getDataSources().size() != expected) {
throw new IllegalStateException("逻辑库数量与分片规则不一致: 配置 " + props.getDataSources().size()
+ " 个, 规则需要 " + expected + " 个");
}
Map<Object, Object> targets = new HashMap<>(expected * 2);
props.getDataSources().forEach((name, node) -> targets.put(name, build(name, node)));
ShardRoutingDataSource routing = new ShardRoutingDataSource(true);
routing.setTargetDataSources(targets);
routing.setLenientFallback(false);
routing.afterPropertiesSet();
return routing;
}
需要注意连接池总量:8 个逻辑库 × 每库 20 个连接 × 应用实例数,就是数据库侧需要承受的连接数。逻辑库部署在同一物理实例上时,这些连接会叠加到一个实例上,连接池上限要按物理实例反推,而不是按逻辑库拍脑袋。
(四)表名改写:MyBatis拦截器
库选好之后,还要把 SQL 里的逻辑表名换成物理表名。MyBatis 的 StatementHandler.prepare 是最合适的拦截点:此时 SQL 已经完成动态拼接,还没有发给数据库。
@Intercepts(@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class}))
public class TableShardInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
ShardTarget target = ShardContextHolder.peek();
if (target == null) {
return invocation.proceed();
}
MetaObject meta = SystemMetaObject.forObject(invocation.getTarget());
while (meta.hasGetter(PROXY_TARGET)) { // 多个插件时逐层剥开代理
meta = SystemMetaObject.forObject(meta.getValue(PROXY_TARGET));
}
String sql = (String) meta.getValue(SQL_PATH); // delegate.boundSql.sql
String rewritten = rewrite(sql, target.getSlot());
if (!rewritten.equals(sql)) {
meta.setValue(SQL_PATH, rewritten);
}
return invocation.proceed();
}
String rewrite(String sql, int slot) {
String out = sql;
for (Map.Entry<String, Pattern> e : logicTables.entrySet()) {
String physical = String.format("%s_%04d", e.getKey(), slot);
out = e.getValue().matcher(out).replaceAll(Matcher.quoteReplacement(physical));
}
return out;
}
}
同一组绑定表(t_order 与 t_order_item)使用相同的槽位后缀,所以它们之间的 JOIN 永远发生在同一个库的同号表之间。改写使用了带词边界的正则,单测验证了两个关键行为:JOIN 两张绑定表时后缀一致,列名中包含逻辑表名(如 t_order_flag)时不会被误改。
SELECT o.order_id FROM t_order o JOIN `t_order_item` i ON ...
→ SELECT o.order_id FROM t_order_0017 o JOIN t_order_item_0017 i ON ...
正则改写不是完整的 SQL 解析:逻辑表名出现在字符串常量中、或者 SQL 里有子查询引用了别的分片表时,它都可能出错。这正是手写方案的天花板,也是生产上倾向引入 SQL 解析型中间件的核心原因之一。
(五)声明式入口:@ShardBy切面
最后,用一个注解把路由声明到业务方法上,业务代码里看不到任何路由逻辑:
@ShardBy(param = "userId")
@Transactional(rollbackFor = Exception.class)
public long createOrder(long userId, long skuId, int quantity, BigDecimal price) {
int slot = router.slotOf(userId);
long orderId = idGenerator.nextId(slot); // 基因法订单号
...
orderMapper.insert(order);
orderMapper.insertItem(item); // 绑定表,同库同事务
return orderId;
}
@ShardBy(param = "orderId", gene = true)
public OrderDO getOrder(long orderId) {
return orderMapper.findById(orderId);
}
切面的实现中,@Order(Ordered.HIGHEST_PRECEDENCE) 这一行至关重要:路由切面必须包在事务切面的外层。如果顺序反过来,事务拦截器会先获取连接,此时路由上下文还没有设置,严格模式下直接报错,非严格模式下则会写错库。
@Aspect
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class ShardRouteAspect {
@Around("@annotation(shardBy)")
public Object route(ProceedingJoinPoint pjp, ShardBy shardBy) throws Throwable {
Object key = resolveKey(pjp, shardBy.param());
ShardContextHolder.push(toTarget(key, shardBy.gene()));
try {
return pjp.proceed();
} finally {
ShardContextHolder.pop();
}
}
}
上下文用栈而不是单值,是为了支持嵌套调用:用户 A 的方法里调用了用户 B 的方法,内层结束后必须恢复 A 的路由,而不是简单清空。跨线程场景(线程池、CompletableFuture、MQ 回调)不会自动继承 ThreadLocal,配套代码提供了 ShardContextHolder.wrap(Runnable),在提交线程捕获上下文、在执行线程恢复。
(六)手写方案的适用边界
手写方案的优势是透明、可控、零额外依赖,路由逻辑一目了然,出了问题可以直接断点调试。它适合以下场景:分片表数量少、查询模式简单且几乎总带分片键、团队希望完全掌控路由行为。
但它的能力边界同样清晰:不支持跨分片查询(没有分片键的 SQL 需要业务代码自己遍历 allTargets() 并归并)、不支持跨库事务、SQL 改写不理解语法。当业务出现"后台按条件统计""运营批量导出""多分片分页"等需求时,手写方案会迅速膨胀成一个半成品中间件。这时就该考虑 ShardingSphere 了。
六、代码实操二:基于ShardingSphere-JDBC落地
ShardingSphere 是 Apache 顶级项目,其中的 ShardingSphere-JDBC 以 JAR 包形式工作在应用侧,对外暴露为一个标准的 javax.sql.DataSource,上层的 MyBatis、JPA、JdbcTemplate 都无需修改。它与 ShardingSphere-Proxy(独立部署的数据库代理)共享同一套内核。
(一)版本选择与依赖
Java 8 项目选型时有两条版本线需要对齐:Spring Boot 2.7.x 是最后一条支持 Java 8 的主线;ShardingSphere 5.2.1 是最后一个提供 shardingsphere-jdbc-core-spring-boot-starter 的版本,5.3.0 起统一改为 ShardingSphereDriver + 独立 YAML 文件的接入方式。对于存量 Spring Boot 2.x 项目,5.2.1 的 Starter 接入成本最低。
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
<version>5.2.1</version>
</dependency>
5.2.1 依赖的 snakeyaml 需要与 Spring Boot 2.7 对齐到 1.33,否则启动时会出现 NoSuchMethodError,配套工程在 POM 中显式固定了 snakeyaml.version。如果新项目选择 5.3 以上版本,配置的整体结构基本一致,但需要把规则写进独立的 YAML 文件,并以 jdbc:shardingsphere:classpath:xxx.yaml 作为 JDBC URL。
(二)执行流程:解析、路由、改写、执行、归并
理解 ShardingSphere 的内核流程,是写好分片算法和排查问题的前提。一条逻辑 SQL 会依次经过五个阶段:
1. SQL 解析:把 SQL 解析成抽象语法树,提取表名、分片条件、排序、分组、分页等上下文;
2. SQL 路由:根据分片条件调用分片算法,计算出需要访问的数据节点,分为单片路由、多片路由、广播路由;
3. SQL 改写:把逻辑表名改为物理表名,并做必要的补列(例如 ORDER BY 的列不在查询结果里时自动补上)、分页修正(LIMIT 10, 10 在多分片时改写为 LIMIT 0, 20);
4. SQL 执行:按"连接模式"和"内存限制模式"自动选择执行策略,在连接数和内存之间平衡;
5. 结果归并:对多分片结果做遍历、排序、分组、聚合、分页归并,最终以一个 ResultSet 返回给上层。

ShardingSphere-JDBC的执行流程
这张流程图也解释了为什么手写方案的正则改写不可靠:ShardingSphere 在改写之前先做了完整的语法解析,它知道哪个标识符是表名、哪个是列名,也知道分页和排序在多分片时需要怎么修正。
(三)YAML配置:数据节点、绑定表与广播表
配套工程采用 4 库 × 8 表的示例规模(槽位 32 个,订单号基因 5 位),核心配置如下:
spring:
shardingsphere:
datasource:
names: ds_0,ds_1,ds_2,ds_3,ds_archive
ds_0:
type: com.zaxxer.hikari.HikariDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
jdbc-url: jdbc:mysql://${MYSQL_A_HOST:127.0.0.1}:3306/order_0?useSSL=false&serverTimezone=Asia/Shanghai
username: ${DB_USER:order_rw}
password: ${DB_PASSWORD:}
# ds_1 ~ ds_3、ds_archive 同理
rules:
sharding:
tables:
t_order:
actual-data-nodes: ds_$->{0..3}.t_order_$->{0..7}
database-strategy:
complex:
sharding-columns: user_id,order_id
sharding-algorithm-name: slot-db
table-strategy:
complex:
sharding-columns: user_id,order_id
sharding-algorithm-name: slot-table
t_order_item:
actual-data-nodes: ds_$->{0..3}.t_order_item_$->{0..7}
# 策略与 t_order 相同
binding-tables:
- t_order,t_order_item
broadcast-tables:
- t_region
sharding-algorithms:
slot-db:
type: CLASS_BASED
props:
strategy: COMPLEX
algorithmClassName: com.example.sphere.algorithm.SlotComplexShardingAlgorithm
target: db
db-count: 4
tables-per-db: 8
slot-table:
type: CLASS_BASED
props:
strategy: COMPLEX
algorithmClassName: com.example.sphere.algorithm.SlotComplexShardingAlgorithm
target: table
db-count: 4
tables-per-db: 8
props:
sql-show: ${SQL_SHOW:false}
有几个配置项需要重点理解:
actual-data-nodes:用行表达式描述逻辑表对应的全部物理节点,ds_$->{0..3}.t_order_$->{0..7}展开为 32 个节点。这里采用库内编号,每个库都有t_order_0到t_order_7,配置直观,代价是表名在集群内不唯一;binding-tables:声明主表与明细是绑定表。未声明时,t_order与t_order_item的 JOIN 会被当作两张独立分片表,产生笛卡尔积式的路由(8 × 8 = 64 条 SQL);声明后只路由到同号表对;broadcast-tables:地区、字典这类小而稳定的维表,在每个库都存一份完整副本,写入时广播到所有库,查询时任选一个库,使它能与分片表在库内 JOIN;sql-show:打开后日志中会同时打印逻辑 SQL 与改写后的实际 SQL,是开发联调阶段最有用的排查手段,生产环境建议关闭。
使用 CLASS_BASED 类型可以直接引用自定义算法类,不需要编写 SPI 注册文件;数据库密码全部通过环境变量注入,配置文件里不出现任何真实凭据。
(四)自定义复合分片算法
内置的 INLINE 算法(例如 ds_$->{user_id % 4})只能处理单一分片列,而我们的订单表需要同时支持"按用户 ID"和"只按订单号"两种路由,这就需要复合分片算法 ComplexKeysShardingAlgorithm:
public final class SlotComplexShardingAlgorithm implements ComplexKeysShardingAlgorithm<Comparable<?>> {
@Override
public void init(Properties properties) {
this.forDb = TARGET_DB.equals(properties.getProperty("target", TARGET_DB));
int dbCount = Integer.parseInt(properties.getProperty("db-count"));
this.tablesPerDb = Integer.parseInt(properties.getProperty("tables-per-db"));
this.router = new ShardRouter(new ShardingRule("t_order", dbCount, tablesPerDb, "ds_"));
}
@Override
public Collection<String> doSharding(Collection<String> availableTargetNames,
ComplexKeysShardingValue<Comparable<?>> shardingValue) {
Map<String, Collection<Comparable<?>>> values = shardingValue.getColumnNameAndShardingValuesMap();
Set<Integer> slots = new LinkedHashSet<>();
Collection<Comparable<?>> userIds = values.get(USER_ID);
Collection<Comparable<?>> orderIds = values.get(ORDER_ID);
if (userIds != null && !userIds.isEmpty()) {
for (Comparable<?> v : userIds) {
slots.add(router.slotOf(toLong(v))); // 按用户哈希
}
} else if (orderIds != null && !orderIds.isEmpty()) {
for (Comparable<?> v : orderIds) {
slots.add(router.routeByGeneId(toLong(v)).getSlot()); // 取订单号基因
}
} else {
return availableTargetNames; // 无分片键:全路由
}
Set<String> result = new LinkedHashSet<>();
for (int slot : slots) {
int index = forDb ? slot / tablesPerDb : slot % tablesPerDb;
String hit = matchBySuffix(availableTargetNames, index);
if (hit != null) {
result.add(hit);
}
}
return result;
}
}
这个算法有三处设计值得借鉴。第一,一个类同时承担库策略和表策略,通过 target 属性区分,保证两层的槽位计算口径永远一致,避免"库按一种算法、表按另一种算法"导致的错位。第二,槽位计算复用 sharding-core 的 ShardRouter,与 ID 生成器共用同一套哈希,这是基因法成立的前提。第三,目标名按 _序号 后缀精确匹配,避免 t_order_1 误命中 t_order_11 这类字符串前缀问题。
IN 查询会带来多个分片值,例如 WHERE user_id IN (1, 2, 3),算法会收集所有值对应的槽位并去重,最终只路由到这些槽位所在的节点。配套单测验证了"只带订单号"与"只带用户 ID"两种路由结果完全一致。
(五)按月范围分表
流水、日志、操作记录这类数据更适合按时间范围分表:写入永远落在当月表,查询通常带时间区间,过期数据可以整表删除(DROP TABLE 比 DELETE 快几个数量级,且不产生碎片)。配套工程对 t_order_log 使用了标准分片算法 StandardShardingAlgorithm,它要求同时实现精确值与区间两种路由:
@Override
public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Comparable<?>> value) {
String suffix = "_" + toMonth(value.getValue()).format(SUFFIX); // 例如 _202609
for (String name : availableTargetNames) {
if (name.endsWith(suffix)) {
return name;
}
}
throw new IllegalStateException("没有可用的月表: " + value.getLogicTableName() + suffix);
}
@Override
public Collection<String> doSharding(Collection<String> availableTargetNames,
RangeShardingValue<Comparable<?>> value) {
Range<Comparable<?>> range = value.getValueRange();
YearMonth[] bounds = boundsOf(availableTargetNames);
YearMonth from = range.hasLowerBound() ? max(toMonth(range.lowerEndpoint()), bounds[0]) : bounds[0];
YearMonth to = range.hasUpperBound() ? min(toMonth(range.upperEndpoint()), bounds[1]) : bounds[1];
... // 只展开 from ~ to 之间命中的月表
}
区间路由是范围分表的精髓:create_time >= '2026-08-01' AND create_time < '2026-10-01' 只会路由到 8 月和 9 月两张表。区间无上界或下界时,用可用表的首尾月份兜底,防止无限展开。数据节点用行表达式声明为 t_order_log_$->{2026..2027}$->{['01','02',...,'12']},每年年底前需要提前建好下一年的表并更新配置,这一步应当纳入例行运维而不是依赖人工记忆。
(六)使用中的注意事项
SQL 兼容性。 ShardingSphere 对分片表的 SQL 有一定限制:不支持跨分片的 INSERT ... SELECT、对复杂子查询和部分函数的支持有限、分片键上的函数运算(如 WHERE DATE(create_time) = ...)会导致无法提取分片条件而全路由。上线前应当把全部 Mapper 的 SQL 在测试环境打开 sql-show 跑一遍,重点检查"本应单片却走了全路由"的语句。
强制路由。 对于无法从 SQL 中提取分片键的场景(例如按槽位巡检、数据修复脚本),可以用 HintManager 在代码中直接指定分片值,配合 HINT 类型的分片策略使用;HintManager 基于 ThreadLocal,必须在 try-with-resources 中使用以确保清理。在配置了读写分离的场景下,HintManager#setWriteRouteOnly() 可以强制当前线程的读请求走主库,解决"写后立即读"的复制延迟问题。
分布式主键。 ShardingSphere 内置的 SNOWFLAKE 主键生成器适合与业务无关的主键(例如流水表的 log_id);对于需要嵌入基因的订单号,必须由应用侧生成,因为中间件的主键生成器拿不到 user_id 这样的业务上下文。
七、分片之后的查询难题与应对
分片方案上线之后,真正的挑战才开始:大量原本理所当然的查询变得昂贵甚至不可行。这一节按问题类型给出成熟的应对方案。
(一)非分片键查询
订单按用户 ID 分片后,至少还存在三类非分片键查询:按订单号查(支付回调、客服)、按商家查(B 端后台)、按手机号查(客服、风控)。
1、基因法
前文已经详述,它完美解决了"订单号 → 分片"的问题,零额外存储、零额外查询,是按订单号查询的首选。它的局限是只能嵌入一个维度的基因,无法同时服务商家、手机号等多个维度。
2、索引表
为非分片键建一张"查询键 → 分片键"的映射表,索引表本身也按查询键分片。例如 t_order_phone_index 按手机号摘要分片,存储 (phone_hash, order_id, user_id);查询时先查索引表拿到 user_id,再按 user_id 路由到订单表。索引表的写入要和主表保持一致,通常在同一业务流程里先写主表再写索引表,失败时通过补偿任务修复。注意索引表里只能存手机号的 HMAC 摘要,不能存明文,这既是安全合规要求,也不影响等值查询。
3、异构到检索引擎
对于条件组合复杂的后台查询(按商家 + 状态 + 时间范围 + 金额区间筛选),最实用的方案是通过 Canal 订阅 MySQL binlog,把订单数据异构同步到 Elasticsearch,由 ES 承担多维检索,MySQL 只承担按主键或分片键的点查。这是一种"读模型与写模型分离"的思路,代价是秒级的同步延迟,B 端后台一般可以接受。
4、冗余分片
对于量大、实时性要求高的 B 端核心查询,可以按商家 ID 再存一份完整的订单数据,形成"买家库"和"卖家库"两套分片。写入时双写(或通过 binlog 异步同步),两边各自按自己的分片键提供查询。它以存储翻倍为代价换取了两个维度都是单分片查询,在大型电商系统中很常见。

(二)跨分片分页
"按创建时间倒序查看全部订单的第 N 页"是分片后最典型的难题。数据分布在 512 张表里,任何一张表的第 N 页都不是全局的第 N 页。业界有三种主流方法。
1、全局视野法
要查第 N 页(每页 S 条),就让每个分片都返回前 N × S 条,在内存里归并排序后取第 (N-1) × S 到 N × S 条。结果精确,ShardingSphere 默认也是这样改写分页的,但代价随页码线性增长:查第 100 页时,512 个分片每个都要返回 2000 条,内存中要归并上百万条数据。它只适合分片数少、页码浅的场景。配套的 ShardPageMerger.globalView 使用小顶堆做 k 路归并,时间复杂度为 O(N log k)。
2、二次查询法
第一轮:把全局 offset 平均分给每个分片,每个分片查 LIMIT offset/k, S,找出所有结果中的最小排序值 min;第二轮:每个分片查 BETWEEN min AND 本分片第一轮的最大值,据此推算出 min 在全局的精确位置,再从归并结果中截取目标页。它把每个分片的数据量控制在 S 的量级,但需要两轮查询,且在数据分布极不均匀时实现复杂,适合"必须支持跳页、页码可能较深"的后台场景。
3、游标法(禁止跳页)
放弃"跳到第 N 页",只支持"下一页"。每次请求带上上一页最后一条记录的排序值作为游标,每个分片执行 WHERE (create_time, order_id) < (游标) ORDER BY create_time DESC, order_id DESC LIMIT S,归并后取前 S 条。无论翻到第几页,每个分片的开销都恒定为 S 条。C 端的列表页几乎都应该采用这种方式,App 的下拉刷新本来就不需要跳页。
配套工程的 Mapper 里给出了游标 SQL 的标准写法——用 (create_time, order_id) 复合游标,避免同一毫秒内的多条记录在翻页时被跳过:
SELECT order_id, user_id, amount, status, create_time FROM t_order
WHERE user_id = #{userId}
AND (create_time < #{lastTime} OR (create_time = #{lastTime} AND order_id < #{lastOrderId}))
ORDER BY create_time DESC, order_id DESC
LIMIT #{size}
两种归并方式的输出对照如下,数据分布在 3 个分片上:
全局视野法 第 3 页(每页 3 条) : [7, 8, 9]
游标法 last=6 取 3 条 : [7, 8, 9]

(三)跨分片聚合、排序与关联
聚合:COUNT、SUM、MAX、MIN 可以在各分片计算后再合并,但 AVG 必须改写为 SUM 与 COUNT 分别求和后再相除,直接对各分片的平均值求平均是错误的——ShardingSphere 会自动完成这一改写,手写方案需要自己注意。COUNT(DISTINCT) 在分片键之外的列上无法精确合并,只能全量拉取去重或借助 HyperLogLog 做近似。
排序与分组:多分片的 ORDER BY 通过归并排序实现;GROUP BY 如果分组字段与排序字段一致,可以流式归并,否则需要把全部数据加载到内存中分组,数据量大时有内存溢出风险。
关联查询:分片后应当遵循"同分片键可 JOIN,广播表可 JOIN,其他一律不 JOIN"的原则。订单与明细是绑定表,可以 JOIN;订单与地区字典,字典是广播表,可以 JOIN;订单与商品,商品在另一个垂直分库里,必须在应用层分两次查询后组装。对于统计报表这类大规模关联需求,应当同步到数仓(如 Hive、ClickHouse、Doris)中完成,不要在交易库上做。
(四)分布式事务
分布式事务是分片方案中最需要"先避免、再解决"的问题。
1、先通过设计避免
分片键选择准则中的"事务边界内聚"就是为了这个目的:下单时订单主表、明细、订单日志都按 user_id 路由到同一个库,一个本地事务就能保证原子性。据经验,合理的分片设计能让 90% 以上的写事务保持在单分片内。
2、本地消息表与最终一致
跨服务、跨库的业务流程(例如下单扣库存),最稳妥的方案是本地消息表:在订单库的同一个本地事务里写订单和一条"待发送消息",再由后台任务把消息投递到 MQ,下游消费并幂等处理。它不依赖任何额外组件,一致性由"至少一次投递 + 幂等消费"保证,是互联网业务最常用的柔性事务方案。RocketMQ 的事务消息是同一思路的中间件实现。
3、Seata AT与TCC
需要强一致语义的场景可以引入 Seata。AT 模式对业务无侵入,通过解析 SQL 生成前后镜像、在二阶段回滚时反向补偿,适合并发不高的内部系统;TCC 模式要求业务实现 Try、Confirm、Cancel 三个接口,侵入性强但性能好、可控性高,适合资金类核心链路。ShardingSphere 也提供了 XA 与 Seata 柔性事务的集成。需要清醒认识的是,任何分布式事务方案都会降低吞吐、增加故障面,它们应当是少数关键链路的"特例",而不是分片系统的默认写法。

八、平滑迁移:从单库到分片的不停机方案
对存量系统来说,分库分表最难的部分不是设计,而是在业务不停服的情况下,把几亿行数据从旧库搬到新的分片集群,并且保证一行不丢、一行不错。停机迁移方案简单,但对于 7×24 小时的交易系统几乎不可接受。下面介绍一套经过大量实践检验的五阶段不停机迁移方案。
(一)五阶段迁移全景
1. 准备阶段:搭建新分片集群、建表、部署带开关的新版本代码,开关处于"只写旧库"档位,行为与改造前完全一致;
2. 双写阶段:开关切到"双写、以旧库为准"。所有写请求同时写旧库和新库,旧库写失败则整体失败,新库写失败只记补偿;
3. 历史数据同步:把双写开启之前的存量数据批量搬到新库;搬迁过程中若遇到双写已经写入的数据,以版本号更新者为准;
4. 校验与切读:全量校验新旧两侧数据一致后,开关切到"双写、以新库为准",读流量切到新库;旧库继续跟写,作为回滚后路;
5. 下线旧库:新库稳定运行一段时间(通常一到两周,覆盖一个完整的业务周期)后,停止写旧库,归档并下线。

这个方案的核心思想是"任何时刻都有一侧是完整且正确的,且可以退回上一步"。在"以旧库为准"阶段,旧库是真相源,新库出问题随时可以废弃重来;在"以新库为准"阶段,旧库仍然在跟写,发现新库有问题时可以把读切回旧库。
(二)双写实现与开关档位
配套工程把四个开关档位建模为一个枚举,每个档位明确规定写哪一侧、以哪一侧为准,并且只允许相邻切换:
public enum MigrationPhase {
OLD_ONLY(true, false, false),
DUAL_WRITE_READ_OLD(true, true, false),
DUAL_WRITE_READ_NEW(true, true, true),
NEW_ONLY(false, true, true);
public boolean canSwitchTo(MigrationPhase target) {
return Math.abs(target.ordinal() - ordinal()) == 1;
}
}
"只允许相邻切换"这个约束非常重要:从"以新库为准"直接跳回"只写旧库",会让双写期间只写入了新库的数据在旧库中缺失。演示输出验证了越级回退会被拒绝:
越级回退被拒绝 : 只能相邻切换: DUAL_WRITE_READ_NEW -> OLD_ONLY
双写仓储的核心逻辑只有三条纪律:主侧同步写、失败即失败;从侧尽力写、失败记补偿;补偿时以主侧当前整行为准重放。
public void save(OrderRecord order) {
MigrationPhase p = phase.get();
OrderStore primary = p.newIsPrimary() ? newStore : oldStore;
OrderStore secondary = p.newIsPrimary() ? oldStore : newStore;
boolean writeSecondary = p.newIsPrimary() ? p.writeOld() : p.writeNew();
primary.upsert(order);
if (!writeSecondary) {
return;
}
try {
secondary.upsert(order);
} catch (RuntimeException e) {
LOG.log(Level.WARNING, "从侧写入失败, 记补偿 orderId=" + order.getOrderId() + ", phase=" + p, e);
compensation.record(order.getOrderId(), p);
}
}
public void replay(long orderId) {
... // 读主侧当前整行,覆盖到从侧
}
补偿重放的是"主侧的当前整行"而不是"当时的写入参数",这让补偿天然幂等:无论重放多少次、以什么顺序重放,最终结果都等于主侧的最新状态。这里刻意没有对两个库做分布式事务——双写窗口内的短暂不一致由补偿和校验来收敛,比引入分布式事务简单可靠得多。
双写有两种实现位置:应用层双写(上面的方式)逻辑清晰、可精确控制,但需要改造所有写入路径;基于 binlog 的同步双写(Canal 或 DTS 订阅旧库 binlog 写入新库)对业务无侵入,但同步是异步的,存在秒级延迟,切换写入时需要短暂停写等待追平。团队可以根据写入路径的分散程度选择,也可以组合:用 binlog 同步做历史与增量,用应用层开关做切换控制。

(三)历史数据同步
历史数据同步需要注意三点。
按主键区间分批,而不是按 LIMIT offset 分页。 WHERE id > ? ORDER BY id LIMIT 1000 这种写法每批都走主键索引,性能恒定;而 LIMIT 1000000, 1000 越往后越慢。每批写入新库时使用 INSERT ... ON DUPLICATE KEY UPDATE,并以版本号或更新时间判定谁更新,避免旧数据覆盖双写阶段已经写入的新数据。
限速与可中断。 同步任务要能按 QPS 限速,并且记录每个区间的完成进度,中断后可以从断点继续。高峰期暂停、低峰期全速是常见的调度策略。
先开双写,再同步历史。 顺序反过来会产生数据空洞:同步期间旧库新写入的数据既不在历史快照里,也没有被双写捕获。
(四)数据校验与对账
校验是迁移中最容易被轻视、却最能决定成败的环节。
1、全量校验
1.1 分段比对
按主键区间分段,每段分别从新旧两侧读取数据,逐行比较业务字段。比较金额时要用 BigDecimal.compareTo 而不是 equals,否则 10.0 与 10.00 会被判为不一致。数据量很大时,可以先对每段计算一个聚合摘要(例如 SUM(CRC32(CONCAT_WS(',', 字段...)))),摘要一致则跳过,不一致再下钻到逐行比对,能把校验时长降低一个数量级。
1.2 两轮确认
校验最常见的误报来自"正在被修改的数据":扫描旧库与扫描新库之间有时间差,这期间发生的一次更新就会表现为不一致。配套的 DataVerifier 采用两轮确认:首轮发现的差异先进入待定集合,间隔一段时间后逐条点查复核,复核仍不一致的才算真实差异。
演示中模拟了新库在双写阶段的偶发写入超时,完整过程的输出如下:
历史同步后首次校验差异 : [111:MISSING_IN_NEW, 148:MISSING_IN_NEW, 185:MISSING_IN_NEW] , 补偿队列 : [111, 148, 185]
补偿重放后再次校验差异 : []
当前档位 DUAL_WRITE_READ_NEW , 读 orderId=74 -> Order{74, user=10074, amount=99.90, status=1, v=1}
校验发现的 3 条差异与补偿队列里记录的 3 条完全吻合,说明补偿机制没有漏记;补偿重放后差异归零,才允许把读流量切到新库。校验结果与补偿记录能互相印证,是判断迁移是否可信的关键信号。
2、增量校验
全量校验完成后,还要持续对最近一段时间有更新的数据做增量校验,直到下线旧库为止。实现上可以按 update_time 扫描最近 N 分钟的变更,或者订阅 binlog 实时比对。增量校验的差异率是决定"能否进入下一阶段"的量化指标,建议阈值为连续 24 小时差异为零。
(五)切换与回滚预案
每一次档位切换都应当准备好书面的切换与回滚预案,至少包含:切换前的检查项(校验差异为零、补偿队列清空、新库监控正常)、切换操作(配置中心修改开关,灰度到部分实例再全量)、切换后的观察指标(错误率、耗时、新库负载)、回滚条件与回滚操作(退回上一档位)。
切读可以按用户维度灰度:先让 1% 的用户读新库,观察一段时间后逐步放量。由于分片键是用户 ID,可以直接用槽位做灰度单位——例如先切槽位 0~5 的读流量——这又一次体现了固定槽位作为"管理单位"的价值。
九、扩容与长期治理
分片集群上线只是开始,随着业务继续增长,扩容和日常治理会成为常态化工作。
(一)扩容:翻倍拆分与逻辑库搬迁
扩容方案的复杂度,几乎完全取决于初期的分片设计。
逻辑库搬迁是最轻量的扩容方式,也是本文推荐的设计要达成的效果。初期把 8 个逻辑库部署在 2 个物理实例上,扩容时为 ds_04~ds_07 搭建新实例作为原实例的从库,追平复制后短暂停写、切换数据源配置、断开复制,整个过程只移动库、不重新计算任何数据的路由。这种方式的扩容上限是"一个逻辑库一个实例",所以逻辑库数量要按长远的写入规模规划。
翻倍拆分适用于已经达到"一库一实例"但仍需扩容的情况。把分片数从 N 扩到 2N 时,原分片 i 的数据只会分流到 i 和 i+N 两个分片,可以利用主从复制:为每个原分片搭建一个从库,追平后把从库提升为新分片,再在两边各自删除不属于自己的一半数据。演示中 4 → 8 的实测搬迁比例为 50%,但因为是通过复制完成的,实际没有逐行搬迁的过程。
任意倍数扩容(例如 4 → 5)需要重新分布 80% 的数据,本质上等同于一次完整的数据迁移,应当尽量通过初期规划避免。

(二)监控:看槽位而不是看库
分片系统的监控粒度应当细化到槽位级别:
- 数据分布:每个槽位的行数、数据体积,识别数据倾斜;
- 访问分布:每个槽位的 QPS、慢查询数,识别热点槽位(例如某个大客户的数据恰好落在一个槽位上);
- 路由分布:单片路由、多片路由、全路由三类 SQL 的比例,全路由比例上升通常意味着有新增的查询没有带分片键;
- 迁移与同步:补偿队列积压量、异构同步(到 ES、数仓)的延迟。
其中路由分布是最有价值、也最容易被忽视的指标。建议在 SQL 审核环节就拦截不带分片键的 SQL,对确实需要全路由的后台查询建立白名单,并限制其执行频率和时间窗口。
(三)常见反模式
结合实践中反复出现的问题,以下是需要重点规避的反模式:
- 过早分片:三年后都达不到单表千万级的数据量,却在第一天就分了 1024 张表,让所有查询背上分布式的复杂度;
- 分片数量随意:取 10、20、100 这类非 2 的幂数字,导致日后无法翻倍扩容;
- 库表同模:
db = id % 库数、table = id % 表数,造成一半以上的表空置; - 分片键可变:选了会被业务修改的字段作为分片键,每次修改都是一次跨分片迁移;
- 事务跨分片:一个事务里同时修改多个用户的数据,被迫引入分布式事务;
- 无开关迁移:新代码直接切到新库,没有档位、没有回滚路径;
- 只校验条数:迁移时只比较两侧行数是否一致,忽视了内容差异;
- 忽视连接数:逻辑库 × 连接池大小 × 实例数,轻易突破数据库的连接上限。
十、结语:一张分库分表决策清单
回顾全文,分库分表是一套从决策到运维的完整方法论,代码只是其中最容易的部分。可以把它浓缩为一张决策清单,在方案评审时逐项核对:
1. 要不要拆:是否走完了 SQL 优化、读写分离、缓存、归档、垂直拆分的降级阶梯?是否用"行宽 + B+ 树层高 + 工作集"而不是经验数字论证了必要性?
2. 按什么拆:分片键是否覆盖 90% 以上的高频查询、分布均匀、不可变、事务内聚?
3. 拆成多少:是否按数据量与写入量两个维度计算、取 2 的幂、逻辑库与物理实例解耦?
4. 怎么路由:是否先算全局槽位再拆库表?是否做了哈希混淆以避免倾斜?
5. 主键怎么生成:是否处理了时钟回拨与 workerId 分配?按订单号查询是否用基因法消除了映射表?
6. 非分片键查询怎么办:索引表、异构检索、冗余分片各自承担哪类查询?
7. 分页与事务怎么办:C 端是否统一改为游标分页?跨分片写入是否通过设计规避、必要时用本地消息表?
8. 怎么迁移:是否具备档位开关、补偿队列、两轮校验与相邻回滚能力?
9. 怎么扩容与治理:扩容路径是否在设计时就已确定?监控是否细化到槽位与路由类型?

选型层面,可以用一句话概括:表少、查询简单、团队希望完全掌控时,手写路由层足够;表多、查询多样、需要跨分片能力时,选 ShardingSphere-JDBC;业务强依赖跨分片复杂查询与强一致事务时,评估分布式数据库。 无论选择哪一条路,槽位这个稳定的中间层、ID 中的基因、带档位的迁移开关,都是让系统在未来几年里"还能改得动"的关键设计。本文的全部代码均可在 Java 8 下直接编译运行,读者可以从 ShardingDemo 开始,逐个观察这些设计在数字上的效果。
参考资料
- Apache ShardingSphere 官方文档(中文)
- ShardingSphere 5.2.1 Spring Boot Starter 数据分片配置
- ShardingSphere 内核原理:解析、路由、改写、执行与归并
- Apache ShardingSphere GitHub 仓库
- MySQL 8.0 参考手册:InnoDB 索引的物理结构
- MySQL 8.0 参考手册:InnoDB Buffer Pool
- 阿里巴巴 Java 开发手册(p3c)
- Leaf——美团点评分布式 ID 生成系统
- Twitter Snowflake 项目归档
- Redis Cluster 规范:哈希槽
- Jump Consistent Hash:一种快速、低内存的一致性哈希算法
- Spring Framework:AbstractRoutingDataSource API 文档
- MyBatis 3 配置文档:插件
- Apache Seata:分布式事务解决方案
- Alibaba Canal:MySQL binlog 增量订阅与消费组件
- gh-ost:GitHub 的 MySQL 在线表结构变更工具
- Vitess 文档:分片
- TiDB 简介
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/xiaofeng10330111/article/details/170289767




