单库单表的容量问题不会在某个时刻突然出现,而是以备份窗口变长、DDL 变慢、连接数长期逼近上限这类信号逐步累积。当这些信号都已经出现、且垂直手段(优化 SQL、加缓存、读写分离、归档)都已用尽时,才轮到分片。分片把单实例的容量问题转换为分布式一致性与运维问题,因此在动手之前需要先明确它换来了什么、又放弃了什么。本文承接 mysql: 表结构变更与运维治理 中容量规划一节给出的拆分触发条件,按"起源—原理—实现—总结"展开:先界定单库单表的三条上限与拆分顺序,再逐项给出拆分方式、分片键、分片算法、路由执行、全局 ID、事务边界与迁移七类原理,最后落到选型、表设计、查询改造、ID 服务、迁移实施、扩容、运维治理与排查八个方面。

一、起源:单库单表的容量与性能边界

1.1 三条互相独立的上限

单实例的承载能力不是单一数字,而是三类资源约束中最早触发的那个。三者的成因不同,扩单机资源只能缓解其中一部分。

上限类型 触发时的表现 主要观测手段 垂直扩容能否缓解
磁盘容量 备份时长与恢复时长超出业务可接受中断窗口;磁盘余量不足以支撑一次表重建 information_schema.tables 的 data_length + index_length、备份任务的耗时趋势 只能延缓,受机型最大挂载容量与备份窗口限制
连接数与并发 空闲连接被占满、应用侧连接池等待超时、max_connections 长期接近上限 SHOW PROCESSLIST、Threads_connected、连接池的等待时长指标 部分缓解,但受线程调度与内存开销约束,连接数不能无限增加
写入吞吐 写入延迟随负载上升、redo 与 binlog 落盘成为瓶颈、从库重放持续落后 写入 QPS 与延迟曲线、磁盘 IOPS 与 iostat、主从复制延迟 受单机 CPU 核数、磁盘与网络上限约束,存在明确天花板

三条上限的独立性决定了判断顺序:容量问题要看备份与恢复窗口,连接问题要看并发模型,吞吐问题要看写放大与刷盘策略。把三者混为一谈会导致错误的扩容决策,例如在写入吞吐已到磁盘上限时继续加内存。

1.2 先优化后拆分的顺序

分片是不可逆的结构性决策,一旦落地,跨片的查询限制与一致性代价会长期存在。因此拆分前的顺序是逐级尝试,每一级都有明确的天花板:

优化层级与天花板
  一级  SQL 与索引优化
        手段:消除全表扫描、补齐联合索引、减少回表、改写深分页
        天花板:单表数据量下索引高度增长带来的固定 IO 成本,以及写入时的索引维护成本

  二级  缓存与读扩展
        手段:热点数据本地缓存与分布式缓存、多级缓存、读写分离
        天花板:写请求无法被缓存吸收;读写分离不增加写入能力,且引入复制延迟

  三级  数据生命周期治理
        手段:归档冷数据、按时间分区、冷热分离、日志类数据降低保留期
        天花板:核心业务表无法归档,活跃数据量仍然线性增长

  四级  垂直拆分
        手段:按业务域拆库、把大字段与低频字段拆表
        天花板:单一业务域内的写吞吐与数据量仍集中在同一实例

  五级  水平拆分
        手段:按分片键把同一张表的数据分散到多个实例
        代价:跨片查询、分布式事务、扩容搬迁与运维复杂度

一级与二级的手段与判读方式见 mysql: 索引与执行计划 与 缓存基本原理;二级中的读写分离只解决读并发,实现与延迟判读见 mysql: 主从部署与运维实践。跳过前面几级直接水平拆分,会把本可以被索引与缓存吸收的问题转化为分布式问题。

1.3 分片引入的复杂度清单

分片换来了容量与写吞吐的线性扩展,代价集中在以下五处,且都属于长期成本:

复杂度项 表现形式 影响面
跨片查询 不带分片键的查询需要广播到全部分片再归并;排序、分页、聚合的代价随分片数上升 SQL 写法受限,接口的实现方式需要改造
分布式事务 跨分片写入无法由本地事务覆盖,只能退化为柔性事务与补偿 一致性模型变化,需要幂等与对账机制承接
运维与扩容 备份、DDL、慢查询分析、容量巡检都从"一次操作"变为"按分片编排" 运维工具与流程需要重做,故障定位范围扩大
应用改造 路由规则、分片键传递、跨片查询改写进入业务代码或中间件 存量 SQL 与 ORM 映射需要逐条梳理
扩容搬迁 分片数变化会导致部分数据需要物理迁移,迁移期间存在双写与一致性风险 一次扩容就是一次数据迁移项目

这五项不是设计缺陷,而是共享存储被拆散后的固有结果。判断是否分片,本质上是在"单实例容量上限"与"上述长期成本"之间比较。

二、原理

2.1 拆分方式:垂直与水平

拆分按对象分为三类:垂直分库拆的是库(实例),垂直分表拆的是表(列),水平分表拆的是行。

拆分方式 拆分对象 直接收益 主要代价
垂直分库 把不同业务域的表分到不同实例 单实例容量与连接数压力下降;故障域按业务域隔离;各域可独立扩容 跨库 JOIN 消失,原本的关联查询需改为多次查询或数据冗余
垂直分表 把一张表按列拆成主表与扩展表 主表行宽变小,单页容纳行数增多,热字段的缓冲池命中率提升 查询需要按主键二次访问;写入需要跨表保持一致
水平分表 把一张表的行按分片键分散到多个表或实例 单表数据量与写吞吐可水平扩展;DDL 与备份的对象变小 跨片查询、分布式事务、扩容搬迁与路由改造全部出现

按业务域拆分与按数据量拆分

垂直拆分的方向由业务边界决定,水平拆分的方向由数据量与写入量决定。两者常常组合出现:先按业务域把强耦合的表分到同一库,再在该库内对增长最快的核心表做水平拆分。

业务域的边界应参照服务边界确定,两者的划分依据一致,否则会出现"服务已拆开但数据仍共享同一实例"的错配,服务边界的判断方式见 Spring Cloud 微服务 中拆分边界的讨论。

拆分顺序与常见组合

常见推进顺序
  1. 垂直分表:把大字段(文本、JSON、日志明细)移出主表,不动查询拓扑
  2. 垂直分库:按业务域拆分实例,先从读多写少、关联最少的域开始
  3. 水平分表:在垂直拆分后的核心库内,对单表数据量最大的表做分片
  4. 分片扩容:分片数不足时增加分片并搬迁数据

顺序的原则是:每一步都选择对查询拓扑破坏最小的动作。垂直分表不改变表之间的关联关系,风险最低;垂直分库会使跨库 JOIN 失效,需要先找出并消灭这类查询;水平分表的影响面最大,放在最后。

2.2 分片键选择

分片键决定了数据分布的均匀性与查询的命中率,是分片设计中改动成本最高的一项。

