分库分表用这个就够了

一、前言

2018年写过一篇分库分表的文章《SpringBoot使用sharding-jdbc分库分表》，但是存在很多不完美的地方比如：

• sharding-jdbc的版本（1.4.2）过低，现在github上的最新版本都是5.3.2了，很多用法和API都过时了。
  
• 分库分表配置采用Java硬编码的方式不够灵活
  
• 持久层使用的是spring-boot-starter-data-jpa，而不是主流的mybatis+mybatis-plus+druid-spring-boot-stater
  
• 没有支持自定义主键生成策略
  

二、设计思路

针对上述问题，本人计划开发一个通用的分库分表starter，具备以下特性：

• 基于ShardingSphere-JDBC版本4.1.1，官方支持的特性我们都支持
  
• 支持yaml文件配置，无需编码开箱即用
  
• 支持多种数据源，整合主流的mybatis
  
• 支持自定义主键生成策略，并提供默认的雪花算法实现
  

通过查看官方文档，可以发现starter的核心逻辑就是获取分库分表等配置，然后在自动配置类创建数据源注入Spring容器即可。
三、编码实现

3.1 starter工程搭建

首先创建一个spring-boot-starter工程ship-sharding-spring-boot-starter，不会的小伙伴可以参考以前写的教程《【SpringBoot】编写一个自己的Starter》。
创建自动配置类cn.sp.sharding.config.ShardingAutoConfig，并在resources/META-INF/spring.factories文件中配置自动配置类的全路径。

1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=cn.sp.sharding.config.ShardingAutoConfig

复制代码

然后需要在pom.xml文件引入sharding-jbc依赖和工具包guava。

1.     <properties>
2.         <java.version>8</java.version>
3.         <spring-boot.version>2.4.0</spring-boot.version>
4.         <sharding-jdbc.version>4.1.1</sharding-jdbc.version>
5.     </properties>
6.    
7.       <dependency>
8.             <groupId>org.apache.shardingsphere</groupId>
9.             <artifactId>sharding-jdbc-core</artifactId>
10.             <version>${sharding-jdbc.version}</version>
11.         </dependency>
13.         <dependency>
14.             <groupId>com.google.guava</groupId>
15.             <artifactId>guava</artifactId>
16.             <version>18.0</version>
17.         </dependency>

复制代码

3.2 注入ShardingDataSource

分库分表配置这块，为了方便自定义配置前缀，创建ShardingRuleConfigurationProperties类继承sharding-jbc的YamlShardingRuleConfiguration类即可，代码如下：

1. /**
2. * @author Ship
3. * @version 1.0.0
4. * @description:
5. * @date 2023/06/06
6. */
7. @ConfigurationProperties(prefix = CommonConstants.COMMON_CONFIG_PREFIX + ".config")
8. public class ShardingRuleConfigurationProperties extends YamlShardingRuleConfiguration {
11. }

复制代码

同时sharding-jbc支持自定义一些properties属性，需要单独创建类ConfigMapConfigurationProperties

1. /**
2. * @Author: Ship
3. * @Description:
4. * @Date: Created in 2023/6/6
5. */
6. @ConfigurationProperties(prefix = CommonConstants.COMMON_CONFIG_PREFIX + ".map")
7. public class ConfigMapConfigurationProperties {
9.     private Properties props = new Properties();
12.     public Properties getProps() {
13.         return props;
14.     }
16.     public void setProps(Properties props) {
17.         this.props = props;
18.     }
19. }

复制代码

官方提供了ShardingDataSourceFactory工厂类来创建数据源，但是查看其源码发现createDataSource方法的参数是ShardingRuleConfiguration类，而不是YamlShardingRuleConfiguration。

1. @NoArgsConstructor(access = AccessLevel.PRIVATE)
2. public final class ShardingDataSourceFactory {
3.    
4.     /**
5.      * Create sharding data source.
6.      *
7.      * @param dataSourceMap data source map
8.      * @param shardingRuleConfig rule configuration for databases and tables sharding
9.      * @param props properties for data source
10.      * @return sharding data source
11.      * @throws SQLException SQL exception
12.      */
13.     public static DataSource createDataSource(
14.             final Map<String, DataSource> dataSourceMap, final ShardingRuleConfiguration shardingRuleConfig, final Properties props) throws SQLException {
15.         return new ShardingDataSource(dataSourceMap, new ShardingRule(shardingRuleConfig, dataSourceMap.keySet()), props);
16.     }
17. }

复制代码

