数据库分片:垂直拆分、水平拆分与分片键

数据库分片:垂直拆分、水平拆分与分片键

Hello,我是小兔大白糖。 读完能按域与键选择拆分策略,并预见到跨片查询与扩容迁移的代价。

估计阅读时间:30 分钟

垂直拆分、水平拆分与扩容迁移
垂直拆分、水平拆分与扩容迁移 · 点击查看 SVG 原图

从单体 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 区间划分扩容简单(追加新分片),范围查询友好热点风险(新分片压力大)日志、流水按月份分表
一致性 HashHash 环 + 虚拟节点扩容只影响相邻节点,迁移量小实现复杂,数据分布需调虚拟节点数缓存分片(Redis Cluster)
混合策略先 Range 再 Hash兼顾扩展性与均匀性路由复杂金融交易:按月 Range,月内按 Hash

2.3 ShardingSphere 架构解析

Apache ShardingSphere 是业界最常用的数据库中间件方案,定位数据库增强引擎,提供分片、加密、读写分离、影子库等能力。

database sharding basics · 图 1
database sharding basics · 图 1 · 点击查看 SVG 原图

核心组件:

  1. SQL Parser:基于 ANTLR 将 SQL 解析为 AST,识别表名、WHERE 条件、聚合函数
  2. Router:根据分片规则计算目标分片(如 user_id = 12345 → ds1.trade_01)
  3. Rewriter:改写 SQL,将逻辑表 trade 替换为物理表 trade_01,并补充分片键
  4. Executor:多线程并行执行路由后的 SQL,默认连接池隔离
  5. 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 表。直接停机迁移不可接受。

database sharding basics · 图 2
database sharding basics · 图 2 · 点击查看 SVG 原图

关键步骤:

阶段动作风险点
1. 存量迁移历史数据按新规则导入新分片全量扫描旧库压力大,需限速
2. 增量同步Canal / Debezium 实时同步 BinlogDDL 变更需同步处理;延迟监控
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: 1

Java 实体类:

@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 性能到顶。

演进路线:

  1. 2007-2009 垂直拆分:按业务拆用户库、商品库、交易库。交易库仍是瓶颈。
  2. 2010-2012 水平拆分:交易表按买家 ID 取模分 16 库 64 表。但卖家查询性能差(需跨分片)。
  3. 2013-2015 异构索引表:同一份数据按买家 ID 和卖家 ID 各建一套分片表,异步同步。查询卖家订单走卖家维度分片。
  4. 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 / HiveOLTP 只保留热数据,冷数据用于离线模型训练

风控特殊考量:

  1. 关联分析查询:风控需查 "某地址关联的所有用户",但表按用户分片,地址查询需全分片扫描。解决方案:

    • 建立异构索引表:address_index 按地址分片,存储 address → user_id 映射
    • 使用 Elasticsearch 做二级索引,MySQL 只存主事务数据
  2. 时间窗口聚合:实时规则需统计 "过去 1 小时某用户交易金额"。按用户分片时单分片可计算;若按时间分片则需跨分片。解决方案:

    • 实时特征用 Redis 滑动窗口预聚合,不走 DB
    • 离线特征用 StarRocks MPP 计算
  3. 黑名单/名单查询:全局名单(如制裁地址)需全量匹配。解决方案:

    • 名单量小(< 1000 万):全量加载到本地缓存(Caffeine)
    • 名单量大:用 Redis BloomFilter 预过滤,DB 只查可疑命中

5.2 常见误区 vs 正确做法

❌ 误区✅ 正确做法
分片数越多越好(1024 张表)根据数据量规划,单表 500-1000 万行为宜;过多表增加元数据开销
用自增 ID 做主键分片后必须全局唯一 ID(Snowflake/Leaf),自增 ID 会冲突
分片键选 UUIDUUID 随机导致页分裂严重;应选趋势递增的雪花 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。解决方案:

  1. 等待策略:检测到回拨时阻塞等待至上次时间戳(适合小幅回拨 < 5ms)
  2. 异常策略:回拨超过阈值直接抛异常,上层重试或降级(美团 Leaf-Snowflake)
  3. 序列号预留:每毫秒序列号只用 0-2047,回拨时用 2048-4095 区间(百度 UidGenerator)
  4. 硬件时钟:使用 Chrony 精细同步,避免大幅回拨