三项基本要求

  1. 高基数。分片键的取值数量需要远大于分片数,否则无论算法如何都可能出现某些分片永远为空。用状态、类型这类低基数字段做分片键时,即使取模也无法分散。
  2. 分布均匀。要求各分片的行数与写入量接近。自增主键做哈希时分布均匀,但用取值范围做分片时,最新数据会全部落入末端分片,形成写热点。
  3. 查询命中率高。绝大多数高频查询都携带分片键,才能把查询收敛到单个分片。订单表以用户 ID 为分片键、同时大量按订单号查询时,这类查询会退化为全分片广播。

三项要求之间存在取舍:以创建时间分片便于归档但写热点集中;以用户 ID 分片分布均匀,但运营侧的按时间统计需要跨全部分片。

分片键与索引的关系

分片键在分片内的索引定位中扮演的前提角色:分片表的索引建在分片内,只有先路由到分片,索引才能发挥作用。这带来两条约束:

  1. 分片键应作为分片内常用联合索引的首列,使分片内的过滤与排序能够延续使用索引,相关规则见 mysql: 索引与执行计划。
  2. 不带分片键的查询无论分片内索引多完整,都需要在每个分片上各执行一次,代价与分片数成正比。

单分片键与多分片键

单分片键只能覆盖一个查询维度,其他维度的高频查询需要额外手段:

手段 做法 适用条件与代价
基因法 把从属维度的标识位嵌入主标识,使两种维度路由到同一分片 适用于标识之间存在生成关系(如订单号由用户 ID 派生),要求标识生成逻辑可控
异构索引表 为从属维度单独建一张映射表,冗余主键与分片键,按从属维度分片 适用于查询维度固定的场景,代价是写入时需要维护第二张表并处理不一致
双写多套分片 同一份数据按两种分片键各存一份 写入放大一倍,一致性维护复杂,一般只在读多写少的字典类数据上使用

用户维度与商家维度的冲突

电商类业务天然存在两个查询主体:终端用户查自己的订单,商家查自己店铺的订单。以用户 ID 分片时,商家侧查询不带用户 ID,只能广播。可选的收敛方式有三类:

  1. 商家侧的查询走异构索引表或检索系统,主存储只服务用户维度。
  2. 以商家 ID 分片,用户侧查询通过用户与商家的映射关系先定位商家,代价是多一次查询且大商家会成为热点。
  3. 按查询优先级选择主维度,另一维度通过冗余表或宽表承接。

三种方式都不消除冲突,只是把冲突从查询路径转移到写入路径或存储成本上。选择依据是业务对两个维度的查询频次与延迟要求。

分片键的评估清单

确定分片键之前,需要用统一口径把候选字段逐项过一遍,避免在上线后才发现无法覆盖主要查询:

评估项 核对方式 不满足时的后果
唯一性与非空 该字段是否在业务上必然存在,是否可能为 NULL 或空串 空值无法参与哈希计算,只能全部落入兜底分片,形成倾斜
基数 取值的去重数量与分片数的比值 基数接近或小于分片数时,部分分片长期为空
分布 去重后按出现频次排序,观察头部取值的占比 头部取值占比过高时,其所在分片成为永久热点
查询覆盖率 统计线上高频语句中携带该字段的比例 覆盖率低说明大量查询将退化为广播
稳定性 该字段在业务生命周期内是否可能变更 变更分片键需要跨分片搬迁数据,属于破坏性操作
写入顺序 该字段的取值与写入时间是否相关 强相关且采用范围分片时,写入集中在最新区间

其中"稳定性"最容易被忽略:以订单状态、所属组织这类会变更的字段作为分片键,等于把一次业务更新变成一次数据搬迁;已经采用这类字段的系统,只能通过禁止变更该字段或接受跨分片更新来规避。

2.3 分片算法

算法 路由规则 分布特点 扩容时的搬迁范围
范围分片 按分片键的区间划分(如时间、ID 段) 区间内连续存储,便于范围查询与归档;末端分片容易出现写热点 一般通过增加新区间扩容,存量数据不动,但历史区间的分布不均会长期保留
取模分片 hash(键) % 分片数 分布均匀 分片数变化几乎导致全量搬迁
一致性哈希 键与分片映射到环形空间,扩容时只重分配相邻区间的数据 分布均匀,扩容搬迁量约为 1/n 搬迁量小,但需要处理虚拟节点与数据倾斜
预分片加映射 先固定逻辑分片数(如 1024),物理实例数可变,逻辑分片到实例的映射可调整 分布均匀,扩容只需迁移部分逻辑分片 只搬迁被调整映射的逻辑分片,是分片数规划的常用做法

数据倾斜的成因与观测

成因 观测方式
分片键基数不足 各分片行数差异长期稳定不变,且低取值分片明显偏小
分片键分布不均 少数取值贡献大部分行数(大客户、头部商家)
范围分片的时间偏斜 最新区间的写入量与查询量显著高于其他分片
哈希算法的实现缺陷 各分片理论应均匀而实际差异固定,需核对哈希函数与取模方式
路由规则配置不全 部分键落入默认分片或兜底分片

观测口径应统一为"每分片的行数、数据量、写入速率、查询量"四项,逐日采集并做趋势对比,而不是只看总量。

扩容时的数据搬迁范围

搬迁范围由算法决定:取模分片在分片数由 n 变为 m 时,理论上需要重新分布约 (m-1)/m 比例的数据;一致性哈希与预分片方案只搬迁受影响的部分。这一差异是选择算法的首要依据,写入吞吐的短期峰值可以用排队与限流缓解,而全量搬迁的代价无法回避。扩容的具体策略见 3.6。

2.4 路由与执行链路

执行链路

一条 SQL 在分片环境中的处理分为四步,应用层分片与代理层分片的差别就在于这四步由谁执行:

分片 SQL 的执行链路
  1. 解析      识别语句类型、表名、条件字段、排序与聚合项
  2. 改写      按目标分片替换物理表名,补齐分片键条件,改写分页与聚合
  3. 路由      按分片键计算目标分片;无法计算时取全部分片(广播)
  4. 归并聚合  合并各分片结果集,处理排序、分页、聚合与去重
对比项 应用层分片(客户端框架) 代理层分片(数据库中间件)
执行位置 在应用进程内完成解析、改写、路由与归并 在独立代理进程中完成,应用连接代理
接入成本 需要引入依赖、改造数据源配置与部分 SQL 应用只改连接地址,对 SQL 透明度更高
故障域 与应用同进程,路由逻辑的缺陷会影响应用 代理本身是独立故障域,需要额外的高可用部署
跨片查询 归并在应用内存中完成,受应用堆内存约束 归并在代理内完成,受代理内存与网络约束
可观测性 可结合应用链路追踪,但需自行埋点 可在代理统一采集 SQL 与路由信息
适用条件 技术栈统一、希望避免多一跳网络、能接受代码改造 多语言客户端、存量系统改造预算有限、希望统一治理入口

跨分片查询的代价

查询形态 执行方式 代价来源
等值且带分片键 路由到单分片 与单库查询接近
等值但不带分片键 广播到全部分片 总代价为各分片之和,受最慢分片决定
范围查询带分片键 可能落在部分分片 取决于分片键与范围的重叠程度
排序 各分片返回各自有序结果后在归并层排序 需要等待全部分片返回,最慢分片决定延迟
分页 各分片取 offset + size 条再归并截断 代价随页深与分片数成倍增长,深分页问题被放大
聚合 各分片局部聚合后在归并层二次聚合 COUNT、SUM 可归并;DISTINCT 需要全量数据在归并层去重

