Sharding-JDBC（二）四种分片策略

官网： https://shardingsphere.apache.org/index_zh.html

官方文档：https://shardingsphere.apache.org/document/current/cn/overview/

准备工作

1.SQL

-- ------------------------------
-- 用户表
-- ------------------------------
CREATE TABLE `t_user` (
  `id` bigint(16) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `username` varchar(64) NOT NULL COMMENT '用户名',
  `password` varchar(64) NOT NULL COMMENT '密码',
  `age` int(8) NOT NULL COMMENT '年龄',
  `salary` int(8) NOT NULL COMMENT '工资',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表';

-- ------------------------------
-- 用户表1
-- ------------------------------
CREATE TABLE `t_user_1` (
  `id` bigint(16) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `username` varchar(64) NOT NULL COMMENT '用户名',
  `password` varchar(64) NOT NULL COMMENT '密码',
  `age` int(8) NOT NULL COMMENT '年龄',
  `salary` int(8) NOT NULL COMMENT '工资',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表1';

-- ------------------------------
-- 用户表2
-- ------------------------------
CREATE TABLE `t_user_2` (
  `id` bigint(16) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `username` varchar(64) NOT NULL COMMENT '用户名',
  `password` varchar(64) NOT NULL COMMENT '密码',
  `age` int(8) NOT NULL COMMENT '年龄',
  `salary` int(8) NOT NULL COMMENT '工资',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表2';

2.数据源配置

注意：数据库命名不能使用下划线，会报错：mydb_0 invalid

spring:
  shardingsphere:
    # 打印sql
    props:
      sql:
        show: true
    datasource:
      names: mydb-1,mydb-2
      mydb-1:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/mydb-1?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
        driver-class-name: com.mysql.cj.jdbc.Driver
        username: root
        password: root
        # 数据源其他配置
        initialSize: 5
        minIdle: 5
        maxActive: 20
        maxWait: 60000
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 1 FROM DUAL
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
        #filters: stat,wall,log4j
        maxPoolPreparedStatementPerConnectionSize: 20
        useGlobalDataSourceStat: true
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
      mydb-2:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/mydb-2?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
        driver-class-name: com.mysql.cj.jdbc.Driver
        username: root
        password: root
        # 数据源其他配置
        initialSize: 5
        minIdle: 5
        maxActive: 20
        maxWait: 60000
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 1 FROM DUAL
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
        #filters: stat,wall,log4j
        maxPoolPreparedStatementPerConnectionSize: 20
        useGlobalDataSourceStat: true
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

一、标准分片策略

标准分片策略（StandardShardingStrategy）： 只支持对单个分片键为依据的分库分表，并提供了两种分片算法：

• PreciseShardingAlgorithm（精准分片）：在使用标准分片策略时，精准分片算法时必须实现的算法，用于SQL含有 = 和 IN 的分片处理；

• RangeShardingAlgorithm（范围分片）：非必选的，用于处理含有 BETWEEN AND 的分片处理。

  注意： 一旦我们没配置范围分片算法，而SQL中又用到 BETWEEN AND 或者 LIKE 等，那么 SQL 将按全库、表路由的方式逐一执行，查询性能会很差。

使用方法：

​ 使用四种分片策略的方式大致相同，都要实现相应的 ShardingAlgorithm 接口，并重写 doSharding() 方法，只是配置稍有不同，doSharding() 方法本身只是个空方法，需要我们自行处理分库、分表逻辑。

1.精准分片算法

使用场景：

• SQL 语句中有 >，>=，<=，<，=，IN 和 BETWEEN AND 操作符，都可以应用此分片策略。

select * from t_user where age = 10 or age in (10,11,12);

1.1 精准分库算法

yaml配置：

spring:
  shardingsphere:
    sharding:
      # 默认数据源，未分片的表默认执行库
      default-data-source-name: mydb-1
      # 表策略配置
      tables:
        # t_user 是逻辑表
        t_user:
          databaseStrategy:
            standard:
              # 分片键
              shardingColumn: age
              # 精准分库算法
              preciseAlgorithmClassName: com.demo.module.config.MyDBPreciseShardingAlgorithm

代码实现：

实现 PreciseShardingAlgorithm 接口，并重写 doSharding()。

public class MyDBPreciseShardingAlgorithm implements PreciseShardingAlgorithm<Integer> {
    
    

    @Override
    public String doSharding(Collection<String> databaseNames, PreciseShardingValue<Integer> shardingValue) {
    
    

        /**
         * databaseNames 所有分片库的集合
         * shardingValue 为分片属性，其中 logicTableName 为逻辑表，columnName 分片键，value 为从 SQL 中解析出的分片键的值
         */
        for (String databaseName : databaseNames) {
    
    
            // 根据年龄判断，未成年 -> mydb-1, 已成年 -> mydb-2
            String value = String.valueOf(shardingValue.getValue() < 18 ? 1 : 2);
            if (databaseName.endsWith(value)) {
    
    
                return databaseName;
            }
        }
        throw new IllegalArgumentException("分片失败，databaseNames：" + databaseNames);
    }
}

1.2 精准分表算法

yaml配置：

spring:
  shardingsphere:
    sharding:
      # 默认数据源，未分片的表默认执行库
      default-data-source-name: mydb-1
      # 表策略配置
      tables:
        # t_user 是逻辑表
        t_user:
          # 分表节点 可以理解为分表后的那些表 比如 t_user_1 ,t_user_2
          actualDataNodes: mydb-1.t_user_$->{
    
    1..2}
          tableStrategy:
            standard:
              # 分片键
              shardingColumn: age
              # 精准分表算法
              preciseAlgorithmClassName: com.demo.module.config.MyTablePreciseShardingAlgorithm

代码实现：

实现 PreciseShardingAlgorithm 接口，并重写 doSharding()。

public class MyTablePreciseShardingAlgorithm implements PreciseShardingAlgorithm<Integer> {
    
    

    @Override
    public String doSharding(Collection<String> tableNames, PreciseShardingValue<Integer> shardingValue) {
    
    
        /**
         * tableNames 对应分片库中所有分片表的集合
         * shardingValue 为分片属性，其中 logicTableName 为逻辑表，columnName 分片键，value 为从 SQL 中解析出来的分片键的值
         */
        for (String tableName : tableNames) {
    
    
            // 取模算法，分片键 % 表数量 + 1
            String value = String.valueOf(shardingValue.getValue() % tableNames.size() + 1);
            if (tableName.endsWith(value)) {
    
    
                return tableName;
            }
        }
        throw new IllegalArgumentException("分片失败，tableNames：" + tableNames);
    }
}

2.范围分片算法

使用场景：

• 当 SQL 中的分片键用到 BETWEEN AND 操作符会使用到此算法，会根据 SQL 中给出的分片键范围值处理分库分表逻辑。

select * from t_user where age between 10 and 12;

yaml配置：

spring:
  shardingsphere:
    sharding:
      # 默认数据源，未分片的表默认执行库
      default-data-source-name: mydb-1
      # 表策略配置
      tables:
        # t_user 是逻辑表
        t_user:
          databaseStrategy:
            standard:
              # 分片键
              shardingColumn: age
              # 精准分库算法
              preciseAlgorithmClassName: com.demo.module.config.MyDBPreciseShardingAlgorithm
              # 范围分库算法
              rangeAlgorithmClassName: com.demo.module.config.MyDBRangeShardingAlgorithm

代码实现：

实现 PreciseShardingAlgorithm 接口，并重写 doSharding()。

public class MyDBRangeShardingAlgorithm implements RangeShardingAlgorithm<Integer> {
    
    

    /**
     * 数据库分片符号
     */
    private final String DATABASE_SPLIT_SYMBOL = "-";

    @Override
    public Collection<String> doSharding(Collection<String> databaseNames, RangeShardingValue<Integer> rangeShardingValue) {
    
    
        Set<String> result = new LinkedHashSet<>();

        // between and 的起始值
        Range<Integer> valueRange = rangeShardingValue.getValueRange();
        boolean hasLowerBound = valueRange.hasLowerBound();
        boolean hasUpperBound = valueRange.hasUpperBound();

        // 计算最大值和最小值（未成年 -> mydb-1, 已成年 -> mydb-2）
        int lower;
        if (hasLowerBound) {
    
    
            lower = valueRange.lowerEndpoint() < 18 ? 1 : 2;
        } else {
    
    
            lower = getLowerEndpoint(databaseNames);
        }
        int upper;
        if (hasUpperBound) {
    
    
            upper = valueRange.upperEndpoint() < 18 ? 1 : 2;
        } else {
    
    
            upper = getUpperEndpoint(databaseNames);
        }

        // 循环范围计算分库逻辑
        for (int i = lower; i <= upper; i++) {
    
    
            for (String databaseName : databaseNames) {
    
    
                String value = String.valueOf(i);
                if (databaseName.endsWith(value)) {
    
    
                    result.add(databaseName);
                }
            }
        }
        return result;
    }

    // --------------------------------------------------------------------------------------------------------------
    // 私有方法
    // --------------------------------------------------------------------------------------------------------------

    /**
     * 获取 最小分片值
     * @param databaseNames 数据库名
     * @return 最小分片值
     */
    private int getLowerEndpoint(Collection<String> databaseNames) {
    
    
        if (CollectionUtils.isNotEmpty(databaseNames)) {
    
    
            return databaseNames.stream().filter(o -> o != null && o.contains(DATABASE_SPLIT_SYMBOL))
                    .mapToInt(o -> {
    
    
                        String[] splits = o.split(DATABASE_SPLIT_SYMBOL);
                        return Integer.valueOf(splits[splits.length - 1]);
                    }).min().orElse(-1);
        }
        return -1;
    }

    /**
     * 获取 最大分片值
     * @param databaseNames 数据库名
     * @return 最大分片值
     */
    private int getUpperEndpoint(Collection<String> databaseNames) {
    
    
        if (CollectionUtils.isNotEmpty(databaseNames)) {
    
    
            return databaseNames.stream().filter(o -> o != null && o.contains(DATABASE_SPLIT_SYMBOL))
                    .mapToInt(o -> {
    
    
                        String[] splits = o.split(DATABASE_SPLIT_SYMBOL);
                        return Integer.valueOf(splits[splits.length - 1]);
                    }).max().orElse(-1);
        }
        return -1;
    }
}

测试验证1-插入数据：

    @Test
    void saveTest() {
    
    
        List<TUser> users = new ArrayList<>(3);
        users.add(new TUser("ACGkaka_1", "123456", 10, 5000));
        users.add(new TUser("ACGkaka_2", "123456", 15, 6000));
        users.add(new TUser("ACGkaka_3", "123456", 18, 7000));
        userService.saveBatch(users);
    }

操作结果：

测试验证2-查询数据：

    @Test
    void listTest() {
    
    
        QueryWrapper<TUser> wrapper = new QueryWrapper<>();
        wrapper.ge("age", 15);
        List<TUser> users = userService.list(wrapper);
        System.out.println(">>>>>>>>>> 【Result】 <<<<<<<<<< ");
        users.forEach(System.out::println);
    }

操作结果：

二、复合分片策略

使用场景：

• SQL语言中有 >，>=，<=，<，=，IN 和 BETWEEN AND 等操作符，不同的是复合分片策略支持对多个分片键操作。

select * from t_user where age=10 and username='ACGkaka_1';

yaml配置：

spring:
  shardingsphere:
    sharding:
      # 表策略配置
      tables:
        # t_user 是逻辑表
        t_user:
          databaseStrategy:
            standard:
              # 分片键
              shardingColumn: age
              # 精准分库算法
              preciseAlgorithmClassName: com.demo.module.config.MyDBPreciseShardingAlgorithm
              # 范围分库算法
              rangeAlgorithmClassName: com.demo.module.config.MyDBRangeShardingAlgorithm

代码实现：

public class MyDBComplexKeysShardingAlgorithm implements ComplexKeysShardingAlgorithm<Integer> {
    
    

    /**
     * 复合分库
     *
     * @param databaseNames 全部库名集合（用于筛选）
     * @param complexKeysShardingValue 复合分片值
     * @return 需要用到的库名集合
     */
    @Override
    public Collection<String> doSharding(Collection<String> databaseNames, ComplexKeysShardingValue<Integer> complexKeysShardingValue) {
    
    

        // 精准分片-得到每个分片键对应的值
        Collection<Integer> ageValues = this.getPreciseShardingValue(complexKeysShardingValue, "age");
        Collection<Integer> salaryValues = this.getPreciseShardingValue(complexKeysShardingValue, "salary");

        // 精准分片-根据两个分片键进行分库
        List<String> ageSuffix = ageValues.stream().map(o -> o < 18 ? "1" : "2").collect(Collectors.toList());
        List<String> salarySuffix = salaryValues.stream().map(o -> o < 5000 ? "1" : "2").collect(Collectors.toList());
        List<String> shardingSuffix = getShardingSuffix(ageSuffix, salarySuffix);

        // 范围分片-得到每个分片键对应的值
        Range<Integer> ageRange = this.getRangeShardingValue(complexKeysShardingValue, "age");
        Range<Integer> salaryRange = this.getRangeShardingValue(complexKeysShardingValue, "salary");

        // 范围分片-根据两个分片键进行分库
        ageSuffix = getRangeSuffix(ageRange);
        salarySuffix = getRangeSuffix(salaryRange);
        shardingSuffix.addAll(getShardingSuffix(ageSuffix, salarySuffix));

        return shardingSuffix.stream().distinct().collect(Collectors.toList());
    }


    // --------------------------------------------------------------------------------------------------------------
    // 私有方法
    // --------------------------------------------------------------------------------------------------------------


    /**
     * 获取 分库的范围
     * @param range 分片值范围
     * @return 分库范围
     */
    private List<String> getRangeSuffix(Range<Integer> range) {
    
    
        boolean isValid = range != null && (range.hasLowerBound() || range.hasUpperBound());
        if (isValid) {
    
    
            List<String> rangeSuffix = new ArrayList<>();
            int lowerEndpoint = range.hasLowerBound() ? range.lowerEndpoint() < 18 ? 1 : 2 : 1;
            int upperEndpoint = range.hasUpperBound() ? range.upperEndpoint() < 18 ? 1 : 2 : 2;
            for (int i = lowerEndpoint; i <= upperEndpoint; i++) {
    
    
                rangeSuffix.add(String.valueOf(i));
            }
            return rangeSuffix;
        }
        return new ArrayList<>(0);
    }

    /**
     * 获取 库名集合
     * @param ageSuffix age分片值
     * @param salarySuffix salary分片值
     * @return 库名集合
     */
    private List<String> getShardingSuffix(List<String> ageSuffix, List<String> salarySuffix) {
    
    
        List<String> dbNames = new ArrayList<>();
        ageSuffix = ageSuffix == null ? new ArrayList<>(0) : ageSuffix;
        salarySuffix = salarySuffix == null ? new ArrayList<>(0) : salarySuffix;
        for (String age : ageSuffix) {
    
    
            for (String salary : salarySuffix) {
    
    
                dbNames.add(String.format("mydb-%s-%s", age, salary));
            }
        }
        return dbNames.stream().distinct().collect(Collectors.toList());
    }

    /**
     * 获取 分片键对应的值
     *
     * @param shardingValue 复合分片值
     * @param key 分片键
     * @return 值
     */
    private Collection<Integer> getPreciseShardingValue(ComplexKeysShardingValue<Integer> shardingValue, final String key) {
    
    
        // 判断非空
        if (StringUtils.isEmpty(key) || shardingValue == null) {
    
    
            return new ArrayList<>(0);
        }

        // 根据 分片键 取值
        Collection<Integer> valueSet = new ArrayList<>();
        Map<String, Collection<Integer>> columnNameAndShardingValueMap = shardingValue.getColumnNameAndShardingValuesMap();
        Map<String, String> columnNameMap = columnNameAndShardingValueMap.keySet().stream().filter(Objects::nonNull)
                .collect(Collectors.toMap(String::toUpperCase, o -> o, (k1, k2) -> k1));
        if (columnNameMap.containsKey(key.toUpperCase())) {
    
    
            String columnName = columnNameMap.get(key.toUpperCase());
            valueSet.addAll(columnNameAndShardingValueMap.get(columnName));
        }
        return valueSet;
    }

    /**
     * 获取 分片键对应的值
     *
     * @param shardingValue 复合分片值
     * @param key 分片键
     * @return 值
     */
    private Range<Integer> getRangeShardingValue(ComplexKeysShardingValue<Integer> shardingValue, final String key) {
    
    
        // 判断非空
        if (StringUtils.isEmpty(key) || shardingValue == null) {
    
    
            return null;
        }

        // 根据 分片键 取值
        Map<String, Range<Integer>> columnNameAndRangeValuesMap = shardingValue.getColumnNameAndRangeValuesMap();
        Map<String, String> columnNameMap = columnNameAndRangeValuesMap.keySet().stream().filter(Objects::nonNull)
                .collect(Collectors.toMap(String::toUpperCase, o -> o, (k1, k2) -> k1));
        if (columnNameMap.containsKey(key.toUpperCase())) {
    
    
            String columnName = columnNameMap.get(key.toUpperCase());
            return columnNameAndRangeValuesMap.get(columnName);
        } else {
    
    
            return null;
        }
    }
}

测试验证1-插入数据：

    @Test
    void saveTest() {
    
    
        List<TUser> users = new ArrayList<>(3);
        users.add(new TUser("ACGkaka_1", "123456", 10, 3000));
        users.add(new TUser("ACGkaka_2", "123456", 18, 4000));
        users.add(new TUser("ACGkaka_3", "123456", 15, 6000));
        users.add(new TUser("ACGkaka_4", "123456", 19, 7000));
        userService.saveBatch(users);
    }

操作结果：

测试验证2-查询数据：

    @Test
    void listTest() {
    
    
        QueryWrapper<TUser> wrapper = new QueryWrapper<>();
        wrapper.ge("age", 18);
        wrapper.ge("salary", 5000);
        List<TUser> users = userService.list(wrapper);
        System.out.println(">>>>>>>>>> 【Result】 <<<<<<<<<< ");
        users.forEach(System.out::println);
    }

操作结果：

三、行表达式分片策略

**行表达式分片策略（InlineShardingStrategy）：**在配置中使用 Groovy 表达式，提供对 SQL 语言中的 = 和 IN 的分片操作支持，它只支持单分片键。

使用场景：

• 适用于做简单的分片算法，无需自定义分片算法，省去了繁琐的代码开发，是四种分片策略中最为简单的。

  比如：ds-KaTeX parse error: Expected '}', got 'EOF' at end of input: … 表示对 age 做取模计算， 是个通配符，用来承接计算结果，最终计算出分库 ds-0 … ds-n

yaml配置：

spring:
  shardingsphere:
    sharding:
      # 表策略配置
      tables:
        # t_user 是逻辑表
        t_user:
          # 分表节点 可以理解为分表后的那些表 比如 t_user_1 ,t_user_2 ,t_user_3
          actualDataNodes: mydb.t_user_$->{
    
    1..3}
          tableStrategy:
            inline:
              # 根据哪列分表
              shardingColumn: age
              # 分表算法 例如：age为奇数 -> t_user_2； age为偶数 -> t_user_1
              algorithmExpression: t_user_$->{
    
    age % 2 + 1}

四、Hint分片策略

Hint分片策略（HintShardingStrategy）： 相比于其他分片策略稍有不同，这种分片策略无需配置分片键，分片键值也不再从 SQL 中解析，而是由外部指定分片信息，让 SQL 在指定的分库、分表中执行。

• ShardingSphere 通过 Hint API 实现指定操作，实际上就是把分片规则 tablerule、databaserule 由集中配置变成了个性化配置。

使用场景：

• 如果我们希望用户表 t_user 用 age 做分片键进行分库分表，但是 t_user 表中却没有 age 这个字段，这时可以通过 Hint API 在外部手动指定分片键或分片库。

yaml配置：

spring:
  shardingsphere:
    sharding:
      # 表策略配置
      tables:
        # t_user 是逻辑表
        t_user:
          # 分表节点 可以理解为分表后的那些表 比如 t_user_1 ,t_user_2
          actualDataNodes: mydb.t_user_$->{
    
    1..2}
          tableStrategy:
            hint:
              # 复合分库算法
              algorithmClassName: com.demo.module.config.MyTableHintShardingAlgorithm

代码实现：

public class MyTableHintShardingAlgorithm implements HintShardingAlgorithm<Integer> {
    
    

    @Override
    public Collection<String> doSharding(Collection<String> tableNames, HintShardingValue<Integer> hintShardingValue) {
    
    

        List<String> result = new ArrayList<>();
        for (Integer shardingValue : hintShardingValue.getValues()) {
    
    
            result.add(shardingValue < 18 ? "t_user_1" : "t_user_2");
        }
        return result;
    }
}

测试验证1-插入数据：

    @Test
    void hintSaveTest() {
    
    
        // 清除掉上一次的规则，否则会报错
        HintManager.clear();
        // HintManager API 工具类实例
        HintManager hintManager = HintManager.getInstance();
        // 直接指定对应具体的数据库
        hintManager.addDatabaseShardingValue("mydb",0);
        // 设置表的分片键值，自定义操作哪个分片中
        hintManager.addTableShardingValue("t_user" , 18);

        // 在读写分离数据库中，Hint 可以强制读主库
        hintManager.setMasterRouteOnly();

        List<TUser> users = new ArrayList<>(3);
        users.add(new TUser("ACGkaka_1", "123456", 10, 3000));
        users.add(new TUser("ACGkaka_2", "123456", 18, 4000));
        users.add(new TUser("ACGkaka_3", "123456", 15, 6000));
        users.add(new TUser("ACGkaka_4", "123456", 19, 7000));
        userService.saveBatch(users);
    }

操作结果：

测试验证2-查询数据：

    @Test
    void hintListTest() {
    
    
        // 清除掉上一次的规则，否则会报错
        HintManager.clear();
        // HintManager API 工具类实例
        HintManager hintManager = HintManager.getInstance();
        // 直接指定对应具体的数据库
        hintManager.addDatabaseShardingValue("mydb",0);
        // 设置表的分片键值，自定义操作哪个分片中
        hintManager.addTableShardingValue("t_user" , 18);

        // 在读写分离数据库中，Hint 可以强制读主库
        hintManager.setMasterRouteOnly();

        QueryWrapper<TUser> wrapper = new QueryWrapper<>();
        List<TUser> users = userService.list(wrapper);
        System.out.println(">>>>>>>>>> 【Result】 <<<<<<<<<< ");
        users.forEach(System.out::println);
    }

操作结果：

五、源码地址

地址： https://gitee.com/acgkaka/SpringBootExamples/tree/master/springboot-sharding-jdbc-4types

参考地址：

1.分库分表的 4 种分片策略，所有 SQL 都逃不掉的一步，https://blog.51cto.com/u_14787961/3200290