SpringBoot 集成 ShardingSphere 进行数据库分表实战案例

实战配置

引入jar包依赖

<dependency>
    <groupId>io.shardingspheregroupId>
    <artifactId>sharding-jdbc-spring-boot-starterartifactId>
    <version>3.0.0.M3version>
dependency>

配置信息

# 注释掉： spring.datasource.***

# inline 和 standard 选择其一
sharding:
  jdbc:
    datasource:
      names: ds0
      ds0:
        password: 123456
        username: root
        jdbcUrl: jdbc:mysql://127.0.1.1:3306/ocr?cuseUnicode=true&characterEncoding=UTF-8&useSSL=false&allowMultiQueries=true&serverTimezone=GMT%2B8
        driverClassName: com.mysql.cj.jdbc.Driver
        type: com.zaxxer.hikari.HikariDataSource
    config:
      sharding:
      	# 绑定表规则列表, 多个用逗号隔开
        binding-tables: zspa_vs_asset_package
        tables:
          zspa_vs_asset_package:
            # 所有数据节点
            actual-data-nodes: ds0.zspa_vs_asset_package_${0..2}
            table-strategy:
            # 行表达式分片策略
#              inline:
#                # 根据这个列分表
#                sharding-column: asset_package_id
#                # 分表规则为:对 asset_package_id 取模
#                algorithm-expression: zspa_vs_asset_package_${asset_package_id % 3}
              standard:
                sharding-column: asset_package_id
                precise-algorithm-class-name: com.answer.ai.config.MyPreciseAlgorithm
            # 设置主键列生成器
            key-generator-column-name: asset_package_id 
            key-generator-class-name: com.answer.ai.config.GeneratorId # 缺省时用 默认 DefaultKeyGenerator
        props:
          sql:
            show: true

自定义 id 生成器

public class GeneratorId implements KeyGenerator {
    private static final AtomicInteger ID = new AtomicInteger(1);

    @Override
    public Number generateKey() {
        return ID.getAndIncrement();
    }
}

自定义分片算法

@Slf4j
public class MyPreciseAlgorithm implements PreciseShardingAlgorithm<Integer> {

    @Override
    public String doSharding(final Collection<String> availableTargetNames, final PreciseShardingValue<Integer> shardingValue) {
        Integer value = shardingValue.getValue();
        String logicTableName = shardingValue.getLogicTableName();
        String shardingColumn = shardingValue.getColumnName();
        log.info("shardingColumn={}, value={}, logicTableName={}, availableTargetNames={}", shardingColumn, value, logicTableName, JSON.toJSONString(availableTargetNames));

        for (String each : availableTargetNames) {
            if (each.endsWith(value % 3 + "")) {
                return each;
            }
        }
        throw new UnsupportedOperationException();
    }

}

配置示例

数据分片 + 读写分离

sharding.jdbc.datasource.names=ds_master_0,ds_master_1,ds_master_0_slave_0,ds_master_0_slave_1,ds_master_1_slave_0,ds_master_1_slave_1

sharding.jdbc.datasource.ds_master_0.type=org.apache.commons.dbcp.BasicDataSource
sharding.jdbc.datasource.ds_master_0.driver-class-name=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_0.url=jdbc:mysql://localhost:3306/ds_master_0
sharding.jdbc.datasource.ds_master_0.username=root
sharding.jdbc.datasource.ds_master_0.password=

sharding.jdbc.datasource.ds_master_0_slave_0.type=org.apache.commons.dbcp.BasicDataSource
sharding.jdbc.datasource.ds_master_0_slave_0.driver-class-name=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_0_slave_0.url=jdbc:mysql://localhost:3306/ds_master_0_slave_0
sharding.jdbc.datasource.ds_master_0_slave_0.username=root
sharding.jdbc.datasource.ds_master_0_slave_0.password=
sharding.jdbc.datasource.ds_master_0_slave_1.type=org.apache.commons.dbcp.BasicDataSource
sharding.jdbc.datasource.ds_master_0_slave_1.driver-class-name=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_0_slave_1.url=jdbc:mysql://localhost:3306/ds_master_0_slave_1
sharding.jdbc.datasource.ds_master_0_slave_1.username=root
sharding.jdbc.datasource.ds_master_0_slave_1.password=