跨分片聚合的限制

可归并与不可归并的聚合需要区分:

  1. 可归并:COUNT、SUM、MIN、MAX、AVG(需同时归并计数)。
  2. 有条件可归并:带 GROUP BY 的聚合,若分组键是分片键则退化为各分片独立完成;否则需要把各分片的中间结果汇总。
  3. 不可正确归并:跨分片的 DISTINCT 计数、排名与百分位、窗口函数、需要全局有序的 ORDER BY 加 LIMIT 组合在部分实现中只能取近似或退化。

把这些操作放到检索系统或离线数仓中完成,通常比在分片中间件里强行归并更可靠。

改写示例

以订单表按 user_id 分片为例,同一业务语义在不同条件下的执行方式差别明显:

-- 原始语句:运营侧按状态查询最近订单,不带分片键
SELECT order_id, user_id, amount, created_at
  FROM t_order
 WHERE status = 1
 ORDER BY created_at DESC
 LIMIT 100;

-- 分片后的执行方式:广播到全部分片,各分片取前 100 条后归并
-- 若排序字段与分片键无关,归并层需要缓存 分片数 × 100 条记录
SELECT order_id, user_id, amount, created_at
  FROM t_order
 WHERE status = 1
 ORDER BY created_at DESC
 LIMIT 100;
-- 实际下发的语句(每个分片各一条)
SELECT order_id, user_id, amount, created_at
  FROM t_order_{0..n}
 WHERE status = 1
 ORDER BY created_at DESC
 LIMIT 100;

-- 收窄为带分片键的查询:单分片执行
SELECT order_id, user_id, amount, created_at
  FROM t_order
 WHERE user_id = 10086
   AND status = 1
 ORDER BY created_at DESC
 LIMIT 100;

-- 深分页:offset 越大,各分片需要返回的数据越多
SELECT order_id, user_id, amount, created_at
  FROM t_order
 WHERE user_id = 10086
 ORDER BY order_id
 LIMIT 10000, 20;
-- 改为键集分页:各分片只需返回游标之后的若干条再归并
SELECT order_id, user_id, amount, created_at
  FROM t_order
 WHERE user_id = 10086
   AND order_id > 8823456789012345
 ORDER BY order_id
 LIMIT 20;

两类语句的差别不在语法,而在访问的分片数量与归并层需要持有的中间结果规模。运营类查询无法强制携带分片键时,正确做法是把这类查询导向检索系统或离线链路,而不是在在线路径上接受广播。

2.5 全局唯一 ID

分片后主键不能再依赖单实例的自增序列,需要一套全局唯一的 ID 生成方案。方案之间的差别集中在四点:是否依赖中心服务、ID 是否有序、ID 是否可读、以及服务的可用性要求。

方案 生成方式 有序性 依赖 主要限制
数据库自增加步长 各分片使用不同起始值与同一步长 分片内递增,全局不连续 数据库 扩容时步长与起始值需要重新规划;ID 随实例数增长而变稀疏
号段模式 从数据库批量领取一段 ID 区间,在内存中分配 趋势递增 数据库 需要处理号段耗尽与服务重启后的续领;批量领取会使 ID 出现跳跃
雪花算法 时间戳、机器位、序列号拼接为 64 位整数 按时间趋势递增 时钟与机器编号分配 依赖时钟,出现时间回拨时可能产生重复;机器位需要统一分配
UUID 随机或基于时间与节点生成 128 位值 无序 无 无序导致索引插入离散、页分裂与写放大;存储与传输开销较大

雪花算法的位分配

雪花算法 64 位结构(常见分配,可按业务调整)
  1 位  符号位,固定为 0
  41 位 毫秒时间戳,相对自定义起始时间,可用约 69 年
  10 位 机器位,可部署 1024 个节点
  12 位 序列号,同一毫秒内单节点可生成 4096 个 ID

约束:
  时钟回拨时无法保证单调递增,必须显式处理
  机器位需要统一分配且唯一,容器化部署下不能依赖固定 IP 推导

时间回拨的处理

回拨的成因包括 NTP 校时、虚拟机迁移与人工改时。处理方式按回拨幅度分级:小幅回拨(毫秒级)可等待时钟追上后继续生成;较大回拨应拒绝生成并降级到备用方案或抛错,由调用方重试;同时需要记录回拨事件并告警,避免长期静默容忍。

ID 的附加要求

  1. 单调性与有序性。趋势递增的 ID 使 InnoDB 的插入集中在索引末端,减少页分裂与随机写;完全无序的 ID 会显著放大写入成本。
  2. 可读性。业务常需要从 ID 中读出时间与来源(如按 ID 排序即按时间排序),雪花算法天然满足,UUID 不满足。
  3. 信息安全。连续自增 ID 会暴露业务量并允许遍历,对外暴露的标识应使用不可预测的值或做编码转换。这一要求与有序性冲突,常见做法是内部主键用有序 ID,对外标识另用一套不可预测值。

2.6 事务边界

分片后事务分为两类,处理方式完全不同:

事务类型 范围 保证方式 代价
单分片事务 读写落在同一分片 数据库本地事务 与单库一致
跨分片事务 读写涉及多个分片 两阶段提交或柔性事务 协调开销、锁持有时间、阻塞风险显著上升

即使分片中间件在协议层提供了对多分片事务的支持,其代价也高于单分片:需要在多个连接上开启事务,由协调者统一提交或回滚,任一参与方的失败都会拉长锁持有时间。因此第一条原则是把跨分片写入消灭在设计阶段:

  1. 让同一业务操作的相关表按同一分片键分片。订单、订单明细、订单日志全部以订单所属用户 ID 分片,一次下单写入即可收敛到单分片。
  2. 无法收敛的跨域写入,改为通过消息与补偿实现最终一致,方案取舍见 消息一致性:事务消息与最终一致性,事务框架的选型与落地方式见 Java 分布式事务实践。
  3. 接受柔性事务后,必须同时具备幂等与对账手段,否则补偿的重试会造成重复写入,相关设计见 消息可靠性与幂等设计。

2.7 迁移与双写

停机迁移与不停机迁移

方案 做法 影响 适用条件
停机迁移 停止写入,导出存量,导入新结构,切换连接地址 业务中断时长与数据量成正比 有明确维护窗口、数据量可控、业务可中断
不停机迁移 存量导出与导入、增量追平、双写、校验、灰度切换并行推进 业务不中断,但过程长且需要处理双写不一致 无法接受停机,且有能力实现双写与校验

双写与数据校验

双写的常见形态有三种,可靠性依次上升:

双写形态
  形态一  业务代码同时写新旧两套存储
          风险:两处写入不在同一事务内,任一侧失败即产生不一致

  形态二  写旧存储成功后发出变更事件,由消费者写入新存储
          风险:事件丢失或消费失败导致新存储落后,需要重放能力

  形态三  写入 binlog 订阅链路,由同步组件投递到新存储
          风险:同步延迟,但可基于位点重放,可靠性最高

