04、Sharding-JDBC 实战；选择分片算法-6ren

04、Sharding-JDBC 实战；选择分片算法

转载作者：大佬之路更新时间：2024-01-07 12:56:53

本篇将通过小例子的方式来一个一个的说明内置的分片算法;

内置多种分片算法以满足不同的业务场景;

自动分片算法

内置了一些常见场景的分片算法，只需要简单配置一些属性就可以实现分片

取模分片算法

顾名思义就是通过数据取模来分片,只需要指定分片算法类型和分片的数量，就会自动根据分片键的数据 % 分片的数量 完成分片

分片算法只需要指定类型，和配置一个几个分片的属性即可

完整配置如下

spring:
  application:
    name: shardingjdbcDemo
  main:
    allow-bean-definition-overriding: true

  shardingsphere:
   数据源信息
    datasource:
     名称为dbsource-0的数据源
      dbsource-0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: 123456
     名称为dbsource-1的数据源
      dbsource-1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db2?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: 123456
      names: dbsource-0,dbsource-1
   规则的配置
    rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbsource-$->{0..1}.t_order_$->{0..1}
           分库策略
            database-strategy:
              standard: 用于单分片键的标准分片场景
                sharding-column: user_id
                sharding-algorithm-name: db-inline
           分表策略
            table-strategy:
             标准策略
              standard:
                sharding-column: user_id
                sharding-algorithm-name: table-inline
         

       分片算法
        sharding-algorithms:
          db-inline:
            type: MOD
            props:
              sharding-count: 2  表示有2个分片库数量
          table-inline:
            type: MOD
            props:
              sharding-count: 2  表示有2个分片表数量

    props:
      sql-show: true
      sql-comment-parse-enabled: true

哈希取模分片算法

说白了就是在取模算法的基础上加了一层 hash运算然后再取模；

主要的特点是可以针对非数值类型字段作为分片键;

如果分片键不是数值类型是不能取模的;这里假设order 表增加一个字符串的类型字段;

同时给数据库各个表增进此字段;

alter table t_order_0 add city varchar(20);
alter table t_order_1 add city varchar(20);

这里用一个库来做演示，因为分库和分表的分片算法是一样的

假设需求同一个城市的数据落到一个库中;

配置信息

注意:sharding-count 后面的值需要强制指定为字符串不然会报错,应该是有问题的;

@Test
void batchInsert(){
    String[] citys = {"北京","上海","成都","石家庄","太原","广州","海口"};
    for (int i = 0; i < 30; i++) {
        Order order = new Order();
        order.setUserId(Long.valueOf(i+""));
        order.setOrderPrice(new BigDecimal("1"));
        order.setCity(citys[i % citys.length]);
        orderMapper.insert(order);
    }
}

这样就完成根据字符串的hash取模分片处理

完整配置如下

spring:
  application:
    name: shardingjdbcDemo
  main:
    allow-bean-definition-overriding: true

  shardingsphere:
   数据源信息
    datasource:
     名称为dbsource-0的数据源
      dbsource-0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: 123456
      names: dbsource-0
   规则的配置
    rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbsource-0.t_order_$->{0..1}
           分表策略
            table-strategy:
             标准策略
              standard:
                sharding-column: city
                sharding-algorithm-name: table-inline
      
      
       分片算法
        sharding-algorithms:
          table-inline:
            type: HASH_MOD
            props:
              sharding-count: !!str 2这里加!!str 是以为解析的时候会有问题，这里必须指定字符串

    props:
      sql-show: true
      sql-comment-parse-enabled: true

基于分片容量的范围分片算法

根据数据的容量进行拆分;比如一个需求一个表中最多只让存10条数据，就可以使用这个分片算法，用来严格的控制每个表的容量;假设id 使用自增的id；根据数据id 来分片;

1. 设置id 类型为输入，后续会给它指定id
@TableId(type = IdType.INPUT)
private Long orderId;

2、为了演示效果，准备6个数据表从0到5；