sharding.jdbc.datasource.ds_master_1.type=org.apache.commons.dbcp.BasicDataSource
sharding.jdbc.datasource.ds_master_1.driver-class-name=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_1.url=jdbc:mysql://localhost:3306/ds_master_1
sharding.jdbc.datasource.ds_master_1.username=root
sharding.jdbc.datasource.ds_master_1.password=

sharding.jdbc.datasource.ds_master_1_slave_0.type=org.apache.commons.dbcp.BasicDataSource
sharding.jdbc.datasource.ds_master_1_slave_0.driver-class-name=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_1_slave_0.url=jdbc:mysql://localhost:3306/ds_master_1_slave_0
sharding.jdbc.datasource.ds_master_1_slave_0.username=root
sharding.jdbc.datasource.ds_master_1_slave_0.password=
sharding.jdbc.datasource.ds_master_1_slave_1.type=org.apache.commons.dbcp.BasicDataSource
sharding.jdbc.datasource.ds_master_1_slave_1.driver-class-name=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_1_slave_1.url=jdbc:mysql://localhost:3306/ds_master_1_slave_1
sharding.jdbc.datasource.ds_master_1_slave_1.username=root
sharding.jdbc.datasource.ds_master_1_slave_1.password=

sharding.jdbc.config.sharding.default-database-strategy.inline.sharding-column=user_id
sharding.jdbc.config.sharding.default-database-strategy.inline.algorithm-expression=ds_$->{user_id % 2}

sharding.jdbc.config.sharding.tables.t_order.actual-data-nodes=ds_$->{0..1}.t_order_$->{0..1}
sharding.jdbc.config.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
sharding.jdbc.config.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_$->{order_id % 2}
sharding.jdbc.config.sharding.tables.t_order.key-generator-column-name=order_id
sharding.jdbc.config.sharding.tables.t_order_item.actual-data-nodes=ds_$->{0..1}.t_order_item_$->{0..1}
sharding.jdbc.config.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id
sharding.jdbc.config.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_$->{order_id % 2}
sharding.jdbc.config.sharding.tables.t_order_item.key-generator-column-name=order_item_id

sharding.jdbc.config.sharding.master-slave-rules.ds_0.master-data-source-name=ds_master_0
sharding.jdbc.config.sharding.master-slave-rules.ds_0.slave-data-source-names=ds_master_0_slave_0, ds_master_0_slave_1
sharding.jdbc.config.sharding.master-slave-rules.ds_1.master-data-source-name=ds_master_1
sharding.jdbc.config.sharding.master-slave-rules.ds_1.slave-data-source-names=ds_master_1_slave_0, ds_master_1_slave_1

配置项说明

数据分片

sharding.jdbc.datasource.names= #数据源名称，多数据源以逗号分隔

sharding.jdbc.datasource..type= #数据库连接池类名称
sharding.jdbc.datasource..driver-class-name= #数据库驱动类名
sharding.jdbc.datasource..url= #数据库url连接
sharding.jdbc.datasource..username= #数据库用户名
sharding.jdbc.datasource..password= #数据库密码
sharding.jdbc.datasource..xxx= #数据库连接池的其它属性

sharding.jdbc.config.sharding.tables..actual-data-nodes= #由数据源名 + 表名组成，以小数点分隔。多个表以逗号分隔，支持inline表达式。缺省表示使用已知数据源与逻辑表名称生成数据节点。用于广播表（即每个库中都需要一个同样的表用于关联查询，多为字典表）或只分库不分表且所有库的表结构完全一致的情况

#分库策略，缺省表示使用默认分库策略，以下的分片策略只能选其一

#用于单分片键的标准分片场景
sharding.jdbc.config.sharding.tables..database-strategy.standard.sharding-column= #分片列名称
sharding.jdbc.config.sharding.tables..database-strategy.standard.precise-algorithm-class-name= #精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
sharding.jdbc.config.sharding.tables..database-strategy.standard.range-algorithm-class-name= #范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器

#用于多分片键的复合分片场景
sharding.jdbc.config.sharding.tables..database-strategy.complex.sharding-columns= #分片列名称，多个列以逗号分隔
sharding.jdbc.config.sharding.tables..database-strategy.complex.algorithm-class-name= #复合分片算法类名称。该类需实现ComplexKeysShardingAlgorithm接口并提供无参数的构造器