无论采用哪种形态,都必须具备三项配套:写入顺序明确(以哪一侧为准)、差异校验工具、以及差异修复流程。

灰度切换与读流量迁移顺序

切换顺序的原则是先读后写、先小流量后全量:

  1. 双写开启,同时以旧存储为读来源,观察新存储的数据追平程度。
  2. 校验差异并修复,确认差异率降到可接受范围。
  3. 按用户、租户或分片维度灰度把读流量切到新存储,对比两侧结果。
  4. 读流量全量切换并稳定运行一个观察周期后,再切换写入的主来源。
  5. 停止反向写入,保留旧存储只读一段时间作为回退路径。

高危:开启双写与切换读写来源会同时影响新旧两套存储的数据一致性,一旦写入顺序或失败处理不当,两侧会持续分化且难以判断以哪一侧为准。影响范围为迁移涉及的全部表与依赖这些表的在线业务。执行前必须确认旧存储可回退、已具备按主键比对的校验工具、且双写失败有明确的重试与告警路径。回滚方式:把读来源切回旧存储并关闭反向写入,然后以旧存储为准重建新存储的差异数据;若已停止对旧存储的写入,则无法通过反向回滚恢复,只能依赖迁移前的全量备份重建。

三、实现

3.1 选型与落地形态

选型的第一层判断是"路由逻辑放在应用内还是放在代理内",第二层判断才是具体框架。两者的对照已在 2.4 给出,此处补充引入成本与适用条件:

  1. 应用层分片框架适合技术栈统一、希望减少网络跳数、且有能力改造数据源与 SQL 的团队。引入成本集中在依赖版本管理、数据源替换、以及分片配置与 Spring 事务管理器的配合。
  2. 代理层分片适合客户端语言多样、存量系统改造成本高、希望把分片规则集中在运维侧管理的场景。代价是代理自身需要高可用部署,且部分 SQL 语义在代理层的支持度与原生数据库存在差异。
  3. 两者的共同前提是分片键能被应用正确传递到 SQL 中。若业务链路上分片键在多层调用中丢失,任何中间件都无法挽回。

引入成本的构成

无论选择哪条路线,引入成本都由以下五部分构成,评估时应逐项列出而不是只看框架本身:

成本项 应用层分片 代理层分片
依赖与版本 框架版本与 Spring、数据源、连接池、ORM 的兼容矩阵需要核对,升级时可能被框架版本绑定 应用依赖不变,但代理的版本需要与数据库版本、客户端协议对齐
配置与元数据 分片规则写在应用配置中,多环境需要同步维护,变更需要重新发布 规则集中在代理侧,变更不重启应用,但需要额外的配置版本管理
SQL 兼容性 依赖框架的 SQL 解析能力,复杂语句可能不支持,需要改写 解析在代理内完成,同样存在不支持的语法,且排查时需要区分代理与数据库的报错
运维对象 无新增进程,但路由逻辑的缺陷与应用故障混在一起 代理需要多实例、健康检查与故障转移,属于新增的可用性依赖
排障路径 可在应用内断点与日志中观察路由结果 需要同时查看代理日志与数据库日志,链路更长

与 ORM 的配合边界同样受路线影响:应用层分片可以直接复用 ORM 的会话与事务管理;代理层分片下 ORM 仍按单库方式工作,但生成的 SQL 需要满足代理的解析要求。

与 ORM 的配合边界

分片与 ORM 的组合需要注意三点:

  1. ORM 生成 SQL 的方式会影响分片路由的可预测性。动态拼接的条件、IN 查询、子查询与联表都会改变路由结果,复杂 SQL 应显式改写或在 Mapper 层手工控制。
  2. 分页与批量操作在分片下的语义与单库不同,ORM 的分页插件通常只处理单表分页,跨分片分页需要框架或中间件支持。
  3. 事务管理器的配置需要与分片数据源对齐,事务传播行为的边界仍遵循单库语义,相关约定见 Java 持久层。

3.2 分片键与表设计实践

表结构约定