生产兜底:

  • 多机部署时,某节点时钟异常可快速摘除(健康检查)
  • ID 生成服务独立部署,不依赖业务机器时钟
  • 数据库唯一索引兜底,即使重复 ID 写入也会报错

Q3:分片后如何做全局唯一约束?比如 trade_no 必须全局唯一。

答:分片后单库唯一索引只能保证本分片唯一,需额外机制:

  1. 全局表(Global Table):建一张 trade_no_unique 全局表,所有分片写之前先查/插全局表。缺点:全局表成瓶颈。
  2. 分布式锁 + 唯一索引:用 Redis RedLock 获取锁,再插入本分片唯一索引。缺点:引入外部依赖。
  3. Snowflake 融入业务码:将业务标识(如币种、交易类型)编码进 ID,保证全局唯一,无需额外校验。
  4. 后置对账:允许短暂重复,异步对账修复(最终一致)。适合风控日志等非强一致场景。

推荐:方案 3 为主(ID 天然唯一),方案 4 为辅(核心业务对账兜底)。


Q4:分片后扩容从 4 库扩到 8 库,数据怎么迁移?如何做到不停机?

答:标准流程(见 2.5 节时序图):

  1. 存量同步:用 Apache SeaTunnel / DataX 按新规则(user_id % 8)全量导出导入
  2. 增量同步:Canal / Debezium 订阅旧库 Binlog,实时写入新库
  3. 数据校验:抽样比对 + MD5 校验全量数据
  4. 双写阶段:应用同时写新旧库,读旧库
  5. 灰度切读:按用户维度(如 user_id % 1000 < 10)逐步切读新库,观察延迟和错误率
  6. 全量切换: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:分库分表后,分布式事务怎么解决?风控场景对一致性要求高,能用最终一致吗?

答:分片后单机事务变成分布式事务,方案按一致性强度排序:

  1. 强一致(2PC/XA):Seata AT 模式,性能差(RT + 2-3 倍),风控实时拦截链路不适合
  2. 柔性事务(TCC/Saga):业务层实现 Try/Confirm/Cancel,复杂度高,适合资金结算
  3. 本地消息表:事务内写业务表 + 消息表,异步投递,最终一致。适合风控事件推送
  4. 最大努力通知 + 对账:允许短暂不一致,日终对账修复

风控场景决策:

  • 实时拦截(< 50ms):单分片事务 + 异步补偿,不强求跨分片事务
  • 资金冻结/扣减:TCC 或 Saga,确保扣减可回滚
  • 日志/特征写入:本地消息表 + Kafka,最终一致即可

核心原则:风控系统的决策链路尽量设计为单分片操作(按用户维度聚合),从根本上避免分布式事务。


Q7:如果某用户是超级大户,交易频率极高,导致单分片热点怎么办?

答:分片热点是 Hash 分片的经典问题,解决方案:

  1. 热点探测 + 自动分片:监控单分片 QPS,超过阈值时将热点用户数据迁移到独立分片(类似 Redis Cluster 的 resharding)
  2. 二级哈希:对热点用户再细分,如 user_id = 123 的数据再按 trade_no % 4 拆成 4 张子表
  3. 读写分离 + 缓存:热点数据全量缓存到 Redis,读请求走缓存,写请求仍走主分片
  4. 业务限流:对单用户交易频率做硬限流(如 100 TPS),从源头控制

大型加密货币交易所 场景:交易所对 API 高频交易有明确限频(如 1200 weight/min),天然限制了单用户热点。


附录:分片选型决策树

数据量是否超过 5000 万?
├── 否 → 单库优化(索引 + 缓存 + 读写分离)
└── 是 → 业务模块是否多?
    ├── 是 → 垂直拆分(按业务分库)
    └── 否 → 查询是否以某字段为主?
        ├── 否 →  reconsider 是否真的需要分片
        └── 是 → 该字段是否离散均匀?
            ├── 否 → 考虑一致性 Hash 或 Range
            └── 是 → Hash 取模分片
                → 是否需要跨维度查询?
                    ├── 是 → 异构索引表 / ES 二级索引
                    └── 否 → 标准分片 + 全局 ID

记忆口诀:

  • 垂直拆 = 分学科建分馆(业务解耦)
  • 水平拆 = 同科书分两馆(数据分散)
  • 分片键 = 查书时先想按什么找(查询模式决定)
  • 雪花 ID = 时间 + 地点 + 编号(三要素全局唯一)
  • 扩容 = 先开新馆同步书,再逐步引导读者(双写灰度)