你沒見過的分庫分表原理決議和解決方案(一)

高并發三駕馬車:分庫分表、MQ、快取，今天給大家帶來的就是分庫分表的干貨解決方案,哪怕你不用我的框架也可以從中聽到不一樣的結局方案和實作，

一款支持自動分表分庫的orm框架easy-query 幫助您解脫跨庫帶來的復雜業務代碼,并且提供多種結局方案和自定義路由來實作比中間件更高性能的資料庫訪問，

GITHUB github地址 https://github.com/xuejmnet/easy-query
GITEE gitee地址 https://gitee.com/xuejm/easy-query

上篇文章簡單的帶大家了解了框架如何使用分片本章將會以理論為主加實踐的方式呈現不一樣的分表分庫，

介紹

分庫分表一直是老生常談的問題,市面上也有很多人侃侃而談,但是大部分的說辭都是一樣,甚至給不出一個實際的解決方案,本人經過多年的深耕在其他語言里面多年的維護和實踐下來秉著happy coding的原則希望更多的人可以了解和認識到該框架并且給大家一個全新的針對分庫分表的認識，
我們也經常戲稱專案一開始就用了分庫分表結果上線沒多少資料,并且整個開發體驗來說非常繁瑣,對于業務而言也是極其不友好,大大拉長開發周期不說,bug也是更加容易產生,針對上述問題該框架給出了一個非常完美的實作來極大程度上的給用戶完美的體驗

分片存盤
- 插入
- 更新洗掉
分片查詢
- 單分片表查詢
- 跨分片表查詢
- 跨分片排序
- 跨分片分組
- 跨分片分頁

分片存盤

分庫分表簡單的實作目前大部分框架已經都可以實作了,就是動態表名來實作分表下的簡單存盤,如果是分庫下面的那么就使用動態資料源來切換實作,如果是分庫加分表就用動態資料源加動態表名來實作，聽上去是不是很完美,但是實際情況下你需要表寫非常繁多的業務代碼,并且會讓整個開發精力全部集中在分庫分表下,針對后期的維護也是非常麻煩的一件事，
但是分庫分表的分片規則又是和具體業務耦合的所以合理的解耦分片路由是一件非常重要的事情，

插入

假設我們按訂單id進行分表存盤

通過上述圖片我們可以很清晰的了解到分片插入的執行原理,通過攔截執行sql分析對應的值計算出所屬表名,然后改寫表名進行插入，該實作方法有一個弊端就是如果插入資料是increment的自增型別,那么這種方法將不適合,因為自增主鍵只有在插入資料庫后才會正真的被確定是什么值,可以通過攔截器設定自定義自增撥號器來實作偽自增，這樣也可以實作“自增”列，

更新洗掉)

這邊假設我們也是按照訂單id進行分表更新

更新分片鍵

一模一樣的處理,將sql進行攔截后決議where和分片欄位id然后計算后將結果發送到對應路由的表中進行執行，

那么如果我們沒辦法進行路由確定呢,如果我們使用created欄位來更新的那么會發生生呢

更新非分片鍵

為了得到正確的結果需要將每條sql進行改寫分別發送到對應的表中,然后將各自表的執行結果進行聚合回傳最終受影響行數

分片查詢

眾所周知分庫分表的難點并不在如何存盤資料到對應的db,也不在于如何更新指定物體資料,因為他們都可以通過分片鍵的計算來重新路由,可以讓分片的操作降為單表操作,所以orm只需要支持動態表名那么以上所有功能都是支持的，
但是實際情況缺是如果orm或者中間件只支持到了這個級別那么對于稍微復雜一點的業務你必須要撰寫大量的業務代碼來實作業務需要的查詢,并且會浪費大量的重復作業和精力

單分片表查詢

加下來我來講解單分片表查詢,其實原理和上面的insert一樣

到這里為止其實都是ok的并沒有什么問題.但是如果我們的本次查詢需要跨分片呢比如跨兩個分片那么應該如何處理

跨分片表查詢

到這一步我們已經將對應的資料路由到對應的資料庫了,那么我們應該如何獲取自己想要的結果呢

