SpringBoot 2.3 整合最新版 ShardingJdbc + Druid + MyBatis

今天項目不忙，想搞一下shardingJDBC分庫分表看看，主要想實現如下幾點:css

捨棄xml配置，使用.yml或者.properties文件+java的方式配置spring。
使用 Druid 做爲數據庫鏈接池，同時開啓監控界面，並支持監控多數據源。
不依賴 com.dangdang 的 sharding-jdbc-core 包。此包過於古老，最後一次更新在2016年。目測只是封裝了一層，意義不大。感受若是不是dangdang公司內部開發，不必用這個包。（且本人實測不能和最新的Druid包一塊兒用，insert語句報錯）

　　折騰了半天，網上找的例子大部分跑不通。直接本身從零開搞，所有組件直接上當前最新版本。java

　　SpringBoot: 2.3.0mysql

　　mybatis: 2.1.3web

　　druid: 1.1.22算法

　　sharding-jdbc: 4.1.1spring

　　注意：這裏由於是本身邊看源碼邊配置，（sharding官網的例子多是版本問題基本無法用，GitHub 我這裏網絡基本打不開），因此數據源和sharding大部分用java代碼配置。部分配置，應該能夠簡化到 .yml / .properties 文件中。如您有興趣優化，成功後可發一份demo給116269651@qq.com，感謝。sql

Sharding-JDBC簡介

　　Apache ShardingSphere 是一套開源的分佈式數據庫中間件解決方案組成的生態圈，它由 JDBC、Proxy 和 Sidecar（規劃中）這 3 款相互獨立，卻又可以混合部署配合使用的產品組成。數據庫

　　Sharding-JDBC定位爲輕量級 Java 框架，在 Java 的 JDBC 層提供的額外服務。它使用客戶端直連數據庫，以 jar 包形式提供服務，無需額外部署和依賴，可理解爲加強版的 JDBC 驅動，徹底兼容 JDBC 和各類 ORM 框架。apache

適用於任何基於 JDBC 的 ORM 框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template 或直接使用 JDBC。
支持任何第三方的數據庫鏈接池，如：DBCP, C3P0, BoneCP, Druid, HikariCP 等。
支持任意實現JDBC規範的數據庫。目前支持 MySQL，Oracle，SQLServer，PostgreSQL 以及任何遵循 SQL92 標準的數據庫。

Sharding配置示意圖

　　簡單的理解以下圖，對sharding-jdbc進行配置，其實就是對全部須要進行分片的表進行配置。對錶的配置，則主要是對分庫的配置和分表的配置。這裏能夠只分庫不分表，或者只分表不分庫，或者同時包含分庫和分表邏輯。api

　　先看一下個人項目目錄結構總體以下：

1、POM依賴配置

　　完整的pom表以下，其中主要是對 mysql-connector-java、mybatis-spring-boot-starter、druid-spring-boot-starter、sharding-jdbc-core 的依賴。

　　注意：sharding-jdbc-core 我用的4.0+的版本，由於已經晉升爲 apache 基金會的頂級項目，其 groupId 變爲了 org.apache.shardingsphere，以前是io.shardingsphere。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>shardingjdbc</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>shardingjdbc</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <!--<sharding.jdbc.version>3.0.0</sharding.jdbc.version>-->
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.22</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-core</artifactId>
            <version>4.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.5</version>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2、application.properties

　　這裏配置了兩個數據源，目前還沒試過自動裝配多個數據源。爲避免自動裝備產生問題，屬性前綴要和自動裝備掃描的區分開，這裏我用 datasource0 和 datasource1。

　　下面 spring.datasource.druid 開頭的配置，會被 druid 的代碼自動掃描裝配。

#################################### common config : ####################################
spring.application.name=shardingjdbc
# 應用服務web訪問端口
server.port=8080

