sharding-jdbc-springboot简单样例

ShardingSphere官方文档

ShardingSphere

样例源代码

sharding-jdbc-springboot

1,sharding-jdbc 基本概念

逻辑表 :水平拆分的数据库(表)的相同逻辑和数据结构表的总称。例:订单数据根据主键尾数拆分为 10 张表,分别是 t_order_0 到 t_order_9,他们的逻辑表名为 t_order。

真实表:数据库中真实存在的物理表。即上个示例中的 t_order_0 到 t_order_9。

数据节点:数据分片的最小单元。由数据源名称和数据表组成,例:ds_0.t_order_0。

绑定表:分片规则一致的主表和子表。例如:t_order 表和 t_order_item 表,均按照 order_id 分片,则此两张表互为绑定表关系。

广播表:指所有的分片数据源中都存在的表,表结构和表中的数据在每个数据库中均完全一致。例如:字典表。

分片键:将数据库(表)水平拆分的关键字段

分片算法:

通过分片算法将数据分片。

StandardShardingAlgorithm:标准分片算法,用于处理使用单一键作为分片键的 =、IN、BETWEEN AND、>、<、>=、<=进行分片的场景。需要配合 StandardShardingStrategy 使用。

ComplexKeysShardingAlgorithm :复合分片算法,用于处理使用多键作为分片键进行分片的场景,包含多个分片键的逻辑较复杂,需要应用开发者自行处理其中的复杂度。需要配合 ComplexShardingStrategy 使用。

HintShardingAlgorithm :Hint分片算法,用于处理使用 Hint 行分片的场景。需要配合 HintShardingStrategy 使用。

分片策略:

包含分片键和分片算法,由于分片算法的独立性,将其独立抽离。真正可用于分片操作的是分片键 + 分片算法,也就是分片策略。目前提供 5 种分片策略。

StandardShardingStrategy:”标准分片策略。提供对 SQ L语句中的 =, >, <, >=, <=, IN 和 BETWEEN AND 的分片操作支持。 StandardShardingStrategy 只支持单分片键,提供 PreciseShardingAlgorithm 和 RangeShardingAlgorithm 两个分片算法。 PreciseShardingAlgorithm 是必选的,用于处理 = 和 IN 的分片。 RangeShardingAlgorithm 是可选的,用于处理 BETWEEN AND, >, <, >=, <=分片,如果不配置 RangeShardingAlgorithm,SQL 中的 BETWEEN AND 将按照全库路由处理。

ComplexShardingStrategy:复合分片策略。提供对 SQL 语句中的 =, >, <, >=, <=, IN 和 BETWEEN AND 的分片操作支持。 ComplexShardingStrategy 支持多分片键,由于多分片键之间的关系复杂,因此并未进行过多的封装,而是直接将分片键值组合以及分片操作符透传至分片算法,完全由应用开发者实现,提供最大的灵活度。

HintShardingStrategy:Hint分片策略,通过 Hint 指定分片值而非从 SQL 中提取分片值的方式进行分片的策略。

NoneShardingStrategy:不分片策略

行表达式

行表达式的使用非常直观,只需要在配置中使用 ${ expression } 或 $->{ expression } 标识行表达式即可。 目前支持数据节点和分片算法这两个部分的配置。行表达式的内容使用的是 Groovy 的语法,Groovy 能够支持的所有操作,行表达式均能够支持。例如:

${begin…end} 表示范围区间

${[unit1, unit2, unit_x]} 表示枚举值

例如,以下行表达式:

$->{['online', 'offline']}_table$->{1..3}

最终会解析为:

online_table1, online_table2, online_table3, offline_table1, offline_table2, offline_table3

2,实例

1,引入jar包


        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-test
        
        
            org.projectlombok
            lombok
            1.18.10
        
        
            com.github.pagehelper
            pagehelper-spring-boot-starter
            1.2.12
        
        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            2.0.1
        
        
            org.springframework.boot
            spring-boot-starter-jdbc
        
        
            mysql
            mysql-connector-java
            runtime
        
        
            org.apache.shardingsphere
            sharding-jdbc-spring-boot-starter
            4.1.1
        
        
        
            io.springfox
            springfox-swagger2
            2.8.0
        
        
            io.springfox
            springfox-swagger-ui
            2.8.0
        
        
        
            org.aspectj
            aspectjrt
            1.8.6
        
        
            org.aspectj
            aspectjweaver
            1.8.6
        
        
        
            org.springframework.boot
            spring-boot-starter-validation
            2.2.2.RELEASE
        
        
            org.apache.commons
            commons-lang3
            3.11
        
    