通過上圖我們可以了解到在跨分片的聚合下我們可以分表通過對a,b兩張表進行查詢可以并行可以串行,最終將結果匯聚到同一個集合那么回傳給用戶端就是一個完整的資料包,并沒有缺少任何資料

跨分片排序

基于上述分片聚合方式我們清晰的了解到如何可以進行跨分片下降資料獲取到記憶體中，但是通過圖中結果可以清晰的了解到回傳的資料并不像我們預期的那樣有序,那是因為各個節點下的所有資料都是僅遵循各自節點的資料庫排序而不受其他節點分片影響，
那么如果我們對資料進行分片聚合+排序那么又會是什么樣的場景呢

方案一記憶體排序

首先我們將執行sql分別路由到t_order_1和t_order_2兩張表,并且執行order by id desc將其資料id大的排在前面這樣可以保證單個Connection的ResultSet肯定是大的先被回傳
所以在單個Connection下結果是正確的但是因為多個分片節點間沒有互動所以當取到記憶體中后資料依然是亂的,所以這邊需要對sql進行攔截獲取排序欄位并且將其在記憶體中的集合里面實作,這樣我們就做到了和排序欄位一樣的回傳結果

方案二流式排序

大部分orm到這邊就為止了,畢竟已經實作了完美的節點處理,但是我們來看他需要消耗的性能事多少,假設我們分片命中2個節點,每個節點各自回傳2條資料,我們對于整個ResultSet的遍歷將是每個鏈接都是2那么就是4次，然后在記憶體中在進行排序如果性能差一點還需要多次所以這個是相對比較浪費性能的,因為如果我們有1000條資料回傳那么記憶體中的排序是很高效的但是這個也是我們這次需要講解的更加高效的排序處理流式排序

相較于記憶體排序這種方式十分復雜并且繁瑣,而且對于用戶也很不好理解,但是如果你獲取的資料是分頁,那么記憶體排序進行獲取結果將會變得非常危險,有可能導致記憶體資料過大從而導致程式崩潰

無order欄位

到這邊不要以為跨分片聚合已經結束了因為當你的sql查詢order by了一個select不存在的欄位,那么上述兩種排序方式都將無法使用,因為程式獲取到的結果集并沒有排序欄位,這個時候一般我們會改寫sql讓其select的時候必須要帶上對應的order by欄位這樣就可以保證我們資料的正確回傳

以下兩個問題因為涉及到過多內容本章節無法呈現所以將會在下一章給出具體解決方案

跨分片分組

如果我們程式遇到了這個那么我們該如何處理呢

跨分片分頁

業務中常常需要的跨分片分頁我們該如何解決,easy-query又如何處理這種情況,如果跨的分片過多我們又該怎么辦,

如何解決深分頁問題
如何解決流式瀑布問題
如何進行分頁快取高效獲取問題

接下來將在下篇文章中一一解答近

最后

我這邊將演示easy-query在本次分片理論中的實際應用
這次采用h2資料庫作為演示

CREATE TABLE IF NOT EXISTS `t_order_0`
(
    `id`  INTEGER PRIMARY KEY,
    `status`       Integer,
    `created` VARCHAR(100)
    );
CREATE TABLE IF NOT EXISTS `t_order_1`
(
    `id`  INTEGER PRIMARY KEY,
    `status`       Integer,
    `created` VARCHAR(100)
    );
CREATE TABLE IF NOT EXISTS `t_order_2`
(
    `id`  INTEGER PRIMARY KEY,
    `status`       Integer,
    `created` VARCHAR(100)
    );
CREATE TABLE IF NOT EXISTS `t_order_3`
(
    `id`  INTEGER PRIMARY KEY,
    `status`       Integer,
    `created` VARCHAR(100)
    );
CREATE TABLE IF NOT EXISTS `t_order_4`
(
    `id`  INTEGER PRIMARY KEY,
    `status`       Integer,
    `created` VARCHAR(100)
    );

安裝maven依賴


        <dependency>
            <groupId>com.easy-query</groupId>
            <artifactId>sql-h2</artifactId>
            <version>0.9.32</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.easy-query</groupId>
            <artifactId>sql-api4j</artifactId>
            <version>0.9.32</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.199</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

創建物體物件對應資料庫