# mybatis配置
mybatis.mapper-locations=classpath:com/example/shardingjdbc/mapper/*.xml
mybatis.type-aliases-package=com.example.shardingjdbc.**.entity

datasource0.url=jdbc:mysql://localhost:3306/test0?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
datasource0.driver-class-name=com.mysql.cj.jdbc.Driver
datasource0.type=com.alibaba.druid.pool.DruidDataSource
datasource0.username=root
datasource0.password=852278

datasource1.url=jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
datasource1.driver-class-name=com.mysql.cj.jdbc.Driver
datasource1.type=com.alibaba.druid.pool.DruidDataSource
datasource1.username=root
datasource1.password=852278

#
##### 鏈接池配置 #######
# 過濾器設置（第一個stat很重要，沒有的話會監控不到SQL）
spring.datasource.druid.filters=stat,wall,log4j2

##### WebStatFilter配置 #######
#啓用StatFilter
spring.datasource.druid.web-stat-filter.enabled=true
#添加過濾規則
spring.datasource.druid.web-stat-filter.url-pattern=/*
#排除一些沒必要要的url
spring.datasource.druid.web-stat-filter.exclusions=*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*
#開啓session統計功能
spring.datasource.druid.web-stat-filter.session-stat-enable=true
#缺省sessionStatMaxCount是1000個
spring.datasource.druid.web-stat-filter.session-stat-max-count=1000
#spring.datasource.druid.web-stat-filter.principal-session-name=
#spring.datasource.druid.web-stat-filter.principal-cookie-name=
#spring.datasource.druid.web-stat-filter.profile-enable=

##### StatViewServlet配置 #######
#啓用內置的監控頁面
spring.datasource.druid.stat-view-servlet.enabled=true
#內置監控頁面的地址
spring.datasource.druid.stat-view-servlet.url-pattern=/druid/*
#關閉 Reset All 功能
spring.datasource.druid.stat-view-servlet.reset-enable=false
#設置登陸用戶名
spring.datasource.druid.stat-view-servlet.login-username=admin
#設置登陸密碼
spring.datasource.druid.stat-view-servlet.login-password=123
#白名單（若是allow沒有配置或者爲空，則容許全部訪問）
spring.datasource.druid.stat-view-servlet.allow=127.0.0.1
#黑名單（deny優先於allow，若是在deny列表中，就算在allow列表中，也會被拒絕）
spring.datasource.druid.stat-view-servlet.deny=

3、數據源和分片配置

　　以下代碼，先從配置文件讀取數據源的所須要的屬性，而後生成 Druid 數據源。注意這裏配置語句中的 setFilters，若是不添加 filters，則 Duird 監控界面沒法監控到sql。另外，其餘諸如最大鏈接數之類的屬性這裏沒有配，按需配置便可。數據源建立好後，添加到 dataSourceMap 集合中。

　　再往下注釋比較清楚，構造 t_user 表的分片規則（包括分庫規則 + 分表規則），而後將全部表的分片規則組裝成 ShardingRuleConfiguration。

　　最後，將前兩步配好的 dataSourceMap 和 shardingRuleConfiguration 交給 ShardingDataSourceFactory，用來構造數據源。

　　到這裏，sharding 、druid 的配置代碼就都寫好了。剩下基本都是業務代碼了。

package com.example.shardingjdbc.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.example.shardingjdbc.sharding.UserShardingAlgorithm;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.StandardShardingStrategyConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.ShardingDataSourceFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

@Configuration
public class DataSourceConfig {
    @Value("${datasource0.url}")
    private String url0;
    @Value("${datasource0.username}")
    private String username0;
    @Value("${datasource0.password}")
    private String password0;
    @Value("${datasource0.driver-class-name}")
    private String driverClassName0;

    @Value("${datasource1.url}")
    private String url1;
    @Value("${datasource1.username}")
    private String username1;
    @Value("${datasource1.password}")
    private String password1;
    @Value("${datasource1.driver-class-name}")
    private String driverClassName1;

    @Value(("${spring.datasource.druid.filters}"))
    private String filters;

    @Bean("dataSource")
    public DataSource dataSource() {
        try {
            DruidDataSource dataSource0 = new DruidDataSource();
            dataSource0.setDriverClassName(this.driverClassName0);
            dataSource0.setUrl(this.url0);
            dataSource0.setUsername(this.username0);
            dataSource0.setPassword(this.password0);
            dataSource0.setFilters(this.filters);

            DruidDataSource dataSource1 = new DruidDataSource();
            dataSource1.setDriverClassName(this.driverClassName1);
            dataSource1.setUrl(this.url1);
            dataSource1.setUsername(this.username1);
            dataSource1.setPassword(this.password1);
            dataSource1.setFilters(this.filters);

            //分庫設置
            Map<String, DataSource> dataSourceMap = new HashMap<>(2);
            //添加兩個數據庫database0和database1
            dataSourceMap.put("ds0", dataSource0);
            dataSourceMap.put("ds1", dataSource1);

            // 配置 t_user 表規則
            TableRuleConfiguration userRuleConfiguration = new TableRuleConfiguration("t_user", "ds${0..1}.t_user${0..1}");
            // 配置分表規則
            userRuleConfiguration.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("id", UserShardingAlgorithm.tableShardingAlgorithm));
            // 配置分庫規則
            userRuleConfiguration.setDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("id", UserShardingAlgorithm.databaseShardingAlgorithm));
            // Sharding全局配置
            ShardingRuleConfiguration shardingRuleConfiguration = new ShardingRuleConfiguration();
            shardingRuleConfiguration.getTableRuleConfigs().add(userRuleConfiguration);
            // 建立數據源
            DataSource dataSource = ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfiguration, new Properties());
            return dataSource;
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }
}

DataSourceConfig.java

　　上面構造分片規則的時候，我定義了User表的分片算法類 UserShardingAlgorithm，並定義了兩個內部類分別實現了數據庫分片和表分片的邏輯。代碼以下：

package com.example.shardingjdbc.sharding;

import org.apache.shardingsphere.api.sharding.standard.PreciseShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingValue;

import java.util.Collection;

public class UserShardingAlgorithm {
    public static final DatabaseShardingAlgorithm databaseShardingAlgorithm = new DatabaseShardingAlgorithm();
    public static final TableShardingAlgorithm tableShardingAlgorithm = new TableShardingAlgorithm();

    static class DatabaseShardingAlgorithm implements PreciseShardingAlgorithm<Long> {
        @Override
        public String doSharding(Collection<String> databaseNames, PreciseShardingValue<Long> shardingValue) {
            for (String database : databaseNames) {
                if (database.endsWith(String.valueOf(shardingValue.getValue() % 2))) {
                    return database;
                }
            }

            return "";
        }
    }

    static class TableShardingAlgorithm implements PreciseShardingAlgorithm<Long> {
        @Override
        public String doSharding(Collection<String> tableNames, PreciseShardingValue<Long> shardingValue) {
            for (String table : tableNames) {
                if (table.endsWith(String.valueOf(shardingValue.getValue() % 2))) {
                    return table;
                }
            }

            return "";
        }
    }
}

　　這裏實現分片規則時，實現的接口是 PreciseShardingAlgorithm，即精確分片，將指定的鍵值記錄映射到指定的1張表中（最多1張表）。這個接口基本上能知足80%的需求了。

　　其餘的還有 Range、ComplexKey、Hint分片規則，這3種均可以將符合條件的鍵值記錄映射到多張表，便可以將記錄 a 同時插入A、B 或 B、C多張表中。其中，

　　　　Range 是範圍篩選分片。我我的理解，好比id尾數1-5插入A表，6-0插入B表，這種狀況，使用Range做爲篩選條件更方便。也能夠根據時間範圍分片。（若有誤請指正）。

　　　　ComplexKey 看名字就是組合鍵分片，能夠同時根據多個鍵，制定映射規則。

　　　　Hint 看名字沒看懂，但看源碼其實也是組合鍵分片，但僅支持對組合鍵進行精確篩選。

　　　　而 ComplexKey 支持對組合鍵進行範圍篩選。因此能夠理解爲 ComplexKey 是 Hint 的高級版本。　　

　　無論實現哪一種分片算法，都要確保算法覆蓋全部可能的鍵值。

4、使用行表達式配置分片策略（對第三步優化，可略過）

　上面第三步，咱們經過實現 PreciseShardingValue 接口，來定義分片算法。這樣每有一張表須要分片，都要從新定義一個類，太麻煩。

　　Sharding 提供了行表達式配置的方式，對簡單的分片邏輯，直接定義一個行表達式便可。（這種方式其實就是直接在 .yml 文件中配置分片策略的解析方式）

　　和上面的代碼相似，這裏之改動了兩行，直接 new 一個 InlineShardingStrategyConfiguration，省去了定義分片算法類的繁瑣步驟。

// 配置 t_user 表規則
            TableRuleConfiguration userRuleConfiguration = new TableRuleConfiguration("t_user", "ds${0..1}.t_user${0..1}");
            // 行表達式分表規則
            userRuleConfiguration.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("id", "t_user${id % 2}"));
            // 行表達式分庫規則
            userRuleConfiguration.setDatabaseShardingStrategyConfig(new InlineShardingStrategyConfiguration("id", "ds${id % 2}"));

            // Sharding全局配置
            ShardingRuleConfiguration shardingRuleConfiguration = new ShardingRuleConfiguration();
            shardingRuleConfiguration.getTableRuleConfigs().add(userRuleConfiguration);

5、分佈式主鍵（雪花算法）

　　分庫後，不能再使用 mysql 的自增主鍵，不然會產生重複主鍵。自定義主鍵，主要須要解決兩個問題：

主鍵惟一（必須）
主鍵單調遞增（可選）（提高索引效率，減小索引重排產生的空間碎片）

　　Sharding 內部提供了2個主鍵生成器，一個使用雪花算法 SnowflakeShardingKeyGenerator，一個使用 UUID（考慮上面第2條，所以不使用 UUID）。

　　雪花算法的主要原理：用一個 64 bit 的 long 型數字作主鍵。其中，

　　　　第 1 位，1 bit 做爲符號位永遠爲 0，表示是正數。

　　　　第 2 - 42 位， 41 個 bit 填充時間戳。

　　　　第 43 - 52 位，10 個 bit 填充機器惟一id。舉個例子，能夠用前4位標識機房號，後6位標識機器號。

　　　　第 53 - 64 位，12 個 bit 填充id序號。範圍 0 - 4095，即每臺機器每 1 毫秒最多生成 4096 個不一樣的主鍵id。

　　雪花算法的主要實現代碼以下：

先判斷時鐘是否回調。這裏默認容忍回調時間爲0，若有回調則會產生異常。能夠經過配置 max.tolerate.time.difference.milliseconds 屬性，讓其自旋等待時鐘回到上一次執行時間。
按當前毫秒數，遞增生成id序號。若是時鐘進入了下一毫秒，則從0開始從新生成id序號。
將時間戳 + 機器序號 + id序號拼裝成主鍵id。這裏機器序號默認爲0，能夠經過 worker.id 屬性進行配置。不一樣的服務器須要配置成不一樣的數字，範圍 0 - 1023。

　　其中 EPOCH 是時鐘基準，sharding中設置的是2016年11月1日，那麼41位的時間戳差很少能夠用70年，一直到2086年。

public synchronized Comparable<?> generateKey() {
        long currentMilliseconds = timeService.getCurrentMillis();
        if (this.waitTolerateTimeDifferenceIfNeed(currentMilliseconds)) {
            currentMilliseconds = timeService.getCurrentMillis();
        }

        if (this.lastMilliseconds == currentMilliseconds) {
            if (0L == (this.sequence = this.sequence + 1L & 4095L)) {
                currentMilliseconds = this.waitUntilNextTime(currentMilliseconds);
            }
        } else {
            this.vibrateSequenceOffset();
            this.sequence = (long)this.sequenceOffset;
        }

        this.lastMilliseconds = currentMilliseconds;
        return currentMilliseconds - EPOCH << 22 | this.getWorkerId() << 12 | this.sequence;
    }

6、業務代碼

　　使用分佈式的主鍵ID生成器，須要給不一樣的表注入不一樣的ID生成器，在config包下加一個KeyIdConfig類，以下：

　　這裏，爲了保持時鐘的統一，能夠能夠專門找一臺機器做爲時鐘服務，而後給全部主鍵生成器配置時鐘服務。

@Configuration
public class KeyIdConfig {
    @Bean("userKeyGenerator")
    public SnowflakeShardingKeyGenerator userKeyGenerator() {
        return new SnowflakeShardingKeyGenerator();
    }

    @Bean("orderKeyGenerator")
    public SnowflakeShardingKeyGenerator orderKeyGenerator() {
        return new SnowflakeShardingKeyGenerator();
    }
}

　　其餘業務代碼，具體能夠參看源代碼，在文末提供源碼下載地址。

　　啓動類以下：

package com.example.shardingjdbc;
 
 import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @MapperScan("com.example.shardingjdbc.mapper")
 @SpringBootApplication
 public class ShardingjdbcApplication {
     public static void main(String[] args) {
         SpringApplication.run(ShardingjdbcApplication.class, args);
     }
 }

　　注意，這裏我在啓動類上加了 @MapperScan 註解。多是由於引用依賴的問題，.properties 配置的 mybatis 包掃描目錄無論用了，後面有時間再研究。

7、其餘

　　除了基本的分庫分表規則之外，還有一些其餘的配置，好比綁定表。這裏先不一一舉例了，參照官方文檔配便可。

　　舉個例子：如今有 order, order_detail兩張表，1:1的關係。

　　在配置的時候，應該將相同 order_id 的 order 記錄和 order_detail 記錄映射到相同尾號的表中。這樣方便鏈接查詢。好比都插入到 order0, order_detail0中。

　　若是配置了綁定關係，那麼只會產生一條查詢 select * from order0 as o join order_detail0 as d on o.order_id = d.order_id。

　　不然會產生笛卡兒積查詢，

　　　　select * from order0 as o join order_detail0 as d on o.order_id = d.order_id。

　　　　select * from order0 as o join order_detail1 as d on o.order_id = d.order_id。

　　　　select * from order1 as o join order_detail0 as d on o.order_id = d.order_id。

　　　　select * from order1 as o join order_detail1 as d on o.order_id = d.order_id。

8、總結

　　項目啓動前，先建立數據庫 test0, test1，而後分別建表 t_user0, t_user1。能夠所有在同一臺機器。

　　項目啓動後，訪問 http://localhost:8080/user/save， id 是偶數的都插入到了 test0 庫的 t_user0 表中，奇數的都插入到了 test1 庫中的 t_user1 表中。

　　druid 的後臺監控頁面地址： http://localhost:8080/druid/。

　　項目啓動後，sharding日誌會將配置已 yml 格式的形式打印出來，也能夠省去 java 配置，將其優化到 .yml 配置文件中去，以下圖：

　　源碼下載地址：https://474b.com/file/14960372-448059323

　　做者QQ： 116269651