一、前言

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檔案中設定自動設定類的全路徑。

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

然後需要在pom.xml檔案引入sharding-jbc依賴和工具包guava。

    <properties>
        <java.version>8</java.version>
        <spring-boot.version>2.4.0</spring-boot.version>
        <sharding-jdbc.version>4.1.1</sharding-jdbc.version>
    </properties>
    
      <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-core</artifactId>
            <version>${sharding-jdbc.version}</version>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>18.0</version>
        </dependency>

3.2 注入ShardingDataSource

分庫分表設定這塊，為了方便自定義設定字首，建立ShardingRuleConfigurationProperties類繼承sharding-jbc的YamlShardingRuleConfiguration類即可，程式碼如下：

/**
 * @author Ship
 * @version 1.0.0
 * @description:
 * @date 2023/06/06
 */
@ConfigurationProperties(prefix = CommonConstants.COMMON_CONFIG_PREFIX + ".config")
public class ShardingRuleConfigurationProperties extends YamlShardingRuleConfiguration {


}

同時sharding-jbc支援自定義一些properties屬性，需要單獨建立類ConfigMapConfigurationProperties

/**
 * @Author: Ship
 * @Description:
 * @Date: Created in 2023/6/6
 */
@ConfigurationProperties(prefix = CommonConstants.COMMON_CONFIG_PREFIX + ".map")
public class ConfigMapConfigurationProperties {

    private Properties props = new Properties();


    public Properties getProps() {
        return props;
    }

    public void setProps(Properties props) {
        this.props = props;
    }
}

官方提供了ShardingDataSourceFactory工廠類來建立資料來源，但是檢視其原始碼發現createDataSource方法的引數是ShardingRuleConfiguration類，而不是YamlShardingRuleConfiguration。

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class ShardingDataSourceFactory {
    
    /**
     * Create sharding data source.
     *
     * @param dataSourceMap data source map
     * @param shardingRuleConfig rule configuration for databases and tables sharding
     * @param props properties for data source
     * @return sharding data source
     * @throws SQLException SQL exception
     */
    public static DataSource createDataSource(
            final Map<String, DataSource> dataSourceMap, final ShardingRuleConfiguration shardingRuleConfig, final Properties props) throws SQLException {
        return new ShardingDataSource(dataSourceMap, new ShardingRule(shardingRuleConfig, dataSourceMap.keySet()), props);
    }
}

該如何解決設定類引數轉換的問題呢？

幸好查詢官方檔案發現sharding-jdbc提供了YamlSwapper類來實現yaml設定和核心設定的轉換

/**
 * YAML configuration swapper.
 *
 * @param <Y> type of YAML configuration
 * @param <T> type of swapped object
 */
public interface YamlSwapper<Y extends YamlConfiguration, T> {
    
    /**
     * Swap to YAML configuration.
     *
     * @param data data to be swapped
     * @return YAML configuration
     */
    Y swap(T data);
    
    /**
     * Swap from YAML configuration to object.
     *
     * @param yamlConfiguration YAML configuration
     * @return swapped object
     */
    T swap(Y yamlConfiguration);
}

ShardingRuleConfigurationYamlSwapper就是YamlSwapper的其中一個實現類。

於是，ShardingAutoConfig的最終程式碼如下：

package cn.sp.sharding.config;

/**
 * @author Ship
 * @version 1.0.0
 * @description:
 * @date 2023/06/06
 */
@AutoConfigureBefore(name = CommonConstants.MYBATIS_PLUS_CONFIG_CLASS)
@Configuration
@EnableConfigurationProperties(value = {ShardingRuleConfigurationProperties.class, ConfigMapConfigurationProperties.class})
@Import(DataSourceHealthConfig.class)
public class ShardingAutoConfig implements EnvironmentAware {


    private Map<String, DataSource> dataSourceMap = new HashMap<>();

