前言

當資料量到達一定數量級的時候，一般都會考慮分庫分表。sharding-jdbc是一個開源的客戶端分庫分表基礎類庫，以一個jar包的形式提供，基於原生的JDBC驅動進行增強，基本能夠無縫整合舊程式碼，非常的便捷。本小節以一個最簡單的單表查詢淺析概要流程。

建庫建表

訂單表邏輯語名：
CREATE TABLE IF NOT EXISTS t_order (order_id INT NOT NULL, user_id

配置

為簡單起見，使用基本的jdbc進行操作，最精簡的程式碼如下：

public final class SingleSelect {

    public static void main(final String[] args) throws SQLException {
        DataSource dataSource = getOrderShardingDataSource();
        printSingleSelect(dataSource);
    }

    private
 
 static ShardingDataSource getOrderShardingDataSource() {
        DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap());
        TableRule orderTableRule = TableRule.builder("t_order").actualTables(Arrays.asList("t_order_0", "t_order_1")).dataSourceRule(dataSourceRule).build();
        ShardingRule shardingRule = ShardingRule.builder().dataSourceRule(dataSourceRule).tableRules(Arrays.asList(orderTableRule))
                .databaseShardingStrategy(new
 
 DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm()))
                .tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm())).build();
        return new ShardingDataSource(shardingRule);
    }

    private static void printSingleSelect(final DataSource dataSource) throws SQLException {
        String sql = "SELECT * FROM t_order where user_id=? and order_id=?";
        try (
            Connection conn = dataSource.getConnection();
            PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
            preparedStatement.setInt(1, 10);
            preparedStatement.setInt(2, 1001);
            try (ResultSet rs = preparedStatement.executeQuery()) {
                while (rs.next()) {
                    System.out.println(rs.getInt(1));
                    System.out.println(rs.getInt(2));
                    System.out.println(rs.getInt(3));
                }
            }
        }
    }
    private static DataSource createDataSource(final String dataSourceName) {
        BasicDataSource result = new BasicDataSource();
        result.setDriverClassName(com.mysql.jdbc.Driver.class.getName());
        result.setUrl(String.format("jdbc:mysql://127.0.0.1:3306/%s", dataSourceName));
        result.setUsername("root");
        result.setPassword("123456");
        return result;
    }
    private static Map<String, DataSource> createDataSourceMap() {
        Map<String, DataSource> result = new HashMap<>(2);
        result.put("ds_jdbc_0", createDataSource("ds_jdbc_0"));
        result.put("ds_jdbc_1", createDataSource("ds_jdbc_1"));
        return result;
    }
}

分庫分表最主要有幾個配置：
1. 有多少個數據源
2. 每張表的邏輯表名和所有物理表名
3. 用什麼列進行分庫以及分庫演算法
4. 用什麼列進行分表以及分表演算法

本示例定義了兩個資料來源： ds_jdbc_0 和 ds_jdbc_1，定義了邏輯表：t_order，以及物理表：t_order_0 和 t_order_0。採用 user_id列進行分庫，order_id列進行分表。一切準備就緒，我們的目標是執行如下的語句：

SELECT * FROM t_order where user_id=10 and order_id=1001

我們想實現如下的目標：
分庫：
user_id % 2 = 0 的資料儲存到 ds_jdbc_0 ，為1的資料儲存到 ds_jdbc_1
分表：
order_id % 2 = 0 的資料儲存到 t_order_0 ，為1的資料儲存到 t_order_1

這屬於業務的範疇，我們必須清楚告知sharding-jdbc我們的意圖，所以要提供分庫分表策略類，
看看分庫策略類：

public final class ModuloDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Integer> {

    @Override
    public String doEqualSharding(final Collection<String> dataSourceNames, final ShardingValue<Integer> shardingValue) {
        for (String each : dataSourceNames) {
            if (each.endsWith(shardingValue.getValue() % 2 + "")) {
                return each;
            }
        }
        throw new IllegalArgumentException();
    }

    @Override
    public Collection<String> doInSharding(final Collection<String> dataSourceNames, final ShardingValue<Integer> shardingValue) {
        return null;
    }

    @Override
    public Collection<String> doBetweenSharding(final Collection<String> dataSourceNames, final ShardingValue<Integer> shardingValue) {
        return null;
    }
}