该如何解决配置类参数转换的问题呢？
幸好查找官方文档发现sharding-jdbc提供了YamlSwapper类来实现yaml配置和核心配置的转换

1. /**
2. * YAML configuration swapper.
3. *
4. * @param <Y> type of YAML configuration
5. * @param <T> type of swapped object
6. */
7. public interface YamlSwapper<Y extends YamlConfiguration, T> {
8.    
9.     /**
10.      * Swap to YAML configuration.
11.      *
12.      * @param data data to be swapped
13.      * @return YAML configuration
14.      */
15.     Y swap(T data);
16.    
17.     /**
18.      * Swap from YAML configuration to object.
19.      *
20.      * @param yamlConfiguration YAML configuration
21.      * @return swapped object
22.      */
23.     T swap(Y yamlConfiguration);
24. }

复制代码

ShardingRuleConfigurationYamlSwapper就是YamlSwapper的其中一个实现类。
于是，ShardingAutoConfig的最终代码如下：

1. package cn.sp.sharding.config;
3. /**
4. * @author Ship
5. * @version 1.0.0
6. * @description:
7. * @date 2023/06/06
8. */
9. @AutoConfigureBefore(name = CommonConstants.MYBATIS_PLUS_CONFIG_CLASS)
10. @Configuration
11. @EnableConfigurationProperties(value = {ShardingRuleConfigurationProperties.class, ConfigMapConfigurationProperties.class})
12. @Import(DataSourceHealthConfig.class)
13. public class ShardingAutoConfig implements EnvironmentAware {
16.     private Map<String, DataSource> dataSourceMap = new HashMap<>();
18.     @ConditionalOnMissingBean
19.     @Bean
20.     public DataSource shardingDataSource(@Autowired ShardingRuleConfigurationProperties configurationProperties,
21.                                          @Autowired ConfigMapConfigurationProperties configMapConfigurationProperties) throws SQLException {
22.         ShardingRuleConfigurationYamlSwapper yamlSwapper = new ShardingRuleConfigurationYamlSwapper();
23.         ShardingRuleConfiguration shardingRuleConfiguration = yamlSwapper.swap(configurationProperties);
24.         return ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfiguration, configMapConfigurationProperties.getProps());
25.     }
27.     @Override
28.     public void setEnvironment(Environment environment) {
29.         setDataSourceMap(environment);
30.     }
32.     private void setDataSourceMap(Environment environment) {
33.         String names = environment.getProperty(CommonConstants.DATA_SOURCE_CONFIG_PREFIX + ".names");
34.         for (String name : names.split(",")) {
35.             try {
36.                 String propertiesPrefix = CommonConstants.DATA_SOURCE_CONFIG_PREFIX + "." + name;
37.                 Map<String, Object> dataSourceProps = PropertyUtil.handle(environment, propertiesPrefix, Map.class);
38.                 // 反射创建数据源
39.                 DataSource dataSource = DataSourceUtil.getDataSource(dataSourceProps.get("type").toString(), dataSourceProps);
40.                 dataSourceMap.put(name, dataSource);
41.             } catch (ReflectiveOperationException e) {
42.                 e.printStackTrace();
43.             } catch (Exception e) {
44.                 e.printStackTrace();
45.             }
46.         }
47.     }
48. }

复制代码

利用反射创建数据源，就可以解决支持多种数据源的问题。
3.3 自定义主键生成策略

sharding-jdbc提供了UUID和Snowflake两种默认实现，但是自定义主键生成策略更加灵活，方便根据自己的需求调整，接下来介绍如何自定义主键生成策略。
因为我们也是用的雪花算法，所以可以直接用sharding-jdbc提供的雪花算法类，KeyGeneratorFactory负责生成雪花算法实现类的实例，采用双重校验加锁的单例模式。

1. public final class KeyGeneratorFactory {
2.     /**
3.      * 使用shardingsphere提供的雪花算法实现
4.      */
5.     private static volatile SnowflakeShardingKeyGenerator keyGenerator = null;
7.     private KeyGeneratorFactory() {
9.     }
11.     /**
12.      * 单例模式
13.      *
14.      * @return
15.      */
16.     public static SnowflakeShardingKeyGenerator getInstance() {
17.         if (keyGenerator == null) {
18.             synchronized (KeyGeneratorFactory.class) {
19.                 if (keyGenerator == null) {
20.                     // 用ip地址当作机器id，机器范围0-1024
21.                     Long workerId = Long.valueOf(IpUtil.getLocalIpAddress().replace(".", "")) % 1024;
22.                     keyGenerator = new SnowflakeShardingKeyGenerator();
23.                     Properties properties = new Properties();
24.                     properties.setProperty("worker.id", workerId.toString());
25.                     keyGenerator.setProperties(properties);
26.                 }
27.             }
28.         }
29.         return keyGenerator;
30.     }
31. }