# 行表达式分片策略
sharding.jdbc.config.sharding.tables..database-strategy.inline.sharding-column= #分片列名称
sharding.jdbc.config.sharding.tables..database-strategy.inline.algorithm-inline-expression= #分片算法行表达式，需符合groovy语法

# Hint分片策略
sharding.jdbc.config.sharding.tables..database-strategy.hint.algorithm-class-name= #Hint分片算法类名称。该类需实现HintShardingAlgorithm接口并提供无参数的构造器

# 分表策略，同分库策略
sharding.jdbc.config.sharding.tables..table-strategy.xxx= #省略

sharding.jdbc.config.sharding.tables..key-generator-column-name= #自增列名称，缺省表示不使用自增主键生成器
sharding.jdbc.config.sharding.tables..key-generator-class-name= #自增列值生成器类名称，缺省表示使用默认自增列值生成器。该类需提供无参数的构造器

sharding.jdbc.config.sharding.tables..logic-index= #逻辑索引名称，对于分表的Oracle/PostgreSQL数据库中DROP INDEX XXX语句，需要通过配置逻辑索引名称定位所执行SQL的真实分表

sharding.jdbc.config.sharding.binding-tables[0]= #绑定表规则列表
sharding.jdbc.config.sharding.binding-tables[1]= #绑定表规则列表
sharding.jdbc.config.sharding.binding-tables[x]= #绑定表规则列表

sharding.jdbc.config.sharding.default-data-source-name= #未配置分片规则的表将通过默认数据源定位
sharding.jdbc.config.sharding.default-database-strategy.xxx= #默认数据库分片策略，同分库策略
sharding.jdbc.config.sharding.default-table-strategy.xxx= #默认表分片策略，同分表策略
sharding.jdbc.config.sharding.default-key-generator-class-name= #默认自增列值生成器类名称，缺省使用io.shardingjdbc.core.keygen.DefaultKeyGenerator。该类需实现KeyGenerator接口并提供无参数的构造器

sharding.jdbc.config.sharding.master-slave-rules..master-data-source-name= #详见读写分离部分
sharding.jdbc.config.sharding.master-slave-rules..slave-data-source-names[0]= #详见读写分离部分
sharding.jdbc.config.sharding.master-slave-rules..slave-data-source-names[1]= #详见读写分离部分
sharding.jdbc.config.sharding.master-slave-rules..slave-data-source-names[x]= #详见读写分离部分
sharding.jdbc.config.sharding.master-slave-rules..load-balance-algorithm-class-name= #详见读写分离部分
sharding.jdbc.config.sharding.master-slave-rules..load-balance-algorithm-type= #详见读写分离部分
sharding.jdbc.config.sharding.master-slave-rules..config.map.key1= #详见读写分离部分
sharding.jdbc.config.sharding.master-slave-rules..config.map.key2= #详见读写分离部分
sharding.jdbc.config.sharding.master-slave-rules..config.map.keyx= #详见读写分离部分

sharding.jdbc.config.sharding.props.sql.show= #是否开启SQL显示，默认值: false
sharding.jdbc.config.sharding.props.executor.size= #工作线程数量，默认值: CPU核数

sharding.jdbc.config.sharding.config.map.key1= #用户自定义配置
sharding.jdbc.config.sharding.config.map.key2= #用户自定义配置
sharding.jdbc.config.sharding.config.map.keyx= #用户自定义配置

读写分离

#省略数据源配置，与数据分片一致

sharding.jdbc.config.sharding.master-slave-rules..master-data-source-name= #主库数据源名称
sharding.jdbc.config.sharding.master-slave-rules..slave-data-source-names[0]= #从库数据源名称列表
sharding.jdbc.config.sharding.master-slave-rules..slave-data-source-names[1]= #从库数据源名称列表
sharding.jdbc.config.sharding.master-slave-rules..slave-data-source-names[x]= #从库数据源名称列表
sharding.jdbc.config.sharding.master-slave-rules..load-balance-algorithm-class-name= #从库负载均衡算法类名称。该类需实现MasterSlaveLoadBalanceAlgorithm接口且提供无参数构造器
sharding.jdbc.config.sharding.master-slave-rules..load-balance-algorithm-type= #从库负载均衡算法类型，可选值：ROUND_ROBIN，RANDOM。若`load-balance-algorithm-class-name`存在则忽略该配置