2,配置

application.yml 文件

server:
  port: 8081
spring:
  shardingsphere:
    props:
      sql:
        # 打印sql
        show: true
    orchestration:
      registry:
        #操作超时的毫秒数,默认500毫秒
        operation-timeout-milliseconds: 600000
    datasource:
      names: ds0,ds0slave,ds1,ds1slave
      ds0:
        driverClassName: com.mysql.cj.jdbc.Driver
        type: com.zaxxer.hikari.HikariDataSource
        jdbcUrl: jdbc:mysql://192.168.16.128:3306/ds0?useUnicode=true&characterEncoding=utf-8&autoReconnect=true&serverTimezone=UTC
        username: root
        password: 123456
        # hikari 的线程池配置
        maximumPoolSize: 20
        minimumIdle: 10
      ds0slave:
        driverClassName: com.mysql.cj.jdbc.Driver
        type: com.zaxxer.hikari.HikariDataSource
        jdbcUrl: jdbc:mysql://192.168.16.129:3306/ds0?useUnicode=true&characterEncoding=utf-8&autoReconnect=true&serverTimezone=UTC
        username: root
        password: 123456
        # hikari 的线程池配置
        maximumPoolSize: 20
        minimumIdle: 10
      ds1:
        driverClassName: com.mysql.cj.jdbc.Driver
        type: com.zaxxer.hikari.HikariDataSource
        jdbcUrl: jdbc:mysql://192.168.16.128:3306/ds1?useUnicode=true&characterEncoding=utf-8&autoReconnect=true&serverTimezone=UTC
        username: root
        password: 123456
        # hikari 的线程池配置
        maximumPoolSize: 20
        minimumIdle: 10
      ds1slave:
        driverClassName: com.mysql.cj.jdbc.Driver
        type: com.zaxxer.hikari.HikariDataSource
        jdbcUrl: jdbc:mysql://192.168.16.129:3306/ds1?useUnicode=true&characterEncoding=utf-8&autoReconnect=true&serverTimezone=UTC
        username: root
        password: 123456
        # hikari 的线程池配置
        maximumPoolSize: 20
        minimumIdle: 10
    sharding:
      #未分片表的默认数据库
      default-data-source-name: ds0
      #读写分离
      master-slave-rules:
        ds0:
          master-data-source-name: ds0
          slave-data-source-names: ds0slave
        ds1:
          master-data-source-name: ds1
          slave-data-source-names: ds1slave
      tables:
        #分表案例
        users:
          actual-data-nodes: ds0.users_$->{0..1}
          key-generator:
            column: id
            type: SNOWFLAKE
          table-strategy:
            inline:
              sharding-column: id
              algorithm-expression: users_$->{id % 2}
        #分表分库案例
        user_pack_records:
          actual-data-nodes: ds0.user_pack_records_$->{2018..2019},ds1.user_pack_records_$->{2020..2021}
          key-generator:
            column: id
            type: SNOWFLAKE
          database-strategy:
            standard:
              sharding-column: start_time
              precise-algorithm-class-name: com.sharding.jdbc.algorithm.db.UserPackRecordsAlgorithm
              range-algorithm-class-name: com.sharding.jdbc.algorithm.db.UserPackRecordsAlgorithm
          table-strategy:
            standard:
              sharding-column: start_time
              precise-algorithm-class-name: com.sharding.jdbc.algorithm.table.UserPackRecordsAlgorithm
              range-algorithm-class-name: com.sharding.jdbc.algorithm.table.UserPackRecordsAlgorithm
mybatis:
  configuration:
    #驼峰转化
    map-underscore-to-camel-case: true
  # Java 与 Mysql 的类型转化基础包
  type-handlers-package: com.sharding.jdbc.convert

3,自定义数据库分片算法


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

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * user_pack_records 分库:阅读时间 start_time 在2018-2019 在 db0,2020-2021 在db1
 */
