MySql分库分表深度指南之从策略到落地

# sharding-proxy 配置示例（透明代理）
schemaName: order_db
dataSources:
  ds_0: { url: jdbc:mysql://db0:3306/order_db0, ... }
  ds_1: { url: jdbc:mysql://db1:3306/order_db1, ... }
rules:
  - !SHARDING
    tables:
      orders:
        actualDataNodes: ds_${0..1}.orders_${0..15}
        tableStrategy:
          standard:
            shardingColumn: order_id
            shardingAlgorithmName: gene_hash
shardingAlgorithms:
  gene_hash:
    type: CLASS_BASED
    props:
      strategy: standard
      algorithmClassName: com.example.GeneShardingAlgorithm

<schema name="order_db" checkSQLschema="true">
    <table name="orders" dataNode="dn$0-15" rule="mod-long" />
</schema>
<dataNode name="dn0" dataHost="dh0" database="order_db0" />
<dataNode name="dn1" dataHost="dh0" database="order_db1" />
<dataHost name="dh0" balance="1" writeType="0" dbType="mysql">
    <writeHost host="hostM1" url="db0:3306" user="root" password="xxx"/>
    <readHost host="hostS1" url="db1:3306" user="root" password="xxx"/>
</dataHost>

-- 错误：status 只有 3 个值，导致 3 个分片成为热点
PARTITION BY HASH(status) PARTITIONS 64; -- 只有 3 个分区有数据
-- 正确：user_id 哈希，数据均匀分布
PARTITION BY HASH(user_id) PARTITIONS 64;

订单系统高频查询：
1. 用户查历史订单 → 必须带 user_id ✅
2. 商家查订单 → 必须带 merchant_id ✅
3. 客服按订单号查 → 必须带 order_no ✅
分片键选择：user_id（覆盖场景最多）

-- 错误：手机号可能变更，导致数据迁移
-- 正确：user_id 是主键，永不改变

// 64位ID结构：符号位(1) + 时间戳(41) + 分片基因(12) + 序列号(10)
public class OrderIdGenerator {
    private static final int GENE_BITS = 12; // 12位基因支持4096个分片
    public static long generateId(long userId) {
        long timestamp = System.currentTimeMillis() - 1288834974657L;
        long gene = userId & ((1 << GENE_BITS) - 1); // 提取user_id后12位作为基因
        long sequence = getNextSequence();
        return (timestamp << 22) | (gene << 10) | sequence;
    }
    // 从订单ID反推分片位置
    public static int getShardKey(long orderId) {
        return (int) ((orderId >> 10) & 0xFFF); // 提取中间12位基因
    }
}

public class OrderShardingRouter {
    private static final int DB_COUNT = 8;          // 8个库
    private static final int TABLE_COUNT = 16;      // 每库16张表
    public static String route(long orderId) {
        int gene = OrderIdGenerator.getShardKey(orderId);
        int dbIndex = gene % DB_COUNT;              // 基因决定库
        int tableIndex = gene % TABLE_COUNT;        // 基因决定表
        return String.format("order_db_%d.orders_%d", dbIndex, tableIndex);
    }
}

// 使用 Ketama 算法
public class ConsistentHashSharding {
    private final SortedMap<Long, String> circle = new TreeMap<>();
    public void addServer(String server) {
        for (int i = 0; i < 160; i++) { // 160个虚拟节点
            circle.put(hash(server + "-" + i), server);
        }
    }
    public String getServer(Long key) {
        if (circle.isEmpty()) return null;
        long hash = hash(key);
        SortedMap<Long, String> tailMap = circle.tailMap(hash);
        hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        return circle.get(hash);
    }
}

位段分布：
0-0   : 符号位（1位，始终为0）
1-41  : 时间戳（41位，支持69年，从2020起算）
42-52 : 机器ID（10位，支持1024个节点）
53-63 : 序列号（12位，每毫秒4096个ID）

0-0   : 符号位（1位）
1-41  : 时间戳（41位）- 支持到 2089年
42-53 : 分片基因（12位）- 支持4096个分片
54-63 : 序列号（10位）- 每毫秒1024个ID

public class GeneSnowflake {
    private final long twepoch = 1288834974657L; // 起始时间戳
    private final long geneBits = 12L;           // 基因位数
    private final long sequenceBits = 10L;       // 序列号位数
    private final long geneShift = sequenceBits; // 基因左移10位
    private final long timestampShift = geneBits + sequenceBits; // 时间戳左移22位
    public synchronized long nextId(long userId) {
        long timestamp = System.currentTimeMillis();
        long gene = userId & ((1 << geneBits) - 1); // 提取基因
        long sequence = getSequenceInSameMs(timestamp); // 毫秒内序列号
        return ((timestamp - twepoch) << timestampShift) |
               (gene << geneShift) |
               sequence;
    }
}

// 提取基因（分片键）
public static int extractGene(long orderId) {
    // 基因位于第10-21位：orderId >> 10 & 0xFFF
    return (int) ((orderId >> 10) & 0xFFF);
}
// 提取生成时间
public static Date extractTime(long orderId) {
    long timestamp = (orderId >> 22) + twepoch;
    return new Date(timestamp);
}
// 完整路由示例
public class OrderService {
    public Order getOrderById(long orderId) {
        int gene = extractGene(orderId);
        String dbTable = OrderShardingRouter.routeByGene(gene);
        return executeQuery("SELECT * FROM " + dbTable + " WHERE order_id = ?", orderId);
    }
}

{
  "order_index": {
    "mappings": {
      "properties": {
        "order_no": { "type": "keyword" },
        "shard_key": { "type": "integer" },  // 分片基因
        "user_id": { "type": "long" },
        "merchant_id": { "type": "long" }
      }
    }
  }
}

// 商家查询订单（先查ES定位分片）
public List<Order> getOrdersByMerchant(Long merchantId) {
    // 1. ES 中查询 shard_key
    SearchResponse response = esClient.search(
        new SearchRequest("order_index")
            .source(new SearchSourceBuilder()
                .query(QueryBuilders.termQuery("merchant_id", merchantId))
                .fetchField("shard_key")
                .size(10000))
    );
    // 2. 按 shard_key 分组
    Map<Integer, List<Long>> shardGroups = groupByShard(response);
    // 3. 并发查询各分片
    return shardGroups.entrySet().parallelStream()
        .map(entry -> queryShard(entry.getKey(), entry.getValue()))
        .flatMap(List::stream)
        .collect(Collectors.toList());
}

-- 创建全局索引（自动同步到指定存储节点）
CREATE SHARDING GLOBAL INDEX idx_merchant ON orders(merchant_id)
    BY SHARDING_ALGORITHM(merchant_hash)
    WITH STORAGE_UNIT(ds_0, ds_1);
-- 查询时自动路由
SELECT * FROM orders WHERE merchant_id = 10086;
-- ShardingSphere 自动改写为：先查 GSI 表获取 order_id，再路由到主表

写操作（Command）：
  应用服务 → 分片路由 → 写入分片库
读操作（Query）：
  应用服务 → ES/HBase → 聚合结果

public void createOrder(Order order) {
    try {
        // 1. 写新库（主库）
        orderNewDao.insert(order);
        // 2. 写旧库（备份）
        orderOldDao.insert(order);
    } catch (Exception e) {
        // 3. 新库失败必须回滚旧库
        if (isNewSuccess()) {
            orderNewDao.delete(order.getId());
        }
        throw e;
    }
}

// 动态分片路由（按用户ID灰度）
public String routeByUserId(Long userId) {
    if (userId <= 10000) { // 1%用户切新库
        return "order_new";
    } else {
        return "order_old";
    }
}

-- 复合分片键：(merchant_id + user_id) % 1024
-- 路由逻辑：将大商家数据按 user_id 二次打散
public int getShardKey(long merchantId, long userId) {
    if (isBigMerchant(merchantId)) {
        return (int) ((merchantId * 31 + userId) % 1024);
    } else {
        return (int) (merchantId % 1024);
    }
}

@Transactional
public void createOrder(Order order) {
    // 1. 本地事务：写订单主库
    orderDao.insert(order);
    // 2. 发送事务消息（半消息）
    TransactionSendResult result = rocketMQTemplate.sendMessageInTransaction(
        "order_create_event",
        MessageBuilder.withPayload(order.toJson()).build(),
        null
    );
    // 3. 消息确认后，下游消费加积分、扣库存
}
// 消费者异步处理
@RocketMQMessageListener(topic = "order_create_event")
public void handleEvent(OrderEvent event) {
    bonusService.addPoints(event.getUserId());      // 异步加积分
    inventoryService.deduct(event.getSkuId());      // 异步扣库存
}

-- 方案1：业务折衷（禁用深分页，仅支持前100页）
-- 方案2：ES 聚合查询（推荐）
GET /order_index/_search
{
  "from": 100,
  "size": 10,
  "sort": [{"create_time": "desc"}]
}
-- 方案3：游标分页（记录上次查询的 order_id）
SELECT * FROM orders 
WHERE create_time < '2024-01-01' AND order_id < #{lastOrderId}
ORDER BY create_time DESC LIMIT 10;

// 基因分片是订单系统的最佳拍档
// 12位基因支持 4096 个分片 = 8库 × 16表 × 32冗余

-- 初始设计：8库 × 16表 = 128分片
-- 支持单分片 500万行 → 总容量 6.4亿行
-- 预留 2 年数据增长

// 小表（<1000万行）无需分片
// 大表关联查询：优先冗余字段，避免跨分片 JOIN

-- 监控分片倾斜率
SELECT db, table_name, COUNT(*) AS rows 
FROM information_schema.tables 
WHERE table_schema LIKE 'order_db_%' 
GROUP BY db, table_name 
HAVING rows > AVG(rows) * 1.5; -- 找出超平均分片50%的热点