# 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>

-- 錯(cuò)誤：status 只有 3 個(gè)值，導(dǎo)致 3 個(gè)分片成為熱點(diǎn)
PARTITION BY HASH(status) PARTITIONS 64; -- 只有 3 個(gè)分區(qū)有數(shù)據(jù)
-- 正確：user_id 哈希，數(shù)據(jù)均勻分布
PARTITION BY HASH(user_id) PARTITIONS 64;

訂單系統(tǒng)高頻查詢：
1. 用戶查歷史訂單 → 必須帶 user_id ?
2. 商家查訂單 → 必須帶 merchant_id ?
3. 客服按訂單號(hào)查 → 必須帶 order_no ?
分片鍵選擇：user_id（覆蓋場(chǎng)景最多）

-- 錯(cuò)誤：手機(jī)號(hào)可能變更，導(dǎo)致數(shù)據(jù)遷移
-- 正確：user_id 是主鍵，永不改變

// 64位ID結(jié)構(gòu)：符號(hào)位(1) + 時(shí)間戳(41) + 分片基因(12) + 序列號(hào)(10)
public class OrderIdGenerator {
    private static final int GENE_BITS = 12; // 12位基因支持4096個(gè)分片
    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個(gè)庫(kù)
    private static final int TABLE_COUNT = 16;      // 每庫(kù)16張表
    public static String route(long orderId) {
        int gene = OrderIdGenerator.getShardKey(orderId);
        int dbIndex = gene % DB_COUNT;              // 基因決定庫(kù)
        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個(gè)虛擬節(jié)點(diǎn)
            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   : 符號(hào)位（1位，始終為0）
1-41  : 時(shí)間戳（41位，支持69年，從2020起算）
42-52 : 機(jī)器ID（10位，支持1024個(gè)節(jié)點(diǎn)）
53-63 : 序列號(hào)（12位，每毫秒4096個(gè)ID）

0-0   : 符號(hào)位（1位）
1-41  : 時(shí)間戳（41位）- 支持到 2089年
42-53 : 分片基因（12位）- 支持4096個(gè)分片
54-63 : 序列號(hào)（10位）- 每毫秒1024個(gè)ID

public class GeneSnowflake {
    private final long twepoch = 1288834974657L; // 起始時(shí)間戳
    private final long geneBits = 12L;           // 基因位數(shù)
    private final long sequenceBits = 10L;       // 序列號(hào)位數(shù)
    private final long geneShift = sequenceBits; // 基因左移10位
    private final long timestampShift = geneBits + sequenceBits; // 時(shí)間戳左移22位
    public synchronized long nextId(long userId) {
        long timestamp = System.currentTimeMillis();
        long gene = userId & ((1 << geneBits) - 1); // 提取基因
        long sequence = getSequenceInSameMs(timestamp); // 毫秒內(nèi)序列號(hào)
        return ((timestamp - twepoch) << timestampShift) |
               (gene << geneShift) |
               sequence;
    }
}

// 提取基因（分片鍵）
public static int extractGene(long orderId) {
    // 基因位于第10-21位：orderId >> 10 & 0xFFF
    return (int) ((orderId >> 10) & 0xFFF);
}
// 提取生成時(shí)間
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. 并發(fā)查詢各分片
    return shardGroups.entrySet().parallelStream()
        .map(entry -> queryShard(entry.getKey(), entry.getValue()))
        .flatMap(List::stream)
        .collect(Collectors.toList());
}

-- 創(chuàng)建全局索引（自動(dòng)同步到指定存儲(chǔ)節(jié)點(diǎn)）
CREATE SHARDING GLOBAL INDEX idx_merchant ON orders(merchant_id)
    BY SHARDING_ALGORITHM(merchant_hash)
    WITH STORAGE_UNIT(ds_0, ds_1);
-- 查詢時(shí)自動(dòng)路由
SELECT * FROM orders WHERE merchant_id = 10086;
-- ShardingSphere 自動(dòng)改寫為：先查 GSI 表獲取 order_id，再路由到主表

寫操作（Command）：
  應(yīng)用服務(wù) → 分片路由 → 寫入分片庫(kù)
讀操作（Query）：
  應(yīng)用服務(wù) → ES/HBase → 聚合結(jié)果

public void createOrder(Order order) {
    try {
        // 1. 寫新庫(kù)（主庫(kù)）
        orderNewDao.insert(order);
        // 2. 寫舊庫(kù)（備份）
        orderOldDao.insert(order);
    } catch (Exception e) {
        // 3. 新庫(kù)失敗必須回滾舊庫(kù)
        if (isNewSuccess()) {
            orderNewDao.delete(order.getId());
        }
        throw e;
    }
}

// 動(dòng)態(tài)分片路由（按用戶ID灰度）
public String routeByUserId(Long userId) {
    if (userId <= 10000) { // 1%用戶切新庫(kù)
        return "order_new";
    } else {
        return "order_old";
    }
}

-- 復(fù)合分片鍵：(merchant_id + user_id) % 1024
-- 路由邏輯：將大商家數(shù)據(jù)按 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. 本地事務(wù)：寫訂單主庫(kù)
    orderDao.insert(order);
    // 2. 發(fā)送事務(wù)消息（半消息）
    TransactionSendResult result = rocketMQTemplate.sendMessageInTransaction(
        "order_create_event",
        MessageBuilder.withPayload(order.toJson()).build(),
        null
    );
    // 3. 消息確認(rèn)后，下游消費(fèi)加積分、扣庫(kù)存
}
// 消費(fèi)者異步處理
@RocketMQMessageListener(topic = "order_create_event")
public void handleEvent(OrderEvent event) {
    bonusService.addPoints(event.getUserId());      // 異步加積分
    inventoryService.deduct(event.getSkuId());      // 異步扣庫(kù)存
}

-- 方案1：業(yè)務(wù)折衷（禁用深分頁(yè)，僅支持前100頁(yè)）
-- 方案2：ES 聚合查詢（推薦）
GET /order_index/_search
{
  "from": 100,
  "size": 10,
  "sort": [{"create_time": "desc"}]
}
-- 方案3：游標(biāo)分頁(yè)（記錄上次查詢的 order_id）
SELECT * FROM orders 
WHERE create_time < '2024-01-01' AND order_id < #{lastOrderId}
ORDER BY create_time DESC LIMIT 10;

// 基因分片是訂單系統(tǒng)的最佳拍檔
// 12位基因支持 4096 個(gè)分片 = 8庫(kù) × 16表 × 32冗余

-- 初始設(shè)計(jì)：8庫(kù) × 16表 = 128分片
-- 支持單分片 500萬(wàn)行 → 總?cè)萘?6.4億行
-- 預(yù)留 2 年數(shù)據(jù)增長(zhǎng)

// 小表（<1000萬(wàn)行）無(wú)需分片
// 大表關(guān)聯(lián)查詢：優(yōu)先冗余字段，避免跨分片 JOIN

-- 監(jiān)控分片傾斜率
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%的熱點(diǎn)