@Data
@Table(value = "https://www.cnblogs.com/xuejiaming/p/t_order",shardingInitializer = H2OrderShardingInitializer.class)
public class H2Order {
    @Column(primaryKey = true)
    @ShardingTableKey
    private Integer id;
    private Integer status;
    private String created;
}
// 分片初始化器

public class H2OrderShardingInitializer extends AbstractShardingTableModInitializer<H2Order> {
    @Override
    protected int mod() {
        return 5;//模5
    }

    @Override
    protected int tailLength() {
        return 1;//表后綴長度1位
    }
}
//分片路由規則

public class H2OrderRule extends AbstractModTableRule<H2Order> {
    @Override
    protected int mod() {
        return 5;
    }

    @Override
    protected int tailLength() {
        return 1;
    }
}

創建datasource和easyquery

   orderShardingDataSource=DataSourceFactory.getDataSource("dsorder","h2-dsorder.sql");
   EasyQueryClient easyQueryClientOrder = EasyQueryBootstrapper.defaultBuilderConfiguration()
                .setDefaultDataSource(orderShardingDataSource)
                .optionConfigure(op -> {
                    op.setMaxShardingQueryLimit(10);
                    op.setDefaultDataSourceName("ds2020");
                    op.setDefaultDataSourceMergePoolSize(20);
                })
                .build();
      EasyQuery   easyQueryOrder = new DefaultEasyQuery(easyQueryClientOrder);

        QueryRuntimeContext runtimeContext = easyQueryOrder.getRuntimeContext();
        QueryConfiguration queryConfiguration = runtimeContext.getQueryConfiguration();
        queryConfiguration.applyShardingInitializer(new H2OrderShardingInitializer());//添加分片初始化器
        TableRouteManager tableRouteManager = runtimeContext.getTableRouteManager();
        tableRouteManager.addRouteRule(new H2OrderRule());//添加分片路由規則

插入代碼


  ArrayList<H2Order> h2Orders = new ArrayList<>();
  for (int i = 0; i < 100; i++) {
      H2Order h2Order = new H2Order();
      h2Order.setId(i);
      h2Order.setStatus(i%3);
      h2Order.setCreated(String.valueOf(i));
      h2Orders.add(h2Order);
  }
  easyQueryOrder.insertable(h2Orders).executeRows();

==> main, name:ds2020, Preparing: INSERT INTO t_order_3 (id,status,created) VALUES (?,?,?)
==> main, name:ds2020, Parameters: 0(Integer),0(Integer),0(String)
<== main, name:ds2020, Total: 1
==> main, name:ds2020, Preparing: INSERT INTO t_order_4 (id,status,created) VALUES (?,?,?)
==> main, name:ds2020, Parameters: 1(Integer),1(Integer),1(String)
<== main, name:ds2020, Total: 1
==> main, name:ds2020, Preparing: INSERT INTO t_order_0 (id,status,created) VALUES (?,?,?)
==> main, name:ds2020, Parameters: 2(Integer),2(Integer),2(String)
<== main, name:ds2020, Total: 1
==> main, name:ds2020, Preparing: INSERT INTO t_order_1 (id,status,created) VALUES (?,?,?)
==> main, name:ds2020, Parameters: 3(Integer),0(Integer),3(String)
<== main, name:ds2020, Total: 1
==> main, name:ds2020, Preparing: INSERT INTO t_order_2 (id,status,created) VALUES (?,?,?)
==> main, name:ds2020, Parameters: 4(Integer),1(Integer),4(String)
.....省略

       List<H2Order> list = easyQueryOrder.queryable(H2Order.class)
                .where(o -> o.in(H2Order::getId, Arrays.asList(1, 2, 6, 7)))
                .toList();
        Assert.assertEquals(4,list.size());