public class UserPackRecordsAlgorithm implements PreciseShardingAlgorithm<LocalDateTime>, RangeShardingAlgorithm<LocalDateTime> {

    /**
     * 通过年份获取真实数据库
     *
     * @param year 年份
     * @return 真实数据库
     */
    private String getDbByYear(Integer year) {
        if (year == 2018 || year == 2019) {
            return "ds0";
        } else if (year == 2020 || year == 2021) {
            return "ds1";
        }
        throw new IllegalArgumentException();
    }

    /**
     * PreciseShardingAlgorithm 是必选的,用于处理=和IN的分片。
     *
     * @param availableDbNames 可用的数据库集合
     * @param shardingValue    分片键
     * @return 真实数据库
     */
    @Override
    public String doSharding(Collection<String> availableDbNames, PreciseShardingValue<LocalDateTime> shardingValue) {
        int year = shardingValue.getValue().getYear();
        return getDbByYear(year);
    }

    /**
     * RangeShardingAlgorithm 可选,用于处理BETWEEN AND, >, <, >=, <=分片
     *
     * @param availableDbNames   可用的数据库集合
     * @param rangeShardingValue 分片键
     * @return 真实数据库
     */
    @Override
    public Collection<String> doSharding(Collection<String> availableDbNames, RangeShardingValue<LocalDateTime> rangeShardingValue) {
        List<String> dbs = new ArrayList<>();
        int lowerYear = rangeShardingValue.getValueRange().lowerEndpoint().toLocalDate().getYear();
        LocalDate startDate = LocalDate.of(lowerYear, 1, 1);
        LocalDate endDate = rangeShardingValue.getValueRange().upperEndpoint().toLocalDate();
        for (LocalDate curDate = startDate; curDate.isBefore(endDate) || curDate.isEqual(endDate); curDate = curDate.plusYears(1)) {
            dbs.add(getDbByYear(curDate.getYear()));
        }
        return dbs;
    }
}

自定义分表算法

package com.sharding.jdbc.algorithm.table;

import org.apache.commons.lang3.StringUtils;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingValue;
import org.apache.shardingsphere.api.sharding.standard.RangeShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.RangeShardingValue;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class UserPackRecordsAlgorithm implements PreciseShardingAlgorithm<LocalDateTime>, RangeShardingAlgorithm<LocalDateTime> {
    /**
     * 通过年份获取真实表
     *
     * @param year 年份
     * @return 真实表
     */
    private String getTableByYear(Collection<String> availableTargetNames, String year) {
        for (String targetName : availableTargetNames) {
            if (targetName.endsWith(year)) {
                return targetName;
            }
        }
        return null;
    }

    /**
     * PreciseShardingAlgorithm 是必选的,用于处理=和IN的分片。
     *
     * @param availableTargetNames 可用的表集合
     * @param shardingValue        分片键
     * @return 真实表
     */
    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<LocalDateTime> shardingValue) {
        LocalDateTime startTime = shardingValue.getValue();
        return getTableByYear(availableTargetNames, String.valueOf(startTime.getYear()));
    }

    /**
     * RangeShardingAlgorithm 可选,用于处理BETWEEN AND, >, <, >=, <=分片
     *
     * @param availableTargetNames 可用的表集合
     * @param rangeShardingValue   分片键
     * @return 真实表
     */
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames, RangeShardingValue<LocalDateTime> rangeShardingValue) {
        List<String> tables = new ArrayList<>();
        int lowerYear = rangeShardingValue.getValueRange().lowerEndpoint().toLocalDate().getYear();
        LocalDate startDate = LocalDate.of(lowerYear, 1, 1);
        LocalDate endDate = rangeShardingValue.getValueRange().upperEndpoint().toLocalDate();
        for (LocalDate curDate = startDate; curDate.isBefore(endDate) || curDate.isEqual(endDate); curDate = curDate.plusYears(1)) {
            String table = getTableByYear(availableTargetNames, String.valueOf(curDate.getYear()));
            if (StringUtils.isNotBlank(table)) {
                tables.add(table);
            }
        }
        return tables;
    }
}

4,详细代码请进入githut看源代码
sharding-jdbc-springboot

你可能感兴趣的:(java,java,spring)