复制代码

雪花算法是由1bit 不用 + 41bit时间戳+10bit工作机器id+12bit序列号组成的，所以为了防止不同节点生成的id重复需要设置机器id，机器id的范围是0-1024，这里是用IP地址转数字取模1024来计算机器id，存在很小概率的重复，也可以用redis来生成机器id（参考雪花算法ID重复问题的解决方案 ）。
注意： 雪花算法坑其实挺多的，除了系统时间回溯会导致id重复，单节点并发过高也会导致重复（序列位只有12位代表1ms内最多支持4096个并发）。
查看源码可知自定义主键生成器是通过SPI实现的，实现ShardingKeyGenerator接口即可。

1. package org.apache.shardingsphere.spi.keygen;
3. import org.apache.shardingsphere.spi.TypeBasedSPI;
5. /**
6. * Key generator.
7. */
8. public interface ShardingKeyGenerator extends TypeBasedSPI {
9.    
10.     /**
11.      * Generate key.
12.      *
13.      * @return generated key
14.      */
15.     Comparable<?> generateKey();
16. }

复制代码

• 自定义主键生成器DistributedKeyGenerator
  

1. /**
2. * @Author: Ship
3. * @Description: 分布式id生成器，雪花算法实现
4. * @Date: Created in 2023/6/8
5. */
6. public class DistributedKeyGenerator implements ShardingKeyGenerator {
8.     @Override
9.     public Comparable<?> generateKey() {
10.         return KeyGeneratorFactory.getInstance().generateKey();
11.     }
13.     @Override
14.     public String getType() {
15.         return "DISTRIBUTED";
16.     }
18.     @Override
19.     public Properties getProperties() {
20.         return null;
21.     }
23.     @Override
24.     public void setProperties(Properties properties) {
26.     }
27. }

复制代码

• 创建META-INF/services文件夹，然后在文件夹下创建org.apache.shardingsphere.spi.keygen.ShardingKeyGenerator文件，内容如下：
  

1. cn.sp.sharding.key.DistributedKeyGenerator

复制代码

• yaml文件配置即可
  

3.4 遗留问题

Spring Boot会在项目启动时执行一条sql语句检查数据源是否可用，因为ShardingDataSource只是对真实数据源进行了封装，没有完全实现Datasouce接口规范，所以会在启动时报错DataSource health check failed，为此需要重写数据源健康检查的逻辑。
创建DataSourceHealthConfig类继承DataSourceHealthContributorAutoConfiguration，然后重写createIndicator方法来重新设置校验sql语句。

1. /**
2. * @Author: Ship
3. * @Description:
4. * @Date: Created in 2023/6/7
5. */
6. public class DataSourceHealthConfig extends DataSourceHealthContributorAutoConfiguration {
8.     private static String validQuery = "SELECT 1";
10.     public DataSourceHealthConfig(Map<String, DataSource> dataSources, ObjectProvider<DataSourcePoolMetadataProvider> metadataProviders) {
11.         super(dataSources, metadataProviders);
12.     }
14.     @Override
15.     protected AbstractHealthIndicator createIndicator(DataSource source) {
16.         DataSourceHealthIndicator healthIndicator = (DataSourceHealthIndicator) super.createIndicator(source);
17.         if (StringUtils.hasText(validQuery)) {
18.             healthIndicator.setQuery(validQuery);
19.         }
20.         return healthIndicator;
21.     }
22. }

复制代码

最后使用@Import注解来注入