由於我們使用了 = 號條件進行查詢，所以只實現了 doEqualSharding 這個方法。程式碼非常簡單，引數dataSourceNames的值為[ds_jdbc_0 , ds_jdbc_1]，而shardingValue在執行的時候可以獲取到 user_id=10這個值，在doEqualSharding 中，我們自己根據user_id的值返回路由的庫的名稱。

接下來看看分表策略類：

public final class ModuloTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Integer> {

    @Override
    public String doEqualSharding(final Collection<String> tableNames, final ShardingValue<Integer> shardingValue) {
        for (String each : tableNames) {
            if (each.endsWith(shardingValue.getValue() % 2 + "")) {
                return each;
            }
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Collection<String> doInSharding(final Collection<String> tableNames, final ShardingValue<Integer> shardingValue) {
        return null;
    }

    @Override
    public Collection<String> doBetweenSharding(final Collection<String> tableNames, final ShardingValue<Integer> shardingValue) {
        return null;
    }
}

一樣實現了 doEqualSharding這個方法，因為我們的條件中有 order_id=1001，在執行回撥時，tableNames的值為[t_order_0 ，t_order_1 ]，我們可以決定如何路由到真實的表名。

流程淺析

先來看個基本的流程圖：

我們再來看看我們的目標sql語句：

SELECT * FROM t_order where user_id=10 and order_id=1001

1. 通過sql解析發現有一張邏輯表名稱：t_order

   發現兩個條件: t_order.userId = 10 和 t_order.order_id = 1001

2. 通過 t_order 找到對應的表配置規則 TableRule，這裡定義了兩個物理表： t_order_0和t_order_1

3. 根據 TableRule找出目標資料來源集合

   通過TableRule找到DatabaseShardingStrategy，得到分庫列：user_id
   通過t_order 和 user_id聯合為key從條件中查詢，找到了t_order.userId = 10，
   再結合引數值(10)，得到分片值
   ShardingValue(logicTableName=t_order, columnName=user_id, value=10)，
   呼叫自定義分庫策略類(傳輸[ds_jdbc_0 , ds_jdbc_1]，ShardingValue)，得到最終的資料來源名稱集合[ds_jdbc_0]

4. 根據TableRule和資料來源 [ds_jdbc_0] 找到物理表

   通過TableShardingStrategy找到表的分片列: order_id
   通過t_order 和 order_id聯合為key從條件中查詢，找到了order_id=1001，再結合引數值(1001)，得到分片值
   ShardingValue(logicTableName=t_order, columnName=order_id, value=1001)，
   呼叫自定義分表策略類(傳輸[t_order_0,t_order_1]，ShardingValue)，得到[ds_jdbc_0]下的最終物理表集合[t_order_1]

5. 根據資料來源和物理表，得到 DataNode的集合

   根據得到的[ds_jdbc_0] 和 [t_order_1]，構建 DataNode集合，每一個DataNode表示 xx庫.xx表，此示例下得到一個DataNode實體: [ds_jdbc_0].[t_order_1]

6. 根據 DataNode生成TableUnits集合

   TableUnit由 邏輯表，物理庫，物理表 三個欄位組成，
   此示例為： t_order 、ds_jdbc_0 、t_order_1

7. SQL重寫

   構建重寫引擎SQLRewriteEngine，根據TableUnits生成對應最終的sql語句執行單元(替換成最終表名)，得到執行單元集合（ExecutionUnits），一個執行單元表示在哪個庫，執行什麼sql語句

8. ExecutionUnits轉換為PreparedStatement，最後又轉為PreparedStatementUnit

9. 執行緒池併發執行PreparedStatementUnit，最後再合併結果返回

多庫單表又如何

通過上面的分析，我們已經知道了單庫單表的基本查詢邏輯，現在把sql簡單調整為：

SELECT * FROM t_order where order_id=1001

這次，我們發現搜尋條件並沒有分庫鍵，這時候，引擎並不會呼叫分庫策略類，直接認定目標庫為[ds_jdbc_0，ds_jdbc_1]，而分表的邏輯是不變的，既然目標庫有兩個，後面生成的DataNode，TableUnits，PreparedStatementUnit 將是以前數量的兩倍，所以這回，引擎最終將會發起多個sql語句的併發執行，併合並最終的結果再返回。

總結

以上基於一個最簡單的查詢拆解了基本的流程，當然，sql解析的細節還是很複雜的，但不是本文關注的重點，本文主要關注一個簡單的sql語句，在sharding-jdbc下是如何達到分庫分表的目的的，後續再分析更多的sql語句的執行。

參考