CREATE TABLE t_order_5 (
  order_id bigint(20) NOT NULL,
  user_id bigint(20) DEFAULT NULL,
  order_price decimal(10,2) DEFAULT NULL,
  city varchar(20) DEFAULT NULL,
  PRIMARY KEY (order_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

3、配置分片容量算法；

修改了actual-data-nodes 指定了6个表

指定了算法分片容量10 ，最小值是 1 最大值是 40

4、插入50条数据演示效果；

@Test
    void volumeRangeInsert() {
        for (int i = 0; i < 50; i++) {
            Order order = new Order();
            order.setOrderId(Long.valueOf(i));
            order.setUserId(233L);
            order.setOrderPrice(new BigDecimal("1"));
            order.setCity("北京");
            orderMapper.insert(order);
        }
    }

    @Test
    void volumeRangeQuery() {
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        queryWrapper.ge("order_id",20L);
        List<Order> orders = orderMapper.selectList(queryWrapper);
        System.out.println(orders.size());

    }

可以看到 order_id 为 0 的独自落到一个表中，接下来的表中数据都为10个，超过就下一个表中，而超过容量的数据都落到最后一个表中;

指定类型使用容量范围分割，比如上面的配置下限是1 上限是40 分割是10，那么在初始化的时候，会分为几个区间段；

(-∞,1),[1,10],[11,20],[21,30],[31,40][40,+∞) ,对应表的后缀分别根据索引从0 开始分别是 table_0 table_1 table_2 table_3 ,table_4,table_5;

那么插入的数据根据数据的范围来确定落到那个表中；查询的时候也会根据分片条件来查询对应的表;

完整配置

spring:
  application:
    name: shardingjdbcDemo
  main:
    allow-bean-definition-overriding: true

  shardingsphere:
   数据源信息
    datasource:
     名称为dbsource-0的数据源
      dbsource-0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: 123456
      names: dbsource-0
   规则的配置
    rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbsource-0.t_order_$->{0..5}
           分表策略
            table-strategy:
             标准策略
              standard:
                sharding-column: order_id
                sharding-algorithm-name: table-inline
       分片算法
        sharding-algorithms:
          table-inline:
            type: VOLUME_RANGE
            props:
              sharding-volume: !!str 10   表示一个表中最多10个数据
              range-lower: !!str 1
              range-upper: !!str 40
    props:
      sql-show: true
      sql-comment-parse-enabled: true

基于分片边界的范围分片算法

和分片容量的分片算法类型;

配置参数:type: BOUNDARY_RANGE

sharding-ranges: long 类型的可用逗号分割的字符串

和基于容量的分界的算法类似，都是为了能够切分成几个区间；适合区间不太多的场景；

   rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbs-0.t_order_$->{0..3}
           分表策略
            table-strategy:
             标准策略
              standard:
                sharding-column: user_id
                sharding-algorithm-name: table-alg
           配置主键id的策略
            keyGenerateStrategy:
              column: order_id
              key-generator:
                type: SNOWFLAKE
                props:
                  worker-id: 1
        sharding-algorithms:
          table-alg:
            type: BOUNDARY_RANGE
            props:
              sharding-ranges: 20,40

注意需要修改 actual-data-nodes 改成可能有3个表,不然会导致表丢失识别不到

如上配置切分了3个区间段；分表对应了表

table_0 ==> -∞,20

table_1 ==> 20,40

table_3 ===> 40,+∞

自动时间段分片算法

此类型针对时间字段类型作为分片键进行查询;可根据固定的时间段，比如天，月，年进行分表

配置项:type:AUTO_INTERVAL

datetime-lower:开始的最小时间

datetime-upper:分片结束的时间

sharding-seconds: 每给分片的时间间隔

假如要实现根据每天时间分一个表;

1、订单增加一个订单时间，根据订单时间作为分片依据；

 @TableField
 private LocalDateTime orderTime;

2、首先使用存储过程创建足够的表；

delimiter //

drop procedure if EXISTS createTable;

create procedure createTable()

BEGIN 

DECLARE @i int(11);     

DECLARE @createSql VARCHAR(2560); 
set @i=0; 

WHILE  @i`< 32 DO                 

-- 创建表        

SET @createSql = CONCAT('CREATE TABLE IF NOT EXISTS t_order_',@i,'(

  order_id bigint(20) NOT NULL,
  user_id bigint(20) DEFAULT NULL,
  order_price decimal(10,2) DEFAULT NULL,
  city varchar(20) DEFAULT NULL,
  order_time datetime DEFAULT NULL,
  PRIMARY KEY (order_id) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4'

); 

prepare stmt from @createSql; 

execute stmt;

SET @i= @i+1; 

            END WHILE;

end //

delimiter ;

3、配置根据每天分表,分片的下限和上限，时间间隔;；

这样的分片结果会分成

(-∞,lower],(2022-01-01 00:00:00,2022-01-02 00:00:00]..... (upper,+∞)

所以会看到结果，小于等于lower 的分到最小的表中，大于upper的分到最后一个表中;

注意:

可能会报parseDate 的解析时间字符串的错误;

经查询是在 AutoIntervalShardingAlgorithm 类的parseDate 报的错;

里面会通过分片键的toString 方法解析成字符串，然后解析成LocalDateTime;

但是我实体类的LocalDateTime 的toString 方法并不是一个符合yyyy-MM-dd HH:mm:ss 的字符串啊!

最终的解决方法，就是在Order类里getOrderTime 的时候，(见上面的Order代码 )返回了一个格式化的字符串，那么后面获取的时候就能获取到对应的字符串了;见下方实体类；

当然实际的工作中还是要通过自定义分片算法的方式来做分片处理;

package com.example.shardingjdbcdemo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

@TableName(value = "t_order")
@Data
public class Order {

    private static final DateTimeFormatter DATE_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    @TableId(type = IdType.INPUT)
    private Long orderId;

    @TableField
    private Long userId;

    @TableField
    private BigDecimal orderPrice;

    @TableField
    private String city;

    @TableField
    private LocalDateTime orderTime;

    public String getOrderTime() {
        return  DATE_TIME_FORMAT.format(orderTime);
    }
}

标准分片算法

行表达式分片算法

提供了简单的单分片键的，基于goovy 表达式的inline 配置语句;

需要注意的是,inline 不支持范围查询，如果需要范围查询需要配置 allow-range-query-with-inline-sharding:true,走全表扫描的范围查询;

    rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbs-0.t_order_$->{0..2}
           分表策略
            table-strategy:
             标准策略
              standard:
                sharding-column: user_id
                sharding-algorithm-name: table-alg
        
           
        sharding-algorithms:
          table-alg:
            type: INLINE
            props:
              algorithm-expression: t_order_$->{user_id % 2}
              allow-range-query-with-inline-sharding: true 允许范围查询

时间范围分片算法

type:INTERVAL

一种时间范围的分片，跟自动时间段不同的是，分片的后缀是可以有意义的，比如

t_order_2021_01 t_order_2021_02 可以是以时间为后缀的

下面展示以每个月来分表

1、创建了12个月份对应的表;；

2、配置根据时间范围进行分片；

 rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbsource-0.t_order_2021_$->{['01','02','03','04','05','06','07','08','09','10','11','12']}
           分表策略
            table-strategy:
             标准策略
              standard:
                sharding-column: order_time
                sharding-algorithm-name: table-inline
       分片算法
        sharding-algorithms:
          table-inline:
            type: INTERVAL
            props:
              datetime-pattern: yyyy-MM-dd HH:mm:ss
              datetime-lower: 2023-01-01 00:00:00
              datetime-upper: 2022-01-01 00:00:00
              sharding-suffix-pattern: yyyy_MM
              datetime-interval-amount: 1
              datetime-interval-unit: MONTHS

3、测试插入数据；

 @Test
    void dateIntervalInsert() {
        LocalDateTime curDate = LocalDateTime.of(2021, 1, 4, 0, 0, 0);
        for (int i = 0; i < 20; i++) {
            Order order = new Order();
            order.setOrderId(Long.valueOf(i));
            order.setUserId(233L);
            order.setOrderPrice(new BigDecimal("1"));
            order.setCity("北京");
            order.setOrderTime(curDate);
            orderMapper.insert(order);
            curDate = curDate.plusMonths(1);
        }
    }

注意：如果时间范围超过配置的上限和下限将无法分片,可能会报错

完整配置

spring:
  application:
    name: shardingjdbcDemo
  main:
    allow-bean-definition-overriding: true

  shardingsphere:
   数据源信息
    datasource:
     名称为dbsource-0的数据源
      dbsource-0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: 123456
      names: dbsource-0
   规则的配置
    rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbsource-0.t_order_2021_$->{['01','02','03','04','05','06','07','08','09','10','11','12']}
           分表策略
            table-strategy:
             标准策略
              standard:
                sharding-column: order_time
                sharding-algorithm-name: table-inline
       分片算法
        sharding-algorithms:
          table-inline:
            type: INTERVAL
            props:
              datetime-pattern: yyyy-MM-dd HH:mm:ss
              datetime-lower: 2023-01-01 00:00:00
              datetime-upper: 2022-01-01 00:00:00
              sharding-suffix-pattern: yyyy_MM
              datetime-interval-amount: 1
              datetime-interval-unit: MONTHS
    props:
      sql-show: true
      sql-comment-parse-enabled: true

复合分片算法

复合分片算法配置策略的时候要配置 complex

复合行表达式分片算法

支持多个分片键并且使用行表达式来分片

假设使用主键id 和userId 来分片，

1、创建4张表；

2、配置规则；

   rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbsource-0.t_order_$->{0..3}
           分表策略
            table-strategy:
             多分片键策略
              complex:
                sharding-columns: user_id,order_id
                sharding-algorithm-name: table-inline
       分片算法
        sharding-algorithms:
          table-inline:
            type: COMPLEX_INLINE
            props:
              sharding-columns: user_id,order_id
              algorithm-expression: t_order_$->{(order_id % 2) + (user_id % 2)}
              allow-range-query-with-inline-sharding: true

3、测试数据；

@Test
void complex_inlineInsert() {
    for (int i = 0; i < 20; i++) {
        Order order = new Order();
        order.setOrderId(Long.valueOf(i));
        order.setUserId(Long.valueOf(i));
        order.setOrderPrice(new BigDecimal("1"));
        order.setOrderTime(LocalDateTime.now());
        order.setCity("北京");
        orderMapper.insert(order);
    }
}

当然这个配置只能到 0 到 3 的表中;

完整配置;

spring:
  application:
    name: shardingjdbcDemo
  main:
    allow-bean-definition-overriding: true

  shardingsphere:
   数据源信息
    datasource:
     名称为dbsource-0的数据源
      dbsource-0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: 123456
      names: dbsource-0
   规则的配置
    rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbsource-0.t_order_$->{0..3}
           分表策略
            table-strategy:
             多分片键策略
              complex:
                sharding-columns: user_id,order_id
                sharding-algorithm-name: table-inline
       分片算法
        sharding-algorithms:
          table-inline:
            type: COMPLEX_INLINE
            props:
              sharding-columns: user_id,order_id
              algorithm-expression: t_order_$->{(order_id % 2) + (user_id % 2)}
              allow-range-query-with-inline-sharding: true
    props:
      sql-show: true
      sql-comment-parse-enabled: true

注意：分表策略需要配置成 complex

分片键使用 sharding-columns ，多个使用逗号分割

Hint 分片算法

Hint 分片算法配置策略的时候要配置 hint

强制路由算法，在其他的算法中需要从sql中解析出对应的分片键和值，而这个算法是通过API强制设置的方式;

Hint 行表达式分片算法

通过inline 表达式和 Api 来实现一个分片算法;

在此配置中，策略为 hint ,不用指定分片键，不从数据中解析分片信息，而是通过一个Api

HintManager 通过 addTableShardingValue 和 addDatabaseShardingValue

来设置表分片的value 和库分片的value ，在执行数据分片的解析表达式的时候从这个手动设置的值中获取;

1、添加配置完整配置；

spring:
  application:
    name: shardingjdbcDemo
  main:
    allow-bean-definition-overriding: true

  shardingsphere:
   数据源信息
    datasource:
     名称为dbsource-0的数据源
      dbsource-0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: 123456
      names: dbsource-0
   规则的配置
    rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbsource-0.t_order_$->{0..1}
           分表策略
            table-strategy:
             多分片键策略
              hint:
                sharding-algorithm-name: table-inline
       分片算法
        sharding-algorithms:
          table-inline:
            type: HINT_INLINE
            props:
              algorithm-expression: t_order_$->{value % 2}

    props:
      sql-show: true
      sql-comment-parse-enabled: true

2、插入数据；

  @Test
    void hintInlineInsert() {
        HintManager hintManager = HintManager.getInstance();
        for (int i = 0; i < 10; i++) {
            hintManager.addTableShardingValue("t_order",i);;
            Order order = new Order();
            order.setOrderId(Long.valueOf(i));
            order.setUserId(Long.valueOf(i));
            order.setOrderPrice(new BigDecimal("1"));
            order.setOrderTime(LocalDateTime.now());
            order.setCity("北京");
            orderMapper.insert(order);
            //执行完毕需要清空
            hintManager.clearShardingValues();
        }
    }

自定义类分片算法

通过自定义类的方式来实现分片算法，也是比较常用的一种做法，优先是比较灵活，可以做一些自定义的特殊分片逻辑;

根据需求实现不同的类;

STANDARD ==> StandardShardingAlgorithm

COMPLEX ==> ComplexKeysShardingAlgorithm

HINT ==> HintShardingAlgorithm

比如要实现一个自定义的复合分片的算法;

1、首先确定要实现一个什么样的分片算法，是标准的，多分片键的，还是强制路由的；

确定了后就新增一个自定义类并实现对应的接口;比如要实现一个多分片键的就实现ComplexKeysShardingAlgorithm;


public class OrderComplexAlgorithm implements ComplexKeysShardingAlgorithm<Long> {

    /**
     * @param availableTargetNames
     * @param shardingValue
     * @return
     */
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames, ComplexKeysShardingValue<Long> shardingValue) {
        if (!shardingValue.getColumnNameAndRangeValuesMap().isEmpty()) {
            //如果是范围查询并且没有路由键信息，全表查询
            return availableTargetNames;
        }
        //只有一个可用的表信息
        int size = availableTargetNames.size();
        if(size == 1){
            return availableTargetNames;
        }

        //获取逻辑表
        String logicTableName = shardingValue.getLogicTableName();
        Set<String> finalTargetNames = new HashSet<>();
        //获取分片信息
        Map<String, Collection<Long>> columnNameAndShardingValuesMap = shardingValue.getColumnNameAndShardingValuesMap();
        Set<Map.Entry<String, Collection<Long>>> entries = columnNameAndShardingValuesMap.entrySet();
        Long modValue = 0L;
        for (Map.Entry<String, Collection<Long>> entry : entries) {
            Collection<Long> values = entry.getValue();
            Long count = values.stream().findFirst().get();
            modValue = (count % size) + modValue;
        }
        modValue = modValue % size;
        finalTargetNames.add(logicTableName + "_" + modValue);
        return finalTargetNames;
    }

2、写对应的doSharding逻辑，返回的就是对应的表信息;；

3、配置对应的规则,和基本的配置一样，区别是配置算法的属性的信息的时候要配置；

strategy 策略 和对应的算法类 algorithmClassName

全配置信息

spring:
  application:
    name: shardingjdbcDemo
  main:
    allow-bean-definition-overriding: true

  shardingsphere:
   数据源信息
    datasource:
     名称为dbsource-0的数据源
      dbsource-0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: 123456
      names: dbsource-0
   规则的配置
    rules:
      sharding:
        tables:
         配置表的规则
          t_order:
            actual-data-nodes: dbsource-0.t_order_$->{0..3}
           分表策略
            table-strategy:
             多分片键策略
              COMPLEX:
                sharding-columns: oder_id,user_id
                sharding-algorithm-name: table-inline
       分片算法
        sharding-algorithms:
          table-inline:
            type: CLASS_BASED
            props:
              strategy: COMPLEX
              algorithmClassName: com.example.shardingjdbcdemo.shardingalgorithm.OrderComplexAlgorithm

    props:
      sql-show: true
      sql-comment-parse-enabled: true

分片算法原理

ShardingAlgorithm 是分片算法的顶层接口;

StandardShardingAlgorithm 是标准分片算法的接口
ComplexKeysShardingAlgorithm 是多键的接口
HintShardingAlgorithm 是强制路由的接口

标准分片接口中定义了2个分片方法，

第一个参数是根据配置的 actual-data-nodes 得到了所有真实的表的节点；

当执行普通的不包含范围查询的查询的时候会调用第一个分片得到对应的一个真实表；

而包含范围关系查询的时候会调用第二个方法获取多个需要查询的表;

以最检查的 ModShardingAlgorithm 算法实现逻辑查看;

1、首先可以看到有一些定义的常量值，这些就是此算法可以定义的那些属性，如果想看下具体可以配置那些属性的时候，直接点到对应的类中查看即可;；

2、 init()初始化方法，在算法类被创建的时候会执行一次，做一些初始化的操作，这里是获取配置的分片的数量并记录下来;；

3、 doSharding(finalCollection availableTargetNames,finalPreciseShardingValue<Comparable<?>>shardingValue)；

遍历所有可用的分片表，使用**分片键 (shardingValue 从sql 的值中解析)**的值和可用表做比对;

4、范围查询分片doSharding(finalCollection availableTargetNames,finalRangeShardingValue<Comparable<?>>shardingValue)；

大致逻辑是根据范围查询的上下限的值来判断当前的查询是否需要查询所有的可用表，如果需要就全部查询得到结果后归并，如果不需要就查询指定的表；目的就是为了能够定位到确定的表;

ClassBasedShardingAlgorithm 说明

ClassBasedShardingAlgorithm 实现了多个分片算法接口，每一种策略的接口都实现了;

内部聚合了多种算法的接口,以一种静态代理的方式来完成分片逻辑的处理;

初始化的时候根据配置的策略名称来实例化对应的自定义算法类;

其他的内置算法类的实现都大致差不多，可直接根据配置的type 搜索到对用的具体实现类，有需要的话查看具体逻辑，这里不再赘述;

文章推荐： 01、Sharding-JDBC 实战；介绍和基本原理

文章推荐： 09、Sharding-JDBC 实战；配置数据源分离

文章推荐： 02、Sharding-JDBC 实战；开始使用

文章推荐： 03、Sharding-JDBC 实战；选择分片策略

03、Sharding-JDBC 实战；Sharding-JDBC分片原理
1、SQL解析当Sharding-JDBC接受到一条SQL语句时，会陆续执行 SQL解析 => 查询优化 => SQL路由 => SQL改写 => SQL执行 =>结
04、Sharding-JDBC 实战；Sharding-JDBC实现读写分离
1、读写分离简介对于同一时刻有大量并发读操作和较少写操作类型的应用系统来说，将数据库拆分为主库和从库，主库负责处理事务性的增删改操作，从库负责处理查询操作，能够有效的避免由数据更新导致的行锁，使得
10、Sharding-JDBC 实战 - Sharding-JDBC 核心之归并引擎
将从各个数据节点获取的多数据结果集，组合成为一个结果集并正确的返回至请求客户端，称为结果归并。也是Sharding 执行过程 SQL解析 => 执行器优化 => SQL路由 => S
11、Sharding-JDBC 实战 - Sharding-JDBC 核心之执行引擎
ShardingSphere采用一套自动化的执行引擎，负责将路由和改写完成之后的真实SQL安全且高效发送到底层数据源执行。它不是简单地将SQL通过JDBC直接发送至数据源执行；也并非直接将执行请求放
09、Sharding-JDBC 实战 - Sharding-JDBC 核心之解析引擎
Sharding-jdbc 官方文档讲的不是很全面和清楚，学习的时候特意再记录补充下官方文档地址：http://shardingsphere.apache.org/index_zh.html 一
07、Sharding-JDBC 实战：update报错：Can not update sharding key
1.详细报错信息： Caused by: org.apache.ibatis.exceptions.PersistenceException: ## Error updating database.
Question on sharding using planetscale (keeping data within a country using sharding)(关于使用planetscale进行分片的问题（使用分片将数据保存在一个国家内）)
I'm building a niche social media DB on planetscale that spans users living in multiple countries
Tensorflow - Keras : Consider either turning off auto-sharding or switching the auto_shard_policy to DATA to shard this dataset
在 keras/tensorflow 中训练模型时: 代码片段: strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
sharding-jdbc兼容MybatisPlus的动态数据源
背景：之前的项目做读写分离的时候用的 MybatisPlus的动态数据做的，很多地方使用的@DS直接指定的读库或者写库实现的业务；随着表数据量越来越大，现在打算把比较大的表进行水平拆分，准备使用
Sharding JDBC案例实战
基础分库以下实例基于shardingsphere 4.1.0 + SpringBoot 2.2.5.RELEASE版本依赖导入： UTF-8 UTF-8 2.2.5.RE
sharding - 我如何了解有关网站分片用户数据的更多信息？
我有兴趣在多个服务器上分割我的网站用户数据。例如，用户将从同一位置登录。但登录脚本需要弄清楚用户数据驻留在哪个服务器上。因此，登录脚本将在主注册表中查询该用户名，并且可能会返回该用户名位于服务器 B
聊聊分布式数据库的 Sharding，你了解吗？
最近我们团队的D-SMART在做蚂蚁的OCEANBASE的适配，因此又把OB的资料拿出来，重新做研究。要想让D-SMART纳管OCEANBASE，不像一些传统的监控软件那么简单，只要把一些关键指标接
sharding-jdbc5.0.0分表实践
本文基于shardingsphere-jdbc-core-spring-boot-starter 5.0.0，请注意不同版本的sharding-jdbc配置可能有不一样的地方，本文不一定适用于其它版本
sharding - 如何在 ArangoDB 中设置集群和分片？
我想在 arangoDB 中使用分片。我已经制作了协调器，如文档 2.8.5 中提到的 DBServers。但是仍然有人仍然可以详细解释它，以及我如何能够在分片前后检查查询的性能。最佳答案可以测试
sharding - 每个 kinesis 分片有多个消费者
我读到每个 kinesis 流可以有多个消费者应用程序。 http://docs.aws.amazon.com/kinesis/latest/dev/developing-consumers-with
php - 设置或规避 MySql Sharding
我正在使用一个预先存在的 bash 文件为开源数据服务器(Zotero)设置一系列数据库，但我遇到了一个我不熟悉的 mysql 结构: MASTER="mysql -h localhost -P 33
Elasticsearch: "shard allocation"是什么意思？
我们遇到了一个生产事件，Elasticsearch 集群健康检查返回了 red 状态。健康检查报告显示 marvel-2019.06.20 有 2 个 unassigned_shards，这似乎是根本
算法题: Minimum Shard Movement
我在分布式系统中遇到分片移动问题。【问题】最初每个分区负责任意数量的分片。 (这个数字可以是任意的，因为系统支持将分片从一个分区移动到另一个分区) 然后一个新的分区来了，系统需要重新分片。目标是使
Sharding-Jdbc 自定义复合分片的实现(分库分表)
Sharding-JDBC中的分片策略有两个维度，分别是：数据源分片策略（DatabaseShardingStrategy）表分片策略（TableShardingStrategy）
mysql sharding(碎片)介绍
1、Sharding 的应用场景一般都那些？当数据库中的数据量越来越大时，不论是读还是写，压力都会变得越来越大。试想，如果一张表中的数据量达到了千万甚至上亿级别的时候，不管是建索引，优化缓存等，

大佬之路

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城