1. @AutoConfigureBefore(name = CommonConstants.MYBATIS_PLUS_CONFIG_CLASS)
2. @Configuration
3. @EnableConfigurationProperties(value = {ShardingRuleConfigurationProperties.class, ConfigMapConfigurationProperties.class})
4. @Import(DataSourceHealthConfig.class)
5. public class ShardingAutoConfig implements EnvironmentAware {

复制代码

四、测试

假设有个订单表数据量很大了需要分表，为了方便水平扩展，根据订单的创建时间分表，分表规则如下：

1. t_order_${创建时间所在年}_${创建时间所在季度}

复制代码

订单表结构如下

1. CREATE TABLE `t_order_2022_3` (
2.   `id` bigint(20) unsigned NOT NULL COMMENT '主键',
3.   `order_code` varchar(32) DEFAULT NULL COMMENT '订单号',
4.   `create_time` bigint(20) NOT NULL COMMENT '创建时间',
5.   PRIMARY KEY (`id`)
6. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

复制代码

• 创建数据库my_springboot,并创建8张订单表t_order_2022_1至t_order_2023_4
  

• 创建SpringBoot项目ship-sharding-example，并添加mybatis等相关依赖
  

1.   <dependency>
2.             <groupId>org.mybatis.spring.boot</groupId>
3.             <artifactId>mybatis-spring-boot-starter</artifactId>
4.             <version>${mybatis.version}</version>
5.         </dependency>
8.         <dependency>
9.             <groupId>com.baomidou</groupId>
10.             <artifactId>mybatis-plus-boot-starter</artifactId>
11.             <version>3.0.1</version>
12.             <exclusions>
13.                 <exclusion>
14.                     <groupId>org.mybatis</groupId>
15.                     <artifactId>mybatis</artifactId>
16.                 </exclusion>
17.             </exclusions>
18.         </dependency>
19.         
20.         <dependency>
21.             <groupId>com.alibaba</groupId>
22.             <artifactId>druid-spring-boot-starter</artifactId>
23.             <version>${druid.version}</version>
24.         </dependency>
26.         <dependency>
27.             <groupId>cn.sp</groupId>
28.             <artifactId>ship-sharding-spring-boot-starter</artifactId>
29.             <version>1.0-SNAPSHOT</version>
30.         </dependency>
32.         <dependency>
33.             <groupId>mysql</groupId>
34.             <artifactId>mysql-connector-java</artifactId>
35.         </dependency>

复制代码

• 创建订单实体Order和OrderMapper,代码比较简单省略
  
• 自定义分表算法需要实现PreciseShardingAlgorithm和RangeShardingAlgorithm接口的方法，它俩区别如下
  

接口描述PreciseShardingAlgorithm定义等值查询条件下的分表算法RangeShardingAlgorithm定义范围查询条件下的分表算法创建算法类MyTableShardingAlgorithm

1. /**
2. * @Author: Ship
3. * @Description:
4. * @Date: Created in 2023/6/8
5. */
6. @Slf4j
7. public class MyTableShardingAlgorithm implements PreciseShardingAlgorithm<Long>, RangeShardingAlgorithm<Long> {
9.     private static final String TABLE_NAME_PREFIX = "t_order_";
11.     @Override
12.     public String doSharding(Collection<String> availableTableNames, PreciseShardingValue<Long> preciseShardingValue) {
13.         Long createTime = preciseShardingValue.getValue();
14.         if (createTime == null) {
15.             throw new ShipShardingException("创建时间不能为空！");
16.         }
17.         LocalDate localDate = DateUtils.longToLocalDate(createTime);
18.         final String year = localDate.getYear() + "";
19.         Integer quarter = DateUtils.getQuarter(localDate);
20.         for (String tableName : availableTableNames) {
21.             String dateStr = tableName.replace(TABLE_NAME_PREFIX, "");
22.             String[] dateArr = dateStr.split("_");
23.             if (dateArr[0].equals(year) && dateArr[1].equals(quarter.toString())) {
24.                 return tableName;
25.             }
26.         }
27.         log.error("分表算法对应的表不存在！");
28.         throw new ShipShardingException("分表算法对应的表不存在！");
29.     }
31.     @Override
32.     public Collection<String> doSharding(Collection<String> availableTableNames, RangeShardingValue<Long> rangeShardingValue) {
33.         //获取查询条件中范围值
34.         Range<Long> valueRange = rangeShardingValue.getValueRange();
35.         // 上限值
36.         Long upperEndpoint = valueRange.upperEndpoint();
37.         // 下限值
38.         Long lowerEndpoint = valueRange.lowerEndpoint();
40.         List<String> tableNames = Lists.newArrayList();
41.         for (String tableName : availableTableNames) {
42.             String dateStr = tableName.replace(MyTableShardingAlgorithm.TABLE_NAME_PREFIX, "");
43.             String[] dateArr = dateStr.split("_");
44.             String year = dateArr[0];
45.             String quarter = dateArr[1];
46.             Long[] minAndMaxTime = DateUtils.getMinAndMaxTime(year, quarter);
47.             Long minTime = minAndMaxTime[0];
48.             Long maxTime = minAndMaxTime[1];
49.             if (valueRange.hasLowerBound() && valueRange.hasUpperBound()) {
50.                 // between and
51.                 if (minTime.compareTo(lowerEndpoint) <= 0 && upperEndpoint.compareTo(maxTime) <= 0) {
52.                     tableNames.add(tableName);
53.                 }
54.             } else if (valueRange.hasLowerBound() && !valueRange.hasUpperBound()) {
55.                 if (maxTime.compareTo(lowerEndpoint) > 0) {
56.                     tableNames.add(tableName);
57.                 }
58.             } else {
59.                 if (upperEndpoint.compareTo(minTime) > 0) {
60.                     tableNames.add(tableName);
61.                 }
62.             }
63.         }
64.         if (tableNames.size() == 0) {
65.             log.error("分表算法对应的表不存在！");
66.             throw new ShipShardingException("分表算法对应的表不存在！");
67.         }
68.         return tableNames;
69.     }
70. }

复制代码

• 在application.yaml上添加数据库配置和分表配置
  

1. spring:
2.   application:
3.     name: ship-sharding-example
6. mybatis-plus:
7.   base-package: cn.sp.sharding.dao
8.   mapper-locations: classpath*:/mapper/*Mapper.xml
9.   configuration:
10.     #开启自动驼峰命名规则（camel case）映射
11.     map-underscore-to-camel-case: true
12.     #延迟加载，需要和lazy-loading-enabled一起使用
13.     aggressive-lazy-loading: true
14.     lazy-loading-enabled: true
15.     #关闭一级缓存
16.     local-cache-scope: statement
17.     #关闭二级级缓存
18.     cache-enabled: false
20. ship:
21.   sharding:
22.     jdbc:
23.       datasource:
24.         names: ds0
25.         ds0:
26.           driver-class-name: com.mysql.cj.jdbc.Driver
27.           type: com.alibaba.druid.pool.DruidDataSource
28.           url: jdbc:mysql://127.0.0.1:3306/my_springboot?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false
29.           username: root
30.           password: 1234
31.           initial-size: 5
32.           minIdle: 5
33.           maxActive: 20
34.           maxWait: 60000
35.           timeBetweenEvictionRunsMillis: 60000
36.           minEvictableIdleTimeMillis: 300000
37.           validationQuery: SELECT 1 FROM DUAL
38.           testWhileIdle: true
39.           testOnBorrow: false
40.           testOnReturn: false
41.           poolPreparedStatements: true
42.           maxPoolPreparedStatementPerConnectionSize: 20
43.           useGlobalDataSourceStat: true
44.           connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=2000;druid.mysql.usePingMethod=false
45.       config:
46.         binding-tables: t_order
47.         tables:
48.           t_order:
49.             actual-data-nodes: ds0.t_order_${2022..2023}_${1..4}
50.             # 配置主键生成策略
51.             key-generator:
52.               type: DISTRIBUTED
53.               column: id
54.             table-strategy:
55.               standard:
56.                 sharding-column: create_time
57.                 # 配置分表算法
58.                 precise-algorithm-class-name: cn.sp.sharding.algorithm.MyTableShardingAlgorithm
59.                 range-algorithm-class-name: cn.sp.sharding.algorithm.MyTableShardingAlgorithm

复制代码

• 现在可以进行测试了，首先写一个单元测试测试数据插入情况。
  

1. @Test
2.     public void testInsert() {
3.         Order order = new Order();
4.         order.setOrderCode("OC001");
5.         order.setCreateTime(System.currentTimeMillis());
6.         orderMapper.insert(order);
7.     }

复制代码

运行testInsert()方法，打开t_order_2023_2表发现已经有了一条订单数据

并且该数据的create_time是1686383781371，转换为时间为2023-06-10 15:56:21，刚好对应2023年第二季度，说明数据正确的路由到了对应的表里。
然后测试下数据查询情况

1. @Test
2.     public void testQuery(){
3.         QueryWrapper<Order> wrapper = new QueryWrapper<>();
4.         wrapper.lambda().eq(Order::getOrderCode,"OC001");
5.         List<Order> orders = orderMapper.selectList(wrapper);
6.         System.out.println(JSONUtil.toJsonStr(orders));
7.     }

复制代码

运行testQuery()方法后可以在控制台看到输出了订单报文，说明查询也没问题。

1. [{"id":1667440550397132802,"orderCode":"OC001","createTime":1686383781371}]

复制代码

五、总结


本文代码已经上传到github，后续会把ship-sharding-spring-boot-starter上传到maven中央仓库方便使用，如果觉得对你有用的话希望可以点个赞让更多人看到
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！