==> SHARDING_EXECUTOR_2, name:ds2020, Preparing: SELECT id,status,created FROM t_order_3 WHERE id IN (?,?,?,?)
==> SHARDING_EXECUTOR_4, name:ds2020, Preparing: SELECT id,status,created FROM t_order_0 WHERE id IN (?,?,?,?)
==> SHARDING_EXECUTOR_3, name:ds2020, Preparing: SELECT id,status,created FROM t_order_4 WHERE id IN (?,?,?,?)
==> SHARDING_EXECUTOR_1, name:ds2020, Preparing: SELECT id,status,created FROM t_order_2 WHERE id IN (?,?,?,?)
==> SHARDING_EXECUTOR_4, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
==> SHARDING_EXECUTOR_5, name:ds2020, Preparing: SELECT id,status,created FROM t_order_1 WHERE id IN (?,?,?,?)
==> SHARDING_EXECUTOR_3, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
==> SHARDING_EXECUTOR_5, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
==> SHARDING_EXECUTOR_1, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
==> SHARDING_EXECUTOR_2, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
<== SHARDING_EXECUTOR_2, name:ds2020, Time Elapsed: 0(ms)
<== SHARDING_EXECUTOR_5, name:ds2020, Time Elapsed: 0(ms)
<== SHARDING_EXECUTOR_1, name:ds2020, Time Elapsed: 1(ms)
<== SHARDING_EXECUTOR_4, name:ds2020, Time Elapsed: 1(ms)
<== SHARDING_EXECUTOR_3, name:ds2020, Time Elapsed: 1(ms)
<== Total: 4
``
通過上述sql展示我們可以清晰的看到哪個執行緒執行了哪個資料源(分片下會不一樣),執行了什么sql,最終執行消耗多少時間引數是多少,一共回傳多少條資料
分片排序
```java
  List<H2Order> list = easyQueryOrder.queryable(H2Order.class)
                .where(o -> o.in(H2Order::getId, Arrays.asList(1, 2, 6, 7)))
                .orderByDesc(o->o.column(H2Order::getId))
                .toList();
  Assert.assertEquals(4,list.size());
  Assert.assertEquals(7,(int)list.get(0).getId());
  Assert.assertEquals(6,(int)list.get(1).getId());
  Assert.assertEquals(2,(int)list.get(2).getId());
  Assert.assertEquals(1,(int)list.get(3).getId());

==> SHARDING_EXECUTOR_1, name:ds2020, Preparing: SELECT id,status,created FROM t_order_1 WHERE id IN (?,?,?,?) ORDER BY id DESC
==> SHARDING_EXECUTOR_5, name:ds2020, Preparing: SELECT id,status,created FROM t_order_3 WHERE id IN (?,?,?,?) ORDER BY id DESC
==> SHARDING_EXECUTOR_4, name:ds2020, Preparing: SELECT id,status,created FROM t_order_2 WHERE id IN (?,?,?,?) ORDER BY id DESC
==> SHARDING_EXECUTOR_3, name:ds2020, Preparing: SELECT id,status,created FROM t_order_4 WHERE id IN (?,?,?,?) ORDER BY id DESC
==> SHARDING_EXECUTOR_5, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
==> SHARDING_EXECUTOR_1, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
==> SHARDING_EXECUTOR_4, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
==> SHARDING_EXECUTOR_2, name:ds2020, Preparing: SELECT id,status,created FROM t_order_0 WHERE id IN (?,?,?,?) ORDER BY id DESC
==> SHARDING_EXECUTOR_3, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
==> SHARDING_EXECUTOR_2, name:ds2020, Parameters: 1(Integer),2(Integer),6(Integer),7(Integer)
<== SHARDING_EXECUTOR_1, name:ds2020, Time Elapsed: 0(ms)
<== SHARDING_EXECUTOR_5, name:ds2020, Time Elapsed: 0(ms)
<== SHARDING_EXECUTOR_4, name:ds2020, Time Elapsed: 0(ms)
<== SHARDING_EXECUTOR_2, name:ds2020, Time Elapsed: 0(ms)
<== SHARDING_EXECUTOR_3, name:ds2020, Time Elapsed: 0(ms)
<== Total: 4

最后的最后

附上原始碼地址,原始碼中有檔案和對應的qq群,如果決定有用請點擊star謝謝大家了

GITHUB github地址 https://github.com/xuejmnet/easy-query
GITEE gitee地址 https://gitee.com/xuejm/easy-query

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/554511.html

標籤：Java

上一篇：【QCustomPlot】下載

下一篇：返回列表