-- 分片表:分片键进入主键与索引首列
CREATE TABLE t_order_0 (
    order_id    BIGINT       NOT NULL COMMENT '全局唯一 ID,由 ID 服务生成',
    user_id     BIGINT       NOT NULL COMMENT '分片键',
    shop_id     BIGINT       NOT NULL COMMENT '商家维度,用于异构索引',
    status      TINYINT      NOT NULL,
    amount      DECIMAL(12,2) NOT NULL,
    created_at  DATETIME(3)  NOT NULL,
    updated_at  DATETIME(3)  NOT NULL,
    PRIMARY KEY (order_id),
    KEY idx_user_created (user_id, created_at),
    KEY idx_shop_created (shop_id, created_at)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

约定要点:

  1. 主键使用全局 ID 而非数据库自增,且各分片表的主键生成方式一致。
  2. 分片键列为 NOT NULL,并作为高频联合索引的首列。
  3. 不使用数据库层面的外键约束:外键无法跨越分片,且会引入额外的锁与检查开销。
  4. 表名使用统一后缀(_0、_1)或按分片数生成,命名规则必须可被路由层推导。
-- 子表冗余父表分片键,使父子数据落在同一分片
CREATE TABLE t_order_item_0 (
    item_id     BIGINT       NOT NULL,
    order_id    BIGINT       NOT NULL,
    user_id     BIGINT       NOT NULL COMMENT '冗余自订单表,用于与父表同分片',
    sku_id      BIGINT       NOT NULL,
    quantity    INT          NOT NULL,
    PRIMARY KEY (item_id),
    KEY idx_order (order_id),
    KEY idx_user (user_id)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

-- 广播表:在每个分片库中各存一份,DDL 需按全部分片一致执行
CREATE TABLE t_dict_0 (
    dict_type   VARCHAR(64)  NOT NULL,
    dict_key    VARCHAR(64)  NOT NULL,
    dict_value  VARCHAR(255) NOT NULL,
    updated_at  DATETIME(3)  NOT NULL,
    PRIMARY KEY (dict_type, dict_key)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

分片键冗余

冗余的目的是把广播查询转化为单分片查询:在子表中冗余父表的分片键,使子表与父表落在同一分片。

冗余场景 做法 代价
订单明细 冗余 user_id,与订单同分片 需要保证父表分片键不变,否则子表要同步搬迁
操作日志 冗余业务主键对应的分片键 日志表写入量放大列宽
关联查询 冗余常用展示字段构成宽表 字段变更需要同步更新冗余列

高危:修改既有的分片键或冗余分片键字段会使已落库数据与路由规则不再匹配,表现为查询查不到、写入重复或落到错误分片。影响范围为该表及其所有依赖分片键的索引、冗余列与下游同步任务。执行前需完成存量数据的一致性核对,并确认可以按旧规则回退。回滚方式:恢复原分片键定义与路由规则,并把按新规则写入的数据迁回原分片;若数据已被混合写入且无来源标记,只能依据备份重建。

字典表、配置表与小表广播

  1. 字典与配置表数据量小、变更少,常见做法是在每个分片库中各存一份副本(广播表),使关联查询不出分片。代价是每次变更需要更新全部副本,需要幂等且具备失败重试。
  2. 若字典表变更频繁,广播的同步成本会超过收益,此时应改为应用层缓存,把字典数据加载到内存并由变更事件驱动刷新。
  3. 广播表不参与分片路由,其 DDL 需要按"全部分片执行同一脚本"的方式编排。

热点数据的处理

热点形态 处置方式 代价
单键高频读写(爆款商品、大商家) 缓存本地化、读写合并、按二级维度散列 一致性更难维护,缓存与存储的更新顺序需要明确
分片键取值集中(少数大客户占比高) 对热点取值再散列,把该取值拆到多个分片 该取值的查询需要跨分片合并
时间末端写热点(范围分片) 改为哈希分片,或对时间分片做二次散列 范围查询与归档的便利性下降
全表统计类请求 结果缓存、异步预计算、走离线链路 数据实时性下降

3.3 路由与查询实现

分片路由的配置方式

# 应用层分片配置要点(以常见框架形态示意)
spring:
  shardingsphere:
    datasource:
      names: ds0,ds1
      ds0:
        # 每个物理库对应一个数据源
        url: jdbc:mysql://host0:3306/app?useSSL=false
      ds1:
        url: jdbc:mysql://host1:3306/app?useSSL=false
    rules:
      sharding:
        tables:
          t_order:
            # 实际数据节点:库表达式与表表达式
            actual-data-nodes: ds$->{0..1}.t_order_$->{0..1}
            # 分片键与算法
            database-strategy:
              standard:
                sharding-column: user_id
                sharding-algorithm-name: db-inline
            table-strategy:
              standard:
                sharding-column: user_id
                sharding-algorithm-name: tbl-inline
            # 全局主键生成策略
            key-generate-strategy:
              column: order_id
              key-generator-name: snowflake
        # 广播表:在每个库中都存在的表
        broadcast-tables: t_dict, t_config
        sharding-algorithms:
          db-inline:
            type: INLINE
            props:
              algorithm-expression: ds$->{user_id % 2}
          tbl-inline:
            type: INLINE
            props:
              algorithm-expression: t_order_$->{user_id % 2}

配置的复核要点:

  1. 表达式与分片键必须一致,数据库分片与表分片使用同一套键时,两者的一致性决定了数据是否落在预期位置。
  2. 广播表清单必须与实际在每个库中建表的清单一致,遗漏会导致查询路由到不存在的表。
  3. 主键生成策略的统一配置可以避免业务代码各处重复生成 ID。
  4. 配置变更等同于路由规则变更,需要版本化管理与灰度验证。

高危:修改分片路由表达式、分片键列或广播表清单会立即改变数据的读写位置,使已落库数据与新路由不再匹配,表现为部分数据查不到或写入落到错误分片。影响范围为使用该分片规则的全部表与在线读写请求。执行前必须确认存量数据的位置与新规则一致、配置可回退到上一版本、且多实例的配置发布能够同步完成。回滚方式:把路由配置回退到变更前的版本并重新发布全部实例;若期间已按新规则写入数据,需要在校验后把这些数据搬回原分片,无法区分来源时只能依据备份重建。

跨分片查询的改写方式与限制

原查询 改写方式 限制
不带分片键的等值查询 广播到全部分片后归并 分片数越多代价越高
跨分片联表 拆为多次单分片查询后在应用层组装 中间结果可能超过单次查询规模,需要分页处理
跨分片排序分页 各分片取前 offset + size 条后归并 页深越大,各分片取回的数据越多
跨分片聚合 各分片局部聚合后二次聚合 DISTINCT 与排名类聚合无法正确归并
子查询与 IN 多值 按分片键展开为多次单分片查询 值数量大时连接占用与往返次数上升

分页与排序的实现方案

  1. 键集分页:以有序的分片键或全局 ID 作为游标,各分片取"大于游标的前 N 条"后归并,避免深 offset。适用条件是顺序翻页且排序键唯一。
  2. 二次查询法:先按目标条件在各分片取 offset + size 条并归并排序,再回到各分片按结果的主键补齐完整字段。适合需要精确分页但字段较多的场景。
  3. 限制可翻页深度:超过阈值后改为要求收窄条件或转入异步导出。这是成本最低的方案,但需要产品侧确认。
  4. 异步导出与离线查询:大批量的排序分页与统计改为导出任务或走离线链路,在线接口只服务浅分页。

跨分片 JOIN 的替代方案

方案 做法 适用条件
数据冗余 把被关联表的展示字段冗余到主表 关联表字段稳定、变更频率低
宽表 预先把多表关联结果物化为宽表 关联关系固定、查询模式集中
检索系统 把需要多维度查询的字段同步到检索系统,由检索承接复杂查询 查询条件灵活、需要排序与聚合;需要处理同步延迟
应用层组装 分别查询多张表后在应用内拼接 关联结果集可控,能接受多次往返
全局表广播 把小表在每个分片建副本 小表变更少、参与频繁关联

3.4 全局 ID 实现

号段模式的实现要点

// 号段模式:按需从数据库批量领取 ID 区间,在内存中分配
public class SegmentIdGenerator {

    private final SegmentLoader loader;
    private final AtomicLong current = new AtomicLong(0);
    private volatile long max = 0;
    private final long step;
    // 提前续领的阈值比例,避免在耗尽瞬间阻塞业务线程
    private final double threshold;

    public SegmentIdGenerator(SegmentLoader loader, long step, double threshold) {
        this.loader = loader;
        this.step = step;
        this.threshold = threshold;
    }

    public long nextId() {
        long value = current.incrementAndGet();
        if (value > max) {
            // 双重检查后触发续领,续领期间需要保证并发安全
            synchronized (this) {
                if (current.get() > max) {
                    Segment segment = loader.loadNext(step);
                    current.set(segment.getStart());
                    max = segment.getEnd();
                    value = current.incrementAndGet();
                }
            }
        }
        return value;
    }

    public boolean shouldPrefetch() {
        // 剩余可用比例低于阈值时提前续领,降低耗尽时的等待
        long remaining = max - current.get();
        return remaining < step * threshold;
    }
}

数据库侧的交互与注意点:

-- 号段表:每行代表一个业务标识的号段
CREATE TABLE t_id_segment (
    biz_tag    VARCHAR(64) NOT NULL COMMENT '业务标识',
    max_id     BIGINT      NOT NULL COMMENT '当前已分配到的最大值',
    step       INT         NOT NULL COMMENT '每次领取的步长',
    updated_at DATETIME(3) NOT NULL,
    PRIMARY KEY (biz_tag)
) ENGINE = InnoDB;

-- 领取号段:单条语句完成"更新并返回新值",避免读写分离下的读取延迟
UPDATE t_id_segment
   SET max_id = max_id + step, updated_at = NOW(3)
 WHERE biz_tag = 'order'
   AND max_id = #{expectedCurrentValue};
  1. 领取语句必须是写操作,并且不能走只读库,否则会读到滞后值导致号段重复,读写分离的行为差异见 mysql:主从同步原理。
  2. 使用乐观锁(AND max_id = ?)可以在并发领取失败时快速重试,避免长事务持锁。
  3. 号段长度需要在"减少领取频次"与"重启后的 ID 浪费"之间取舍。号段过长会放大服务重启与节点下线造成的空洞。

雪花算法的实现与时间回拨处置

public class SnowflakeIdGenerator {

    private static final long EPOCH = 1735689600000L; // 自定义起始时间,2025-01-01
    private static final long WORKER_BITS = 10L;
    private static final long SEQUENCE_BITS = 12L;
    private static final long MAX_WORKER_ID = (1L << WORKER_BITS) - 1;
    private static final long MAX_SEQUENCE = (1L << SEQUENCE_BITS) - 1;
    private static final long WORKER_SHIFT = SEQUENCE_BITS;
    private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_BITS;

    private final long workerId;
    private long lastTimestamp = -1L;
    private long sequence = 0L;
    // 允许容忍的回拨幅度,超过则拒绝生成
    private final long maxBackwardMs;

    public SnowflakeIdGenerator(long workerId, long maxBackwardMs) {
        if (workerId < 0 || workerId > MAX_WORKER_ID) {
            throw new IllegalArgumentException("workerId 超出取值范围");
        }
        this.workerId = workerId;
        this.maxBackwardMs = maxBackwardMs;
    }

    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();
        if (timestamp < lastTimestamp) {
            long offset = lastTimestamp - timestamp;
            if (offset > maxBackwardMs) {
                // 回拨幅度超出容忍范围:拒绝生成并上报,由调用方降级或重试
                throw new IllegalStateException("时钟回拨 " + offset + "ms,拒绝生成 ID");
            }
            // 小幅回拨:等待时钟追上上一次的时间戳后再继续
            timestamp = waitUntil(lastTimestamp);
        }
        if (timestamp == lastTimestamp) {
            sequence = (sequence + 1) & MAX_SEQUENCE;
            if (sequence == 0) {
                // 当前毫秒序列号用尽,等待下一毫秒
                timestamp = waitUntil(lastTimestamp + 1);
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = timestamp;
        return ((timestamp - EPOCH) << TIMESTAMP_SHIFT)
                | (workerId << WORKER_SHIFT)
                | sequence;
    }

    private long waitUntil(long target) {
        long timestamp = System.currentTimeMillis();
        while (timestamp < target) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
}

机器位分配的三条约束:

  1. 机器位必须在全部实例间唯一。容器化部署下实例的 IP 与主机名都不稳定,应通过配置中心、启动参数或协调服务分配并登记,由 ID 服务启动时校验占用情况。
  2. 机器位分配必须持久化并留痕,否则实例重启后可能拿到已被占用的编号,造成 ID 重复。
  3. 实例数接近机器位上限时需要提前扩容机器位或引入位数可变的方案,重新分配位数会改变 ID 结构,需要评估历史数据。
# 机器位与 ID 服务的配置要点
id-service:
  worker:
    # 机器位不由实例自行推导,而是从分配表或配置中心获取
    allocation: config-center
    namespace: order-id
    # 启动时校验:同一编号若已被其他存活实例持有则拒绝启动
    verify-occupied-on-start: true
  segment:
    # 号段长度与预取阈值
    step: 1000
    prefetch-ratio: 0.2
    # 续领失败的重试与退避
    retry:
      max-attempts: 3
      backoff-ms: 50
  snowflake:
    # 起始时间固定不可变更,变更会导致 ID 结构不连续
    epoch: 2025-01-01T00:00:00Z
    max-backward-ms: 5

ID 服务的可用性与降级

失效场景 降级手段 代价
号段领取的数据库不可用 本地缓存已有号段继续服务,同时告警 只能支撑有限时长,耗尽后无法生成
号段耗尽且无法续领 切换备用号段表或备用数据库 需要预先准备并验证备用链路
时钟回拨超出容忍范围 降级到备用生成方式或拒绝服务并返回可重试错误 依赖调用方的重试策略,短时写入失败
机器位冲突 启动时校验失败即拒绝启动,避免带病生成 实例无法提供服务,需要人工介入修复编号

ID 服务是所有写入路径的强依赖,其可用性要求高于普通业务服务:应支持多实例部署、本地缓存预取、以及明确的失败信号,而不是在号段耗尽时静默阻塞。

预取的实现时序:

号段预取
  1. 分配线程在每次取号时检查剩余比例
  2. 剩余比例低于阈值时异步发起续领,不阻塞当前取号
  3. 续领成功:把新号段放入备用槽位,当前号段耗尽后原子切换
  4. 续领失败:记录失败并重试;重试期间当前号段仍可服务
  5. 当前号段耗尽且续领仍未成功:按配置决定是阻塞等待还是立即失败

  关键点:切换号段与分配 ID 必须保证同一时刻只有一个号段在服务,
         否则两个号段的区间重叠会造成 ID 重复

ID 生成的可观测性

需要采集的指标包括:每秒生成量、当前号段的剩余比例、号段续领的耗时与失败次数、时钟回拨次数与幅度、机器位占用清单、以及 ID 的重复检测结果。其中"重复检测"通常通过在存储层对主键的唯一约束间接体现,写入时的主键冲突次数是最直接的信号。

3.5 迁移实施

迁移方案设计

存量导出 → 全量导入新结构 → 增量追平 → 数据校验 → 灰度切换读 → 切换写主源 → 停写旧库 → 观察与回收
        ↑                                    ↓
        └──────── 差异修复 ← 校验不一致 ────────┘
  1. 存量导出:按主键或分片键分批导出,避免一次性大查询导致主库压力上升;导出方式与工具的选择见 mysql: 备份与恢复。
  2. 全量导入:导入顺序与目标分片对齐,导入期间关闭或弱化二级索引的唯一性校验,完成后再补建索引。
  3. 增量追平:以 binlog 订阅或双写承接迁移开始之后的变更,记录起始位点以便重放。
  4. 数据校验:按行数与关键字段校验和分段比对,差异定位到具体主键范围。

双写的实现与一致性风险

  1. 双写必须保证"哪一侧为准"是确定的:写在两侧都成功时才返回成功,或在主侧成功、从侧失败时记录差异并由补偿任务修复。
  2. 双写失败必须有明确的落库记录(本地消息表或失败队列),否则差异只能靠全量比对发现。
  3. 双写期间禁止对两侧执行结构不一致的变更,否则同一份写入在两侧的成功条件不同。
// 双写与差异记录:主侧为准,从侧失败时落库由补偿任务修复
public void saveOrder(Order order) {
    // 主侧:新存储,失败即整体失败
    orderRepository.save(order);
    try {
        // 从侧:旧存储,失败不阻断主流程,但必须留痕
        legacyOrderRepository.save(order);
    } catch (Exception e) {
        // 记录差异:保留主键、操作类型与失败原因,供补偿任务重放
        differenceLog.record(new DifferenceRecord(
                order.getOrderId(), Operation.INSERT, e.getMessage()));
    }
}

差异记录的字段至少需要包含主键、操作类型、发生时间与重试次数,使补偿任务能够按主键重放并判断是否需要人工介入。缺少操作类型时,补偿无法区分是插入缺失还是更新缺失。

校验工具与差异修复

# 分段校验的思路:按主键区间分块,逐块比对行数与字段校验和
# 每块的结果落库,便于按块重跑与差异定位
for range in $(seq 0 999); do
  # 导出旧库该区间
  mysql -h old -e "SELECT COUNT(*) AS c, BIT_XOR(CRC32(CONCAT_WS(',', id, user_id, status))) AS s
                     FROM app.t_order WHERE id BETWEEN ${range}000000 AND ${range}999999" >> old_chunk.txt
  # 导出新库同区间(多分片结果按区间汇总)
  mysql -h shard0 -e "SELECT COUNT(*) AS c, BIT_XOR(CRC32(CONCAT_WS(',', id, user_id, status))) AS s
                        FROM app.t_order WHERE id BETWEEN ${range}000000 AND ${range}999999" >> new_chunk.txt
done

# 比对结果差异,差异块再按主键逐条核对并生成修复语句
diff old_chunk.txt new_chunk.txt

校验手段的取舍:行数比对成本最低但遗漏率最高;字段校验和能发现内容差异但不定位具体行;逐行比对最准确但代价最高。实践中按"先粗后细"分三轮执行。

高危:批量修复数据会直接改写生产数据,若修复条件写错或校验依据不可靠,会造成大范围数据错误且难以区分哪些行是被修复过的。影响范围为修复语句命中的全部行及其关联的冗余列与下游同步数据。执行前必须完成差异明细的导出与备份、确认修复条件能唯一定位到目标行、并在小批量上验证后再推广。回滚方式:按修复前导出的差异明细反向生成恢复语句,无法定位原始值时只能从备份重建。

切换步骤与回滚点

步骤 动作 回滚点
1 开启双写,旧库仍为读主源 关闭双写(无数据影响)
2 校验并修复差异 无需回滚,重复执行校验
3 灰度切读,对比两侧结果 读流量切回旧库
4 读全量切换,观察一个周期 读流量切回旧库
5 写主源切到新库,旧库降为只写副本 写主源切回旧库并重新校验差异
6 停止对旧库写入,旧库转只读保留 此步之后无法回滚,只能依赖备份

切换后的观察指标

  1. 新库各分片的数据量与行数增长是否符合预期分布。
  2. 写入延迟与错误率较切换前的变化。
  3. 双写差异的累积量是否为零或持续收敛。
  4. 跨分片查询的比例与延迟,以及慢 SQL 的分布变化。
  5. 连接数、复制延迟与 ID 生成的失败率。

3.6 容量与扩容

分片数量的规划依据

分片数量需要在"当前够用"与"未来少搬"之间平衡:

  1. 按单分片的目标容量反推:目标单分片数据量应使其备份与恢复能在可接受窗口内完成,并留有余量。
  2. 按写入吞吐反推:单分片的写入能力上限由磁盘与 CPU 决定,分片数应覆盖未来一段时间的峰值写入。
  3. 预留增长系数:分片数一般取未来业务量的预估上限,并保持为 2 的幂次或可整除的整数,便于用取模以外的表达式映射。
  4. 采用预分片加映射的方式,把物理分片数与逻辑分片数解耦,使后续扩容只调整映射关系而不改变路由表达式。
-- 逻辑分片到物理实例的映射表:扩容时只改这张表的值
CREATE TABLE t_shard_mapping (
    logic_shard   INT          NOT NULL COMMENT '逻辑分片编号,总数固定',
    physical_group VARCHAR(64) NOT NULL COMMENT '物理实例分组标识',
    state         VARCHAR(16)  NOT NULL COMMENT 'NORMAL/MIGRATING/READONLY',
    updated_at    DATETIME(3)  NOT NULL,
    PRIMARY KEY (logic_shard)
) ENGINE = InnoDB;

-- 路由计算:先按分片键算出逻辑分片,再查映射得到物理实例
-- 逻辑分片数固定后,路由表达式不随扩容变化
SELECT physical_group
  FROM t_shard_mapping
 WHERE logic_shard = ?() % 1024
   AND state = 'NORMAL';

映射表中的 state 字段是搬迁期间的关键:处于 MIGRATING 的逻辑分片需要双读校验,处于 READONLY 的逻辑分片需要在完成搬迁后回收写入。状态流转必须与搬迁进度严格同步。

扩容时的数据搬迁与路由变更

扩容搬迁的两种形态
  形态一  增加物理实例,调整逻辑分片到实例的映射
          搬迁范围:被调整映射的逻辑分片
          路由变更:映射表变化,应用或代理读取新映射

  形态二  增加分片数(分片数从 n 变为 m)
          搬迁范围:取模方案下接近全量;一致性哈希方案下约 1/m
          路由变更:分片表达式变化,需要双读或双写过渡

搬迁期间的读写策略与限流

  1. 双读校验:搬迁期间对迁移中的数据先读新位置、回源旧位置,比对一致后切换。适用于允许短暂读旧数据的场景。
  2. 搬迁限流:搬迁任务必须限速,控制其对源库与目标库的读取、写入与网络占用。并发度按目标库的剩余 IOPS 与磁盘余量确定,而不是按源库。
  3. 搬迁期间的写入处理:搬迁开始后该范围内的新写入必须双写或通过增量追平补齐,否则搬迁完成时数据已过期。
  4. 搬迁的暂停与回退:搬迁任务应支持按逻辑分片粒度暂停与重跑;回退方式是丢弃目标位置的部分数据并恢复映射,前提是尚未切换路由。

高危:扩容时的数据搬迁与路由变更会同时改变数据位置与访问路径,路由切换瞬间的错误会导致读写落到不存在或过期的数据上。影响范围为被搬迁分片上的全部表与业务。执行前必须确认搬迁工具支持按分片暂停与重跑、路由变更可回退、且目标实例容量足以承接搬迁后的负载。回滚方式:把路由与映射恢复到变更前的版本并清理目标位置的数据;若搬迁期间已发生写入且未保留增量,则需要重新执行一次搬迁。

3.7 运维与治理

分片后的监控项

监控维度 具体指标 判读重点
各分片数据量 每分片的行数、数据量、索引量 分布是否均匀,倾斜是否随时间扩大
各分片增长速率 日均行数与字节数增量 哪个分片会先触及容量上限
跨分片查询比例 广播查询数占总查询数的比例 比例上升说明查询路径在偏离分片键
慢 SQL 分布 慢查询按分片与按语句形态的分布 是单分片热点还是全分片普遍变慢
路由与配置 路由规则的版本、广播表清单一致性 配置与实际表结构的偏差
ID 服务 号段剩余、续领失败、时钟回拨 写入路径的强依赖健康度

监控体系的指标类型、采集模型与告警规则构成,见 linux: 监控与告警;MySQL 侧的慢查询与性能指标采集见 mysql: 性能诊断与调优。

备份与恢复的分片视角

  1. 备份需要覆盖全部分片并保证时间点尽可能接近,否则按全局时间点恢复会缺失部分分片的数据。一致性快照与恢复方式见 mysql: 备份与恢复。
  2. 恢复演练必须包含"仅恢复单个分片"的场景,因为实际故障多以单分片为单位发生。
  3. 备份窗口从"一次备份"变为"并行备份多个分片",需要评估并行度对共享存储与网络的影响。

连接池与资源分配

分片后总连接数等于"单分片连接数 × 分片数",很容易突破数据库实例的 max_connections。要点:

  1. 按分片维度核算连接池上限,而不是只在应用侧设置一个总上限。
  2. 分片数增加时同步复核数据库实例的连接上限与内存开销。
  3. 容器化部署下实例数与副本数的变化会成倍放大连接数,弹性伸缩与连接池的配合需要预先验证,相关配置与排障见 Java 应用云原生部署。

分片元数据的管理与变更流程

分片元数据包括:分片键定义、分片算法与表达式、逻辑分片到物理实例的映射、广播表清单、以及全局 ID 的生成策略。这些元数据的变更等同于路由变更,必须走变更流程:

  1. 元数据版本化,每次变更留档,可回退到任一历史版本。
  2. 变更前评估影响面:哪些表、哪些查询路径、是否需要同步搬迁数据。
  3. 变更在灰度环境验证后再推广,推广过程按分片分批。
  4. 变更后核对实际数据位置是否符合新元数据的预期。

周期性巡检清单

巡检项 核对内容 异常信号
分片分布 各分片行数与数据量的比值是否稳定 比值持续扩大说明倾斜在累积
跨片查询比例 广播查询占比与环比变化 占比上升通常对应新上线功能未带分片键
慢 SQL 分布 慢查询是按分片集中还是普遍存在 单分片集中指向倾斜,普遍存在指向语句本身
广播表一致性 各分片的广播表行数与校验和 不一致说明同步机制有失败未处理
ID 服务 号段剩余比例、续领失败率、机器位占用表 占用表与实际存活实例不符存在重复风险
连接数 各分片实例的连接占用与峰值 接近上限时需要先核算分片数再调整池大小
备份完整性 各分片最近一次备份是否成功且可恢复 单分片备份失败在总量检查中容易被平均掉
路由配置 配置版本与映射表状态是否与实际一致 存在残留的迁移中间状态会造成读写分裂

3.8 常见问题与排查

问题 典型表现 排查方向
数据倾斜 某分片数据量与负载长期显著高于其他分片 核对分片键基数与取值分布;检查是否存在大客户集中;检查路由表达式是否与预期一致
跨分片查询性能骤降 接口延迟随分片数上升,慢查询集中在广播语句 统计广播查询比例;定位缺少分片键的语句;检查归并层的内存与排序开销
ID 冲突 写入报主键冲突,且冲突行分布在不同分片 检查机器位是否重复分配、时间回拨是否被静默容忍、号段是否被并发重复领取
ID 耗尽或分配失败 写入失败伴随 ID 服务报错,或 ID 出现大段跳跃 检查号段剩余比例与续领失败率、时钟状态与机器位占用
迁移后数据不一致 校验差异持续存在或周期性重现 检查双写的失败处理、增量追平的位点是否推进、是否有绕过双写的写入路径
扩容后路由错误 部分数据查不到或写入落到错误分片 核对路由表达式的变更范围、映射表版本、以及缓存中的旧路由配置
分布式事务悬挂 跨分片事务的参与方长期持有锁或存在未完成分支 检查协调者的日志、参与方的锁等待与事务状态,确认补偿任务是否执行
广播表不一致 同一字典数据在不同分片取值不同 核对广播表的同步机制与失败重试,检查是否存在绕过同步的直接写入

排查顺序上,先确认问题是否与路由相关(对照数据实际位置与预期位置),再确认是否与倾斜相关(对照各分片指标),最后才进入单条 SQL 与索引层面。应用侧的延迟与错误表现、线程与连接的判读顺序,见 Java 应用诊断与部署调优。

以"扩容后路由错误"为例,排查可以沿以下顺序收敛:

1. 确认现象范围:是全部分片还是特定分片;是新写入数据还是历史数据
2. 核对路由配置:表达式版本、映射表版本、应用缓存中的配置是否一致
3. 抽样验证:取若干已知分片键的数据,手工计算应落分片并与实际位置比对
4. 区分读写路径:读路径异常说明路由或映射有误,写路径异常还需检查写入是否绕过路由
5. 确认影响边界:错误写入的数据是否需要搬迁回正确分片,是否存在重复行
6. 修复与复核:修正配置或搬迁数据后,按分片键重新抽样验证,并补齐校验

其中第 2 步最常见的原因是配置发布不完整:多实例部署下部分实例仍在使用旧路由表达式,表现为同一份数据在部分实例上被路由到错误位置,而在其他实例上正常。

四、总结

  • 单库单表的上限由磁盘容量、连接数与写入吞吐三类约束共同决定,三者成因不同、互相独立;触发判断以备份与恢复窗口、连接占用趋势与写延迟曲线为主,拆分条件详见 mysql: 表结构变更与运维治理 的容量规划一节
  • 拆分顺序是 SQL 与索引优化、缓存与读写分离、数据生命周期治理、垂直拆分、水平拆分;跳级拆分会把可被索引与缓存吸收的问题转化为分布式问题
  • 分片的长期成本集中在跨片查询、分布式事务、运维与扩容、应用改造与数据搬迁五处,这些不是设计缺陷而是共享存储被拆散后的固有结果
  • 垂直分表拆列、垂直分库拆实例、水平分表拆行;推进顺序以"对查询拓扑破坏最小"为准,业务域边界应与服务边界一致
  • 分片键需要同时满足高基数、分布均匀与查询命中率高,三者存在取舍;分片键应作为高频联合索引的首列,多维度查询通过基因法、异构索引表或双写多套分片承接
  • 分片算法的选择首先看扩容搬迁范围:取模分片接近全量搬迁,一致性哈希与预分片加映射只搬迁受影响部分;数据倾斜的成因需要按分片键基数、取值分布、时间偏斜与路由配置逐项核对
  • 分片 SQL 的执行链路是解析、改写、路由、归并聚合;跨分片查询的代价随分片数增长,排序分页受最慢分片决定,DISTINCT 与排名类聚合无法正确归并
  • 全局唯一 ID 的取舍集中在依赖、有序性与可用性:数据库自增步长受扩容规划约束,号段模式依赖数据库但有序可控,雪花算法依赖时钟与机器位分配,UUID 无序会放大写入成本;对外标识还应满足不可预测要求
  • 事务边界上优先把同一业务操作收敛到单分片,跨分片写入只能退化为柔性事务并配套幂等与对账;单分片事务与单库语义一致
  • 迁移采用存量导出、增量追平、校验、灰度切读、切换写主源、停写旧库的顺序推进,每一步都需要明确的回滚点;双写必须明确以哪一侧为准并记录失败
  • 分片数量按目标单分片容量与写入能力反推并预留增长系数;扩容的关键是搬迁范围可控与路由变更可回退,搬迁期间需要限流与增量追平
  • 分片后的运维重点是把"一次操作"改为"按分片编排":监控按分片采集、备份按分片验证、连接池按分片核算、分片元数据按变更流程版本化管理
  • 常见问题的排查从路由与数据位置的一致性入手,再判断倾斜,最后才进入单条 SQL 与索引;ID 冲突与迁移不一致属于数据正确性问题,优先级高于性能问题