    @ConditionalOnMissingBean
    @Bean
    public DataSource shardingDataSource(@Autowired ShardingRuleConfigurationProperties configurationProperties,
                                         @Autowired ConfigMapConfigurationProperties configMapConfigurationProperties) throws SQLException {
        ShardingRuleConfigurationYamlSwapper yamlSwapper = new ShardingRuleConfigurationYamlSwapper();
        ShardingRuleConfiguration shardingRuleConfiguration = yamlSwapper.swap(configurationProperties);
        return ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfiguration, configMapConfigurationProperties.getProps());
    }

    @Override
    public void setEnvironment(Environment environment) {
        setDataSourceMap(environment);
    }

    private void setDataSourceMap(Environment environment) {
        String names = environment.getProperty(CommonConstants.DATA_SOURCE_CONFIG_PREFIX + ".names");
        for (String name : names.split(",")) {
            try {
                String propertiesPrefix = CommonConstants.DATA_SOURCE_CONFIG_PREFIX + "." + name;
                Map<String, Object> dataSourceProps = PropertyUtil.handle(environment, propertiesPrefix, Map.class);
                // 反射建立資料來源
                DataSource dataSource = DataSourceUtil.getDataSource(dataSourceProps.get("type").toString(), dataSourceProps);
                dataSourceMap.put(name, dataSource);
            } catch (ReflectiveOperationException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

利用反射建立資料來源，就可以解決支援多種資料來源的問題。

3.3 自定義主鍵生成策略

sharding-jdbc提供了UUID和Snowflake兩種預設實現，但是自定義主鍵生成策略更加靈活，方便根據自己的需求調整，接下來介紹如何自定義主鍵生成策略。

因為我們也是用的雪花演演算法，所以可以直接用sharding-jdbc提供的雪花演演算法類，KeyGeneratorFactory負責生成雪花演演算法實現類的範例，採用雙重校驗加鎖的單例模式。

public final class KeyGeneratorFactory {
    /**
     * 使用shardingsphere提供的雪花演演算法實現
     */
    private static volatile SnowflakeShardingKeyGenerator keyGenerator = null;

    private KeyGeneratorFactory() {

    }

    /**
     * 單例模式
     *
     * @return
     */
    public static SnowflakeShardingKeyGenerator getInstance() {
        if (keyGenerator == null) {
            synchronized (KeyGeneratorFactory.class) {
                if (keyGenerator == null) {
                    // 用ip地址當作機器id，機器範圍0-1024
                    Long workerId = Long.valueOf(IpUtil.getLocalIpAddress().replace(".", "")) % 1024;
                    keyGenerator = new SnowflakeShardingKeyGenerator();
                    Properties properties = new Properties();
                    properties.setProperty("worker.id", workerId.toString());
                    keyGenerator.setProperties(properties);
                }
            }
        }
        return keyGenerator;
    }
}

雪花演演算法是由1bit 不用 + 41bit時間戳+10bit工作機器id+12bit序列號組成的，所以為了防止不同節點生成的id重複需要設定機器id，機器id的範圍是0-1024，這裡是用IP地址轉數位取模1024來計算機器id，存在很小概率的重複，也可以用redis來生成機器id（參考雪花演演算法ID重複問題的解決方案）。

注意： 雪花演演算法坑其實挺多的，除了系統時間回溯會導致id重複，單節點並行過高也會導致重複（序列位只有12位元代表1ms內最多支援4096個並行）。

檢視原始碼可知自定義主鍵生成器是通過SPI實現的，實現ShardingKeyGenerator介面即可。

package org.apache.shardingsphere.spi.keygen;

import org.apache.shardingsphere.spi.TypeBasedSPI;

/**
 * Key generator.
 */
public interface ShardingKeyGenerator extends TypeBasedSPI {
    
    /**
     * Generate key.
     * 
     * @return generated key
     */
    Comparable<?> generateKey();
}

自定義主鍵生成器DistributedKeyGenerator

/**
 * @Author: Ship
 * @Description: 分散式id生成器，雪花演演算法實現
 * @Date: Created in 2023/6/8
 */
public class DistributedKeyGenerator implements ShardingKeyGenerator {

    @Override
    public Comparable<?> generateKey() {
        return KeyGeneratorFactory.getInstance().generateKey();
    }

    @Override
    public String getType() {
        return "DISTRIBUTED";
    }

    @Override
    public Properties getProperties() {
        return null;
    }

    @Override
    public void setProperties(Properties properties) {

    }
}

建立META-INF/services資料夾，然後在資料夾下建立org.apache.shardingsphere.spi.keygen.ShardingKeyGenerator檔案，內容如下：

 cn.sp.sharding.key.DistributedKeyGenerator

yaml檔案設定即可

3.4 遺留問題

Spring Boot會在專案啟動時執行一條sql語句檢查資料來源是否可用，因為ShardingDataSource只是對真實資料來源進行了封裝，沒有完全實現Datasouce介面規範，所以會在啟動時報錯DataSource health check failed，為此需要重寫資料來源健康檢查的邏輯。

建立DataSourceHealthConfig類繼承DataSourceHealthContributorAutoConfiguration，然後重寫createIndicator方法來重新設定校驗sql語句。

/**
 * @Author: Ship
 * @Description:
 * @Date: Created in 2023/6/7
 */
public class DataSourceHealthConfig extends DataSourceHealthContributorAutoConfiguration {

    private static String validQuery = "SELECT 1";

    public DataSourceHealthConfig(Map<String, DataSource> dataSources, ObjectProvider<DataSourcePoolMetadataProvider> metadataProviders) {
        super(dataSources, metadataProviders);
    }

    @Override
    protected AbstractHealthIndicator createIndicator(DataSource source) {
        DataSourceHealthIndicator healthIndicator = (DataSourceHealthIndicator) super.createIndicator(source);
        if (StringUtils.hasText(validQuery)) {
            healthIndicator.setQuery(validQuery);
        }
        return healthIndicator;
    }
}

最後使用@Import註解來注入

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

四、測試

假設有個訂單表資料量很大了需要分表，為了方便水平擴充套件，根據訂單的建立時間分表，分表規則如下：

t_order_${建立時間所在年}_${建立時間所在季度}

訂單表結構如下

CREATE TABLE `t_order_2022_3` (
  `id` bigint(20) unsigned NOT NULL COMMENT '主鍵',
  `order_code` varchar(32) DEFAULT NULL COMMENT '訂單號',
  `create_time` bigint(20) NOT NULL COMMENT '建立時間',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

建立資料庫my_springboot,並建立8張訂單表t_order_2022_1至t_order_2023_4

建立SpringBoot專案ship-sharding-example，並新增mybatis等相關依賴

  <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.version}</version>
        </dependency>


        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.1</version>
            <exclusions>
                <exclusion>
                    <groupId>org.mybatis</groupId>
                    <artifactId>mybatis</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <dependency>
            <groupId>cn.sp</groupId>
            <artifactId>ship-sharding-spring-boot-starter</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

建立訂單實體Order和OrderMapper,程式碼比較簡單省略
自定義分表演演算法需要實現PreciseShardingAlgorithm和RangeShardingAlgorithm介面的方法，它倆區別如下

介面	描述
PreciseShardingAlgorithm	定義等值查詢條件下的分表演演算法
RangeShardingAlgorithm	定義範圍查詢條件下的分表演演算法

建立演演算法類MyTableShardingAlgorithm

/**
 * @Author: Ship
 * @Description:
 * @Date: Created in 2023/6/8
 */
@Slf4j
public class MyTableShardingAlgorithm implements PreciseShardingAlgorithm<Long>, RangeShardingAlgorithm<Long> {

    private static final String TABLE_NAME_PREFIX = "t_order_";

    @Override
    public String doSharding(Collection<String> availableTableNames, PreciseShardingValue<Long> preciseShardingValue) {
        Long createTime = preciseShardingValue.getValue();
        if (createTime == null) {
            throw new ShipShardingException("建立時間不能為空！");
        }
        LocalDate localDate = DateUtils.longToLocalDate(createTime);
        final String year = localDate.getYear() + "";
        Integer quarter = DateUtils.getQuarter(localDate);
        for (String tableName : availableTableNames) {
            String dateStr = tableName.replace(TABLE_NAME_PREFIX, "");
            String[] dateArr = dateStr.split("_");
            if (dateArr[0].equals(year) && dateArr[1].equals(quarter.toString())) {
                return tableName;
            }
        }
        log.error("分表演演算法對應的表不存在！");
        throw new ShipShardingException("分表演演算法對應的表不存在！");
    }

    @Override
    public Collection<String> doSharding(Collection<String> availableTableNames, RangeShardingValue<Long> rangeShardingValue) {
        //獲取查詢條件中範圍值
        Range<Long> valueRange = rangeShardingValue.getValueRange();
        // 上限值
        Long upperEndpoint = valueRange.upperEndpoint();
        // 下限值
        Long lowerEndpoint = valueRange.lowerEndpoint();

        List<String> tableNames = Lists.newArrayList();
        for (String tableName : availableTableNames) {
            String dateStr = tableName.replace(MyTableShardingAlgorithm.TABLE_NAME_PREFIX, "");
            String[] dateArr = dateStr.split("_");
            String year = dateArr[0];
            String quarter = dateArr[1];
            Long[] minAndMaxTime = DateUtils.getMinAndMaxTime(year, quarter);
            Long minTime = minAndMaxTime[0];
            Long maxTime = minAndMaxTime[1];
            if (valueRange.hasLowerBound() && valueRange.hasUpperBound()) {
                // between and
                if (minTime.compareTo(lowerEndpoint) <= 0 && upperEndpoint.compareTo(maxTime) <= 0) {
                    tableNames.add(tableName);
                }
            } else if (valueRange.hasLowerBound() && !valueRange.hasUpperBound()) {
                if (maxTime.compareTo(lowerEndpoint) > 0) {
                    tableNames.add(tableName);
                }
            } else {
                if (upperEndpoint.compareTo(minTime) > 0) {
                    tableNames.add(tableName);
                }
            }
        }
        if (tableNames.size() == 0) {
            log.error("分表演演算法對應的表不存在！");
            throw new ShipShardingException("分表演演算法對應的表不存在！");
        }
        return tableNames;
    }
}

在application.yaml上新增資料庫設定和分表設定

spring:
  application:
    name: ship-sharding-example


mybatis-plus:
  base-package: cn.sp.sharding.dao
  mapper-locations: classpath*:/mapper/*Mapper.xml
  configuration:
    #開啟自動駝峰命名規則（camel case）對映
    map-underscore-to-camel-case: true
    #延遲載入，需要和lazy-loading-enabled一起使用
    aggressive-lazy-loading: true
    lazy-loading-enabled: true
    #關閉一級快取
    local-cache-scope: statement
    #關閉二級級快取
    cache-enabled: false

ship:
  sharding:
    jdbc:
      datasource:
        names: ds0
        ds0:
          driver-class-name: com.mysql.cj.jdbc.Driver
          type: com.alibaba.druid.pool.DruidDataSource
          url: jdbc:mysql://127.0.0.1:3306/my_springboot?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false
          username: root
          password: 1234
          initial-size: 5
          minIdle: 5
          maxActive: 20
          maxWait: 60000
          timeBetweenEvictionRunsMillis: 60000
          minEvictableIdleTimeMillis: 300000
          validationQuery: SELECT 1 FROM DUAL
          testWhileIdle: true
          testOnBorrow: false
          testOnReturn: false
          poolPreparedStatements: true
          maxPoolPreparedStatementPerConnectionSize: 20
          useGlobalDataSourceStat: true
          connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=2000;druid.mysql.usePingMethod=false
      config:
        binding-tables: t_order
        tables:
          t_order:
            actual-data-nodes: ds0.t_order_${2022..2023}_${1..4}
            # 設定主鍵生成策略
            key-generator:
              type: DISTRIBUTED
              column: id
            table-strategy:
              standard:
                sharding-column: create_time
                # 設定分表演演算法
                precise-algorithm-class-name: cn.sp.sharding.algorithm.MyTableShardingAlgorithm
                range-algorithm-class-name: cn.sp.sharding.algorithm.MyTableShardingAlgorithm

現在可以進行測試了，首先寫一個單元測試測試資料插入情況。

 @Test
    public void testInsert() {
        Order order = new Order();
        order.setOrderCode("OC001");
        order.setCreateTime(System.currentTimeMillis());
        orderMapper.insert(order);
    }

執行testInsert()方法，開啟t_order_2023_2表發現已經有了一條訂單資料

並且該資料的create_time是1686383781371，轉換為時間為2023-06-10 15:56:21，剛好對應2023年第二季度，說明資料正確的路由到了對應的表裡。

然後測試下資料查詢情況

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

執行testQuery()方法後可以在控制檯看到輸出了訂單報文，說明查詢也沒問題。

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

五、總結

本文程式碼已經上傳到github，後續會把ship-sharding-spring-boot-starter上傳到maven中央倉庫方便使用，如果覺得對你有用的話希望可以點個贊讓更多人看到

分庫分表用這個就夠了