sharding.jdbc.config.sharding.master-slave-rules..config.map.key1= #用户自定义配置
sharding.jdbc.config.sharding.master-slave-rules..config.map.key2= #用户自定义配置
sharding.jdbc.config.sharding.master-slave-rules..config.map.keyx= #用户自定义配置

配置项说明-2

sharding:
  jdbc:
    datasource:
      names: ds0, ds1 # 数据源名称，多数据源以逗号分隔
      ds0:
        type: # 数据库连接池类名称
        driver-class-name: com.mysql.cj.jdbc.Driver # 数据库驱动类名
        url: jdbc:mysql://localhost:3306/ds0?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&characterEncoding=utf8 # 数据库url连接
        username: root # 数据库用户名
        password: root # 数据库密码
        xxx: #数据库连接池的其它属性
      ds1:
        type:
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://localhost:3306/ds1?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&characterEncoding=utf8
          username: root
          password: root
    config:
      props:
        sql:
          show: true # 是否开启SQL显示，默认值: false
          executor:
            size: # 工作线程数量，默认值: CPU核数
          check:
            table:
              metadata:
                enabled: # 是否在启动时检查分表元数据一致性，默认值: false
      sharding:
        binding-tables: # 绑定表规则列表1
        broadcast-tables: #广播表规则列表1
        default-data-source-name: # 未配置分片规则的表将通过默认数据源定位
        default-database-strategy: # 默认数据库分片策略，同分库策略
          inline:
            sharding-column: user_id
            algorithm-expression: ds$->{user_id % 2}
        default-table-strategy: # 默认表分片策略，同分表策略
        default-key-generator-class-name: # 默认自增列值生成器类名称，缺省使用io.shardingsphere.core.keygen.DefaultKeyGenerator。该类需实现KeyGenerator接口并提供无参数的构造器
        tables: # 数据分片
          t_order:
            # 由数据源名 + 表名组成，以小数点分隔。多个表以逗号分隔，支持inline表达式。缺省表示使用已知数据源与逻辑表名称生成数据节点。用于广播表（即每个库中都需要一个同样的表用于关联查询，多为字典表）或只分库不分表且所有库的表结构完全一致的情况
            actual-data-nodes: ds$->{0..1}.t_order$->{0..1}
            database-strategy: # 分库策略 4选一
              standard: # 用于单分片键的标准分片场景
                sharding-column: # 分片列名称
                precise-algorithm-class-name: # 精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
                range-algorithm-class-name: # 范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器
              complex: # 用于多分片键的复合分片场景
                sharding-columns: # 分片列名称，多个列以逗号分隔
                algorithm-class-name: # 复合分片算法类名称。该类需实现ComplexKeysShardingAlgorithm接口并提供无参数的构造器
              inline: # 行表达式分片策略
                sharding-column: # 分片列名称
                algorithm-expression: # 分片算法行表达式，需符合groovy语法
              hint: # Hint分片策略
                algorithm-class-name: # Hint分片算法类名称。该类需实现HintShardingAlgorithm接口并提供无参数的构造器
            table-strategy: # 分表策略
              standard: # 用于单分片键的标准分片场景
                sharding-column: # 分片列名称
                precise-algorithm-class-name: # 精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
                range-algorithm-class-name: # 范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器
                complex: # 用于多分片键的复合分片场景
                  sharding-columns: # 分片列名称，多个列以逗号分隔
                  algorithm-class-name: # 复合分片算法类名称。该类需实现ComplexKeysShardingAlgorithm接口并提供无参数的构造器
                inline: # 行表达式分片策略
                  sharding-column: # 分片列名称
                  algorithm-expression: # 分片算法行表达式，需符合groovy语法
                hint: # Hint分片策略
                  algorithm-class-name: # Hint分片算法类名称。该类需实现HintShardingAlgorithm接口并提供无参数的构造器
            key-generator-column-name: # 自增列名称，缺省表示不使用自增主键生成器
            key-generator-class-name: # 自增列值生成器类名称，缺省表示使用默认自增列值生成器。该类需提供无参数的构造器
            logic-index: # 逻辑索引名称，对于分表的Oracle/PostgreSQL数据库中DROP INDEX XXX语句，需要通过配置逻辑索引名称定位所执行SQL的真实分表
          t_order_item:
            # 由数据源名 + 表名组成，以小数点分隔。多个表以逗号分隔，支持inline表达式。缺省表示使用已知数据源与逻辑表名称生成数据节点。用于广播表（即每个库中都需要一个同样的表用于关联查询，多为字典表）或只分库不分表且所有库的表结构完全一致的情况
            actual-data-nodes: ds$->{0..1}.t_order$->{0..1}
            database-strategy: # 分库策略
              standard: # 用于单分片键的标准分片场景
                sharding-column: # 分片列名称
                precise-algorithm-class-name: # 精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
                range-algorithm-class-name: # 范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器
              complex: # 用于多分片键的复合分片场景
                sharding-columns: # 分片列名称，多个列以逗号分隔
                algorithm-class-name: # 复合分片算法类名称。该类需实现ComplexKeysShardingAlgorithm接口并提供无参数的构造器
              inline: # 行表达式分片策略
                sharding-column: # 分片列名称
                algorithm-expression: # 分片算法行表达式，需符合groovy语法
              hint: # Hint分片策略
                algorithm-class-name: # Hint分片算法类名称。该类需实现HintShardingAlgorithm接口并提供无参数的构造器
            table-strategy: # 分表策略
              standard: # 用于单分片键的标准分片场景
                sharding-column: # 分片列名称
                precise-algorithm-class-name: # 精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
                range-algorithm-class-name: # 范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器
                complex: # 用于多分片键的复合分片场景
                  sharding-columns: # 分片列名称，多个列以逗号分隔
                  algorithm-class-name: # 复合分片算法类名称。该类需实现ComplexKeysShardingAlgorithm接口并提供无参数的构造器
                inline: # 行表达式分片策略
                  sharding-column: # 分片列名称
                  algorithm-expression: # 分片算法行表达式，需符合groovy语法
                hint: # Hint分片策略
                  algorithm-class-name: # Hint分片算法类名称。该类需实现HintShardingAlgorithm接口并提供无参数的构造器
        master-slave-rules: # 读写分离
          ds0: # 主从数据源的名称
            master-data-source-name: # 主库数据源名称
            slave-data-source-names: # 从库数据源名称列表
            load-balance-algorithm-class-name: # 从库负载均衡算法类名称。该类需实现MasterSlaveLoadBalanceAlgorithm接口且提供无参数构造器
            load-balance-algorithm-type: # 从库负载均衡算法类型，可选值：ROUND_ROBIN，RANDOM。若`load-balance-algorithm-class-name`存在则忽略该配置
          ds1: # 主从数据源的名称
            master-data-source-name: # 主库数据源名称
            slave-data-source-names: # 从库数据源名称列表
            load-balance-algorithm-class-name: # 从库负载均衡算法类名称。该类需实现MasterSlaveLoadBalanceAlgorithm接口且提供无参数构造器
            load-balance-algorithm-type: # 从库负载均衡算法类型，可选值：ROUND_ROBIN，RANDOM。若`load-balance-algorithm-class-name`存在则忽略该配置
          map:
            key1: # 用户自定义配置 Key1为用户填
            key2: # 用户自定义配置
        orchestration: # 数据治理
          name: # 数据治理实例名称
          overwrite: # 本地配置是否覆盖注册中心配置。如果可覆盖，每次启动都以本地配置为准
          registry:
            server-lists: # 连接注册中心服务器的列表。包括IP地址和端口号。多个地址用逗号分隔。如: host1:2181,host2:2181
            namespace: # 注册中心的命名空间
            digest: # 连接注册中心的权限令牌。缺省为不需要权限验证
            operation-timeout-milliseconds: # 操作超时的毫秒数，默认500毫秒
            max-retries: # 连接失败后的最大重试次数，默认3次
            retry-interval-milliseconds: # 重试间隔毫秒数，默认500毫秒
            time-to-live-seconds: # 临时节点存活秒数，默认60秒

参考文档

• Sharing-Sphere之Spring Boot配置
• SpringBoot + Sharding-jdbc3.x配置
• Spring Boot中整合Sharding-JDBC单库分表示例
• SpringBoot+Mybaits+sharding jdbc进行分库分表，亲测可行！（方法一）
• ☆官方文档-SpringBoot配置
• Springboot2.x + ShardingSphere 实现分库分表