Sharding-Sphere

Sharding-JDBC 最早是當當網內部使用的一款分庫分表框架，到2017年的時候才開始對外開源，這幾年在大量社區貢獻者的不斷迭代下，功能也逐漸完善，現已更名為 ShardingSphere，2020年4?16?正式成為 Apache 軟體基?會的頂級項?，

隨著版本的不斷更迭 ShardingSphere 的核心功能也變得多元化起來，如圖7-1，ShardingSphere生態包含三款開源分布式資料庫中間件解決方案，Sharding-JDBC、Sharding-Proxy、Sharding-Sidecar，

圖7-1

Apache ShardingSphere 5.x 版本開始致力于提供可插拔架構，專案的功能組件能夠靈活的以可插拔的方式進行擴展，目前，資料分片、讀寫分離、資料加密、影子庫壓測等功能，以及對 MySQL、PostgreSQL、SQLServer、Oracle 等 SQL 與協議的支持，均通過插件的方式織入專案，開發者能夠像使用積木一樣定制屬于自己的獨特系統，Apache ShardingSphere 目前已提供數十個 SPI 作為系統的擴展點，而且仍在不斷增加中，

如圖7-2，是Sharding-Sphere的整體架構，

圖7-2

Sharding-JDBC

Sharding-JDBC是比較常用的一個組件，它定位的是一個增強版的JDBC驅動，簡單來說就是在應用端來完成資料庫分庫分表相關的路由和分片操作，也是我們本階段重點去分析的組件，

我們在專案內引入Sharding-JDBC的依賴，我們的業務代碼在操作資料庫的時候，就會通過Sharding-JDBC的代碼連接到資料庫，也就是分庫分表的一些核心動作，比如SQL決議，路由，執行，結果處理，都是由它來完成的，它作業在客戶端，

圖7-3

Sharding-Proxy

Sharding-Proxy有點類似于Mycat，它是提供了資料庫層面的代理，什么意思呢？簡單來說，以前我們的應用是直連資料庫，引入了Sharding-Proxy之后，我們的應用是直連Sharding-Proxy，然后Sharding-Proxy通過處理之后再轉發到mysql中，

這種方式的好處在于，用戶不需要感知到分庫分表的存在，相當于正常訪問mysql，目前Sharding-Proxy支持Mysql和PostgreSQL兩種資料庫協議，如圖7-4所示，

圖7-4

Sharding-Sidecar（TODO）

看到Sidecar，大家應該就能想到服務網格架構，它主要定位于 Kubernetes 的云原生資料庫代理，以 Sidecar 的形式代理所有對資料庫的訪問，目前Sharding-Sidecar還處于開發階段未發布，

Sharding-JDBC

Sharding-JDBC是對原有JDBC驅動的增強，在分庫分表的場景中，為應用提供了如圖7-5所示的功能，

圖7-5

Sharding-JDBC的整體架構

如圖7-6所示，Java應用程式通過Sharding-JDBC驅動訪問資料庫，而在Sharding-JDBC中，它會根據相關配置完成分庫分表路由、分布式事務等功能，所以我們可以認為它是對JDBC驅動的增強，

Registry Center表示注冊中心，用來實作集中化分片配置規則管理、動態配置、以及資料源等資訊，

![](https://mic-blob-bucket.oss-cn-beijing.aliyuncs.com/202110202033009.png" alt="ShardingSphere-JDBC Architecture)

圖7-6

Sharding-JDBC的基本使用

為了讓大家更好的理解Shading-JDBC，我們通過一個案例來簡單認識一下Sharding-JDBC，‘

https://shardingsphere.apache.org/document/current/cn/quick-start/shardingsphere-jdbc-quick-start/

為了更直觀的理解Sharding-JDBC，下面通過一個原生的案例進行演示，

圖7-7

圖7-8表示整體專案結構，

引入Maven依賴

<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>shardingsphere-jdbc-core</artifactId>
    <version>5.0.0-alpha</version>
</dependency>
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>3.4.1</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

Order

定義Order表的物體物件，

@Data
public class Order implements Serializable {

    private static final long serialVersionUID = 661434701950670670L;

    private long orderId;

    private int userId;

    private long addressId;

    private String status;
}

OrderReporitoryImpl

定義資料庫操作層

public interface OrderRepository {

    void createTableIfNotExists() throws SQLException;

    Long insert(final Order order) throws SQLException;
}

public class OrderRepositoryImpl implements OrderRepository {

    private final DataSource dataSource;

    public OrderRepositoryImpl(final DataSource dataSource) {
        this.dataSource = dataSource;
    }
    @Override
    public void createTableIfNotExists() throws SQLException {
        String sql = "CREATE TABLE IF NOT EXISTS t_order (order_id BIGINT NOT NULL AUTO_INCREMENT, user_id INT NOT NULL, address_id BIGINT NOT NULL, status VARCHAR(50), PRIMARY KEY (order_id))";
        try (Connection connection = dataSource.getConnection();
             Statement statement = connection.createStatement()) {
            statement.executeUpdate(sql);
        }
    }
    @Override
    public Long insert(final Order order) throws SQLException {
        String sql = "INSERT INTO t_order (user_id, address_id, status) VALUES (?, ?, ?)";
        try (Connection connection = dataSource.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
            preparedStatement.setInt(1, order.getUserId());
            preparedStatement.setLong(2, order.getAddressId());
            preparedStatement.setString(3, order.getStatus());
            preparedStatement.executeUpdate();
            try (ResultSet resultSet = preparedStatement.getGeneratedKeys()) {
                if (resultSet.next()) {
                    order.setOrderId(resultSet.getLong(1));
                }
            }
        }
        return order.getOrderId();
    }
}

OrderServiceImpl

定義資料庫訪問層

public interface ExampleService {
    /**
     * 初始化表結構
     *
     * @throws SQLException SQL exception
     */
    void initEnvironment() throws SQLException;

    /**
     * 執行成功
     *
     * @throws SQLException SQL exception
     */
    void processSuccess() throws SQLException;
}

public class OrderServiceImpl implements ExampleService {
    private final OrderRepository orderRepository;
    Random random=new Random();

    public OrderServiceImpl(final DataSource dataSource) {
        orderRepository=new OrderRepositoryImpl(dataSource);
    }

    @Override
    public void initEnvironment() throws SQLException {
        orderRepository.createTableIfNotExists();
    }

    @Override
    public void processSuccess() throws SQLException {
        System.out.println("-------------- Process Success Begin ---------------");
        List<Long> orderIds = insertData();
        System.out.println("-------------- Process Success Finish --------------");
    }
    private List<Long> insertData() throws SQLException {
        System.out.println("---------------------------- Insert Data ----------------------------");
        List<Long> result = new ArrayList<>(10);
        for (int i = 1; i <= 10; i++) {
            Order order = insertOrder(i);
            result.add(order.getOrderId());
        }
        return result;
    }
    private Order insertOrder(final int i) throws SQLException {
        Order order = new Order();
        order.setUserId(random.nextInt(10000));
        order.setAddressId(i);
        order.setStatus("INSERT_TEST");
        orderRepository.insert(order);
        return order;
    }
}

DataSourceUtil

public class DataSourceUtil {

    private static final String HOST = "192.168.221.128";

    private static final int PORT = 3306;

    private static final String USER_NAME = "root";

    private static final String PASSWORD = "123456";

    public static DataSource createDataSource(final String dataSourceName) {
        HikariDataSource result = new HikariDataSource();
        result.setDriverClassName("com.mysql.jdbc.Driver");
        result.setJdbcUrl(String.format("jdbc:mysql://%s:%s/%s?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8", HOST, PORT, dataSourceName));
        result.setUsername(USER_NAME);
        result.setPassword(PASSWORD);
        return result;
    }
}

Sharding-JDBC分片規則配置

public class ShardingDatabasesAndTableConfiguration {
    //創建兩個資料源
    private static Map<String,DataSource> createDataSourceMap(){
        Map<String, DataSource> dataSourceMap=new HashMap<>();
        dataSourceMap.put("ds0",DataSourceUtil.createDataSource("shard01"));
        dataSourceMap.put("ds1",DataSourceUtil.createDataSource("shard02"));
        return dataSourceMap;
    }

    private static ShardingRuleConfiguration createShardingRuleConfiguration(){
        ShardingRuleConfiguration configuration=new ShardingRuleConfiguration();
        configuration.getTables().add(getOrderTableRuleConfiguration());
//        configuration.getBindingTableGroups().add("t_order,t_order_item");
        //
        //
        /**
         * 設定資料庫的分片規則
         * inline表示行運算式分片演算法，它使用groovy的運算式，支持單分片鍵，比如 t_user_$->{uid%8} 表示t_user表根據u_id%8分成8張表
         */
        configuration.setDefaultDatabaseShardingStrategy(
                new StandardShardingStrategyConfiguration("user_id","inline"));
        /**
         * 設定表的分片規則
         */
        configuration.setDefaultTableShardingStrategy(new StandardShardingStrategyConfiguration("order_id","order_inline"));
        Properties props=new Properties();
        props.setProperty("algorithm-expression","ds${user_id%2}"); //表示根據user_id取模得到目標表
        /**
         * 定義具體的分片規則演算法，用于提供分庫分表的演算法規則
         */
        configuration.getShardingAlgorithms().put("inline",new ShardingSphereAlgorithmConfiguration("INLINE",props));
        Properties properties=new Properties();
        properties.setProperty("algorithm-expression","t_order_${order_id%2}");
        configuration.getShardingAlgorithms().put("order_inline",new ShardingSphereAlgorithmConfiguration("INLINE",properties));
        configuration.getKeyGenerators().put("snowflake",new ShardingSphereAlgorithmConfiguration("SNOWFLAKE",getProperties()));
        return configuration;
    }
    private static Properties getProperties(){
        Properties properties=new Properties();
        properties.setProperty("worker-id","123");
        return properties;
    }
    //創建訂單表的分片規則
    private static ShardingTableRuleConfiguration getOrderTableRuleConfiguration(){
        ShardingTableRuleConfiguration tableRule=new ShardingTableRuleConfiguration("t_order","ds${0..1}.t_order_${0..1}");
        tableRule.setKeyGenerateStrategy(new KeyGenerateStrategyConfiguration("order_id","snowflake"));
        return tableRule;
    }

    public static DataSource getDataSource() throws SQLException {
        return ShardingSphereDataSourceFactory.createDataSource(createDataSourceMap(), Collections.singleton(createShardingRuleConfiguration()),new Properties());
    }
}

Main方法測驗

public class ExampleMain {
    public static void main(String[] args) throws SQLException {
        DataSource dataSource=ShardingDatabasesAndTableConfiguration.getDataSource();
        ExampleService exampleService=new OrderServiceImpl(dataSource);
        exampleService.initEnvironment();
        exampleService.processSuccess();
    }
}

Sharding-JDBC使用總結

從上述的案例來看，Sharding-JDBC相當于通過配置化的方式幫我們提供了分片規則的配置，但是基于原生的使用方式，配置起來比較復雜，我們可以直接集成到Spring-Boot中，使用起來會比較簡潔，

Spring Boot集成Sharding-JDBC分片實戰

下面給大家演示一下在springboot應用中集成mybatis的情況下，如何實作分庫分表的配置，

專案代碼參考： sharding-jdbc-spring-boot-example，專案結構如圖7-8所示，

圖7-8

其中，MybatisPlusGeneratorConfig，用來生成t_order表的dal、service、controller代碼，由于代碼是基于mybatis-plus生成，這里就不做過多描述了

引入pom依賴

<dependencies>    <dependency>        <groupId>org.springframework.boot</groupId>        <artifactId>spring-boot-starter-web</artifactId>    </dependency>    <dependency>        <groupId>mysql</groupId>        <artifactId>mysql-connector-java</artifactId>        <scope>runtime</scope>    </dependency>    <dependency>        <groupId>com.baomidou</groupId>        <artifactId>mybatis-plus-boot-starter</artifactId>        <version>3.4.3</version>    </dependency>    <dependency>        <groupId>com.baomidou</groupId>        <artifactId>mybatis-plus-generator</artifactId>        <version>3.4.1</version>    </dependency>    <dependency>        <groupId>org.projectlombok</groupId>        <artifactId>lombok</artifactId>        <version>1.18.12</version>    </dependency>    <dependency>        <groupId>org.apache.shardingsphere</groupId>        <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>        <version>5.0.0-alpha</version>    </dependency>    <dependency>        <groupId>com.zaxxer</groupId>        <artifactId>HikariCP</artifactId>        <version>3.4.2</version>    </dependency></dependencies>

application.properties配置

#配置資料源名稱spring.shardingsphere.datasource.names=ds-0,ds-1spring.shardingsphere.datasource.common.type=com.zaxxer.hikari.HikariDataSourcespring.shardingsphere.datasource.common.driver-class-name=com.mysql.jdbc.Driver# 分別配置多個資料源的詳細資訊spring.shardingsphere.datasource.ds-0.username=rootspring.shardingsphere.datasource.ds-0.password=123456spring.shardingsphere.datasource.ds-0.jdbc-url=jdbc:mysql://192.168.221.128:3306/shard01?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8spring.shardingsphere.datasource.ds-1.username=rootspring.shardingsphere.datasource.ds-1.password=123456spring.shardingsphere.datasource.ds-1.jdbc-url=jdbc:mysql://192.168.221.128:3306/shard02?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8# 配置資料庫的分庫策略，其中database-inline會在后面宣告spring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-column=user_idspring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-algorithm-name=database-inline# 配置t_order表的分表策略，其中t-order-inline會在后面宣告# 行運算式識別符號可以使用 ${...} 或 $->{...}，但前者與 Spring 本身的屬性檔案占位符沖突，因此在 Spring 環境中使用行運算式識別符號建議使用 $->{...}spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=ds-$->{0..1}.t_order_$->{0..1}spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-column=order_idspring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-algorithm-name=t-order-inline# 配置order_id采用雪花演算法生成全域id策略spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.column=order_idspring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.key-generator-name=snowflake# 配置具體的分庫分表規則spring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.props.algorithm-expression=ds-$->{user_id % 2}spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-inline.props.algorithm-expression=t_order_$->{order_id % 2}spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-item-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-item-inline.props.algorithm-expression=t_order_item_$->{order_id % 2}# 配置雪花演算法spring.shardingsphere.rules.sharding.key-generators.snowflake.type=SNOWFLAKEspring.shardingsphere.rules.sharding.key-generators.snowflake.props.worker-id=123

增加邏輯代碼

TOrderMapper

@Update("CREATE TABLE IF NOT EXISTS t_order (order_id BIGINT AUTO_INCREMENT, user_id INT NOT NULL, address_id BIGINT NOT NULL, status VARCHAR(50), PRIMARY KEY (order_id))")void createTableIfNotExists();

TOrderServiceImpl

@Servicepublic class TOrderServiceImpl extends ServiceImpl<TOrderMapper, TOrder> implements ITOrderService {    @Autowired    TOrderMapper orderMapper;    Random random=new Random();    @Override    public void initEnvironment() throws SQLException {        orderMapper.createTableIfNotExists();    }    @Override    public void processSuccess() throws SQLException {        System.out.println("-------------- Process Success Begin ---------------");        List<Long> orderIds = insertData();        System.out.println("-------------- Process Success Finish --------------");    }    private List<Long> insertData() throws SQLException {        System.out.println("---------------------------- Insert Data ----------------------------");        List<Long> result = new ArrayList<>(10);        for (int i = 1; i <= 10; i++) {            TOrder order = new TOrder();            order.setUserId(random.nextInt(10000));            order.setAddressId(i);            order.setStatus("INSERT_TEST");            orderMapper.insert(order);            result.add(order.getOrderId());        }        return result;    }}

TOrderController

提供測驗介面，

@RestController@RequestMapping("/t-order")public class TOrderController {    @Autowired    ITOrderService orderService;    @GetMapping    public void init() throws SQLException {        orderService.initEnvironment();        orderService.processSuccess();    }}

Sharding-JDBC的相關概念說明

前面我們通過兩種方式演示了Sharding-JDBC的分庫分表功能的用法，其實，從這個層面來說，Sharding-JDBC相當于增強了JDBC驅動的功能，使得開發者只需要通過配置就可以輕松完成分庫分表功能的實作，

在Sharding-JDBC中，有一些表的概念，需要給大家普及一下，邏輯表、真實表、分片鍵、資料節點、動態表、廣播表、系結表，

邏輯表

邏輯表可以理解為資料庫中的視圖，是一張虛擬表，可以映射到一張物理表，也可以由多張物理表組成，這些物理表可以來自于不同的資料源，對于mysql, Hbase和ES，要組成一張邏輯表，只需要他們有相同含義的key即可，這個key在mysql中是主鍵，Hbase中是生成rowkey用的值，是ES中的key，

在前面的分庫分表規則配置中，就有用到t_order這個邏輯表的定義，當我們針對t_order表操作時，會根據分片規則映射到實際的物理表進行相關事務操作，如圖7-9所示，邏輯表會在SQL決議和路由時被替換成真實的表名，

spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=ds-$->{0..1}.t_order_$->{0..1}

圖7-9

廣播表

廣播表也叫全域表，也就是它會存在于多個庫中冗余，避免跨庫查詢問題，

比如省份、字典等一些基礎資料，為了避免分庫分表后關聯表查詢這些基礎資料存在跨庫問題，所以可以把這些資料同步給每一個資料庫節點，這個就叫廣播表，如圖7-10所示，

圖7-10

在Sharding-JDBC中，配置方式如下

# 廣播表, 其主節點是ds0spring.shardingsphere.sharding.broadcast-tables=t_configspring.shardingsphere.sharding.tables.t_config.actual-data-nodes=ds$->{0}.t_config

系結表

我們有些表的資料是存在邏輯的主外鍵關系的，比如訂單表order_info，存的是匯總的商品數，商品金額；訂單明細表order_detail，是每個商品的價格，個數等等，或者叫做從屬關系，父表和子表的關系，他們之間會經常有關聯查詢的操作，如果父表的資料和子表的資料分別存盤在不同的資料庫，跨庫關聯查詢也比較麻煩，所以我們能不能把父表和資料和從屬于父表的資料落到一個節點上呢？

比如order_id=1001的資料在node1，它所有的明細資料也放到node1；order_id=1002的資料在node2，它所有的明細資料都放到node2，這樣在關聯查詢的時候依然是在一個資料庫，如圖7-11所示

圖7-11

# 系結表規則，多組系結規則使用陣列形式配置spring.shardingsphere.rules.sharding.binding-tables=t_order,t_order_item

如果存在多個系結表規則，可以用陣列的方式宣告

spring.shardingsphere.rules.sharding.binding-tables[0]= # 系結表規則串列spring.shardingsphere.rules.sharding.binding-tables[1]= # 系結表規則串列spring.shardingsphere.rules.sharding.binding-tables[x]= # 系結表規則串列

Sharding-JDBC中的分片策略

Sharding-JDBC內置了很多常用的分片策略，這些演算法主要針對兩個維度

資料源分片
資料表分片

Sharding-JDBC的分片策略包含了分片鍵和分片演算法；

分片鍵，用于分片的資料庫欄位，是將資料庫(表)水平拆分的關鍵欄位，例：將訂單表中的訂單主鍵的尾數取模分片，則訂單主鍵為分片欄位， SQL中如果無分片欄位，將執行全路由，性能較差，除了對單分片欄位的支持，ShardingSphere也支持根據多個欄位進行分片，
分片演算法，就是用來實作分片的計算規則，

Sharding-JDBC提供內置了多種分片演算法，包含四種型別分別是

自動分片演算法
標準分片演算法
復合分片演算法
Hinit分片演算法

自動分片演算法

自動分片演算法，就是根據我們配置的演算法運算式完成資料的自動分發功能，在Sharding-JDBC中提供了五種自動分片演算法

取模分片演算法
哈希取模分片演算法
基于分片容量的范圍分片演算法
基于分片邊界的范圍分片演算法
自動時間段分片演算法

取模分片演算法

最基礎的取模演算法，它會根據分片欄位的值和sharding-count進行取模運算，得到一個結果，

ModShardingAlgorithm

# database-mod是自定義字串名字spring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-algorithm-name=database-mod# MOD表示取模演算法型別spring.shardingsphere.rules.sharding.sharding-algorithms.database-mod.type=MOD# 表示分片數量spring.shardingsphere.rules.sharding.sharding-algorithms.database-mod.props.sharding-count=2

哈希取模分片演算法

和取模演算法相同，唯一的區別是針對分片鍵得到哈希值之后再取模

HashModShardingAlgorithm

# database-mod是自定義字串名字spring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-algorithm-name=database-hash-modspring.shardingsphere.rules.sharding.sharding-algorithms.database-hash-mod.type=HASH_MODspring.shardingsphere.rules.sharding.sharding-algorithms.database-hash-mod.props.sharding-count=2

分片容量范圍

分片容量范圍，簡單理解就是按照某個欄位的數值范圍進行分片，比如存在下面這樣一個需求，怎么配置呢？

(0~199)保存到表0[200~399]保存到表1[400~599)保存到表2

參考7.2.3章節中的方式，構建一個t_order_colume_range表，使用mybatis-plus生成相關代碼，如圖7-12所示

圖7-12

添加如下配置，通過spring.profiles.active=volumn-range來激活不同的配置資訊，

server.port=8080spring.mvc.view.prefix=classpath:/templates/spring.mvc.view.suffix=.htmlspring.shardingsphere.datasource.names=ds-0spring.shardingsphere.datasource.common.type=com.zaxxer.hikari.HikariDataSourcespring.shardingsphere.datasource.common.driver-class-name=com.mysql.jdbc.Driverspring.shardingsphere.datasource.ds-0.username=rootspring.shardingsphere.datasource.ds-0.password=123456spring.shardingsphere.datasource.ds-0.jdbc-url=jdbc:mysql://192.168.221.128:3306/shard01?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8spring.shardingsphere.rules.sharding.tables.t_order_volume_range.actual-data-nodes=ds-0.t_order_volume_range_$->{0..2}spring.shardingsphere.rules.sharding.tables.t_order_volume_range.table-strategy.standard.sharding-column=user_idspring.shardingsphere.rules.sharding.tables.t_order_volume_range.table-strategy.standard.sharding-algorithm-name=t-order-volume-rangespring.shardingsphere.rules.sharding.tables.t_order_volume_range.key-generate-strategy.column=order_idspring.shardingsphere.rules.sharding.tables.t_order_volume_range.key-generate-strategy.key-generator-name=snowflakespring.shardingsphere.rules.sharding.sharding-algorithms.t-order-volume-range.type=VOLUME_RANGE#最小的范圍，0-200spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-volume-range.props.range-lower=200#最大的范圍，600 ，如果超過600，會報錯spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-volume-range.props.range-upper=600# 表示每張表的容量為200spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-volume-range.props.sharding-volume=200spring.shardingsphere.rules.sharding.key-generators.snowflake.type=SNOWFLAKEspring.shardingsphere.rules.sharding.key-generators.snowflake.props.worker-id=123

基于分片邊界的范圍分片演算法

前面講的分片容量范圍分片，是一個均衡的分片方法，如果存在不均衡的場景，比如下面這種情況

(0~1000)保存到表0[1000~20000]保存到表1[20000~300000)保存到表2[300000~無窮大)保存到表3

我們就可以用到基于分片邊界的范圍分片演算法來完成，配置方法如下

BoundaryBasedRangeShardingAlgorithm

# BOUNDARY_RANGE 表示分片演算法型別spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-boundary-range.type=BOUNDARY_RANGE# 分片的范圍邊界，多個范圍邊界以逗號分隔spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-boundary-range.props.sharding-ranges=1000,20000,300000

自動時間段分片演算法

IntervalShardingAlgorithm

根據時間段進行分片，如果想實作如下功能

(1970-01-01 23:59:59 ~ 2020-01-01 23:59:59) 表0[2020-01-01 23:59:59 ~ 2021-01-01 23:59:59) 表1[2021-01-01 23:59:59 ~ 2021-02-01 23:59:59) 表2[2022-01-01 23:59:59 ~ 2024-01-01 23:59:59) 表3

配置方法如下，表示從2010-01-01到2021-01-01這個時間區間內的資料，按照每一年劃分一個表

spring.shardingsphere.rules.sharding.tables.t_order_volume_range.actual-data-nodes=ds-0.t_order_volume_range_$->{0..2}spring.shardingsphere.rules.sharding.tables.t_order_volume_range.table-strategy.standard.sharding-column=create_datespring.shardingsphere.rules.sharding.tables.t_order_volume_range.table-strategy.standard.sharding-algorithm-name=t-order-auto-intervalspring.shardingsphere.rules.sharding.tables.t_order_volume_range.key-generate-strategy.column=order_idspring.shardingsphere.rules.sharding.tables.t_order_volume_range.key-generate-strategy.key-generator-name=snowflakespring.shardingsphere.rules.sharding.sharding-algorithms.t-order-auto-interval.type=AUTO_INTERVAL# 分片的起始時間范圍，時間戳格式：yyyy-MM-dd HH:mm:ssspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-auto-interval.props.datetime-lower=2010-01-01 23:59:59# 分片的結束時間范圍，時間戳格式：yyyy-MM-dd HH:mm:ssspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-auto-interval.props.datetime-upper=2021-01-01 23:59:59# 單一分片所能承載的最大時間，單位：秒，下面的數字表示1年spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-auto-interval.props.sharding-seconds='31536000'

需要注意，如果是基于時間段來分片，那么在查詢的時候不能使用函式查詢，否則會導致全路由，

select * from t_order where to_date(create,'yyyy-mm-dd')=''

標準分片演算法

標準分片策略（StandardShardingStrategy），它只支持對單個分片健（欄位）為依據的分庫分表，Sharding-JDBC提供了兩種演算法實作

行運算式分片演算法

型別：INLINE

使用 Groovy 的運算式，提供對 SQL 陳述句中的 = 和 IN 的分片操作支持，只支持單分片鍵，對于簡單的分片演算法，可以通過簡單的配置使用，從而避免繁瑣的 Java 代碼開發，如: t_user_$->{u_id % 8} 表示 t_user 表根據 u_id 模 8，而分成 8 張表，表名稱為 t_user_0 到 t_user_7

配置方法如下，

spring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.props.algorithm-expression=ds-$->{user_id % 2}spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-inline.props.algorithm-expression=t_order_$->{order_id % 2}

時間范圍分片演算法

和前面自動分片演算法的自動時間段分片演算法類似，

型別：INTERVAL

可配置屬性：

屬性名稱	資料型別	說明	默認值
datetime-pattern	String	分片鍵的時間戳格式，必須遵循 Java DateTimeFormatter 的格式，例如：yyyy-MM-dd HH:mm:ss	-
datetime-lower	String	時間分片下界值，格式與 `datetime-pattern` 定義的時間戳格式一致	-
datetime-upper (?)	String	時間分片上界值，格式與 `datetime-pattern` 定義的時間戳格式一致	當前時間
sharding-suffix-pattern	String	分片資料源或真實表的后綴格式，必須遵循 Java DateTimeFormatter 的格式，必須和 `datetime-interval-unit` 保持一致，例如：yyyyMM	-
datetime-interval-amount (?)	int	分片鍵時間間隔，超過該時間間隔將進入下一分片	1
datetime-interval-unit (?)	String	分片鍵時間間隔單位，必須遵循 Java ChronoUnit 的列舉值，例如：MONTHS

復合分片演算法

使用場景：SQL 陳述句中有>，>=, <=，<，=，IN 和 BETWEEN AND 等運算子，不同的是復合分片策略支持對多個分片健操作，

Sharding-JDBC內置了一種復合分片演算法的實作，

型別： COMPLEX_INLINE，實作類：ComplexInlineShardingAlgorithm

屬性名稱	資料型別	說明	默認值
sharding-columns (?)	String	分片列名稱，多個列用逗號分隔，如不配置無法則不能校驗	-
algorithm-expression	String	分片演算法的行運算式	-
allow-range-query-with-inline-sharding (?)	boolean	是否允許范圍查詢，注意：范圍查詢會無視分片策略，進行全路由

目前版本還未發布（在github倉庫中已經提供了實作），如果要實作符合分片演算法，需要自己手動實作，

自定義分片演算法

除了默認提供了分片演算法之外，我們可以根據實際需求自定義分片演算法，Sharding-JDBC同樣提供了幾種型別的擴展實作

標準分片演算法
復合分片演算法
Hinit分片策略
不分片策略

分片策略的介面定義如下，它有四個子類，分別對應上面四種分片策略，我們可以通過繼承不同的分片策略完成自定義分片策略的擴展，

public interface ShardingStrategy {    Collection<String> getShardingColumns();    ShardingAlgorithm getShardingAlgorithm();    Collection<String> doSharding(Collection<String> var1, Collection<ShardingConditionValue> var2, ConfigurationProperties var3);}

圖7-13

自定義標準分片演算法

public class StandardModTableShardAlgorithm implements StandardShardingAlgorithm<Long> {    private Properties props=new Properties();    /**     * 用于處理=和IN的分片，     * @param collection 表示目標分片的集合     * @param preciseShardingValue 邏輯表相關資訊     * @return     */    @Override    public String doSharding(Collection<String> collection, PreciseShardingValue<Long> preciseShardingValue) {        for(String name:collection){            //根據order_id的值進行取模，得到一個目標值            if(name.endsWith(String.valueOf(preciseShardingValue.getValue()%4))){                return name;            }        }        throw new UnsupportedOperationException();    }    /**     * 用于處理BETWEEN AND分片，如果不配置RangeShardingAlgorithm，SQL中的BETWEEN AND將按照全庫路由處理     * @param collection     * @param rangeShardingValue     * @return     */    @Override    public Collection<String> doSharding(Collection<String> collection, RangeShardingValue<Long> rangeShardingValue) {        Collection<String> result=new LinkedHashSet<>(collection.size());        for(Long i=rangeShardingValue.getValueRange().lowerEndpoint();i<=rangeShardingValue.getValueRange().upperEndpoint();i++){            for(String name:collection){                if(name.endsWith(String.valueOf(i%4))){                    result.add(name);                }            }        }        return result;    }    /**     * 初始化物件的時候呼叫的方法     */    @Override    public void init() {    }    /**     * 對應分片演算法（sharding-algorithms）的型別     * @return     */    @Override    public String getType() {        return "STANDARD_MOD";    }    @Override    public Properties getProps() {        return this.props;    }    /**     * 獲取分片相關屬性     * @param properties     */    @Override    public void setProps(Properties properties) {        this.props=properties;    }}

通過SPI機制進行擴展

在resource目錄下創建META-INF/service/org.apache.shardingsphere.sharding.spi.ShardingAlgorithm檔案
把自定義標準分片演算法的全路徑寫如到上述檔案中

  com.gupao.sharding.example.StandardModTableShardAlgorithm

增加application-custom-standard.properties檔案

spring.shardingsphere.rules.sharding.tables.t_order_standard.actual-data-nodes=ds-0.t_order_standard_$->{0..3}spring.shardingsphere.rules.sharding.tables.t_order_standard.table-strategy.standard.sharding-column=order_idspring.shardingsphere.rules.sharding.tables.t_order_standard.table-strategy.standard.sharding-algorithm-name=standard-modspring.shardingsphere.rules.sharding.tables.t_order_standard.key-generate-strategy.column=order_idspring.shardingsphere.rules.sharding.tables.t_order_standard.key-generate-strategy.key-generator-name=snowflakespring.shardingsphere.rules.sharding.sharding-algorithms.standard-mod.type=STANDARD_MODspring.shardingsphere.rules.sharding.sharding-algorithms.standard-mod.props.algorithm-class-name=com.gupao.sharding.example.StandardModTableShardAlgorithm

其中，STANDARD_MOD是我們自定義的取模分片演算法的型別，

表以及代碼生成

把t_order表復制一張t_order_standard，通過mybatis-plus生成業務代碼，

代碼工程詳見： sharding-jdbc-springboot-example

分布式序列演算法

Sharding-JDBC中默認提供了兩種分布式序列演算法

UUID
雪花演算法

這兩種在前面都說過，就不在重復說明，

分布式序列演算法是為了保證水平分表之后，保證全域唯一性，關于雪花演算法的定義如下，

型別：SNOWFLAKE

可配置屬性：

屬性名稱	資料型別	說明	默認值
worker-id (?)	long	作業機器唯一標識	0
max-vibration-offset (?)	int	最大抖動上限值，范圍[0, 4096)，注：若使用此演算法生成值作分片值，建議配置此屬性，此演算法在不同毫秒內所生成的 key 取模 2^n (2^n一般為分庫或分表數) 之后結果總為 0 或 1，為防止上述分片問題，建議將此屬性值配置為 (2^n)-1	1
max-tolerate-time-difference-milliseconds (?)	long	最大容忍時鐘回退時間，單位：毫秒

關注[跟著Mic學架構]公眾號，獲取更多精品原創

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

標籤：Java

上一篇：JAVA中如何取得一個陣列中最大值和最小值呢？

下一篇：超市訂單管理系統（5）-密碼修改

分庫分表利器之Sharding Sphere（深度好文，看過的人都說好）

Sharding-Sphere

Sharding-JDBC

Sharding-Proxy

Sharding-Sidecar（TODO）

Sharding-JDBC

Sharding-JDBC的整體架構

Sharding-JDBC的基本使用

引入Maven依賴

Order

OrderReporitoryImpl

OrderServiceImpl

DataSourceUtil

Sharding-JDBC分片規則配置

Main方法測驗

Sharding-JDBC使用總結

Spring Boot集成Sharding-JDBC分片實戰

引入pom依賴

application.properties配置

增加邏輯代碼

TOrderController

Sharding-JDBC的相關概念說明

邏輯表

廣播表

系結表

Sharding-JDBC中的分片策略

自動分片演算法

取模分片演算法

哈希取模分片演算法

分片容量范圍

基于分片邊界的范圍分片演算法

自動時間段分片演算法

標準分片演算法

行運算式分片演算法

時間范圍分片演算法

復合分片演算法

自定義分片演算法

自定義標準分片演算法

通過SPI機制進行擴展

增加application-custom-standard.properties檔案

表以及代碼生成

分布式序列演算法