ShardingSphere笔记（三）：自定义分片算法 — 按月分表·真·自动建表

ShardingSphere笔记（二）：自定义分片算法 — 按月分表·真·自动建表

一、 前言

上一篇文章中，已经介绍了shardingshpere 怎么进行按月分表。但是我们知道，一般来说按月分表肯定是本月到了之后才会进行建表，因为我们不可能预想到系统到底可以运行多久。而且在第一篇文章里面也已经提到了，Shardingshpere 默认是要求配置的实际表都是存在的。

难不成我们要每年建一次当年的按月分表的数据库表，每年改一次软件的配置文件然后重启软件吗？且不说如果维护项目的大兄弟离职，锅会留给下一个接手项目的人。这种每年修改一次，提心吊胆的记着改数据库，改软件的苦差事，一点都不优雅。

那么有没有好一点的方法能够让它自动建表呢？欸，这就得说说我在研究的过程中，碰巧碰到了一种骚操作，可以在运行过程中建表，并且能让sharesphere 框架知道新增了表，自动更新表缓存。

因此这篇文章最后能实现下面的这几个效果：

1. 使用Shardingsphere 实现按月分表的查询功能。
2. 根据查询的语句判断该月的表是否存在，不存在自动建表，并自动刷新到shardingsphere缓存表中。
3. 实现多数据库切换功能。并且提供原生的数据库操作数据源，因为从第一篇文章我们已经知道，shardingsphere数据源不支持数据库函数，不支持原生ddl操作，提供原生数据源可以保证我们在原生数据源中执行一些Shardingsphere不支持的操作。

不过、因为是骚操作，可能的缺点有两个：

1. 该骚操作可能会受ShardingSphere版本影响，万一哪天ShardingSphere程序员爸爸修改了表缓存逻辑，这一块儿逻辑就有可能失效了（目前版本 5.2.1）
2. 数据库里面必须存在一个逻辑表，因为自动建表语句是利用的mysql的 CREATE TABLE LIKE 创建的，你得保证有这么个表我才能建表罢，所以哪怕这个表实际上用不到，数据库中也要存在一个这样的表。

二、 Springboot 的动态数据库

因为要实现多数据源的动态切库，这里需要先介绍Springboot 是怎么做动态数据库切库的。
如果已经有大佬对springboot 的动态数据门儿清的话，可以跳过这一节。

众所周知，好吧，至少刚入职的时候我不知道，Springboot 通过 AbstractRoutingDatasource 切换不同的数据源。默认的springboot是单数据库的数据源。如果我们要实现多数据源的动态切换就需要实现 AbstractRoutingDatasource。 并将该DataSource 作为一个Bean注册到Spring中。

那么 AbstractRoutingDatasource 是怎么做到多数据源的呢？众所~~，好吧不废话了，我们首先看看DataSource的作用是什么。下面是Datasource的源码。

public interface DataSource  extends CommonDataSource, Wrapper {

  /**
   * 
Attempts to establish a connection with the data source that
   * this {@code DataSource} object represents.
   *
   * @return  a connection to the data source
   * @exception SQLException if a database access error occurs
   * @throws java.sql.SQLTimeoutException  when the driver has determined that the
   * timeout value specified by the {@code setLoginTimeout} method
   * has been exceeded and has at least tried to cancel the
   * current database connection attempt
   */
  Connection getConnection() throws SQLException;
/// ..... 无关紧要的代码
}

简单说呢，就是获取当前数据库的一个Connection，诶嘿，人家可没说这个就只能返回一个数据库的连接，说的只是当前数据库的连接。没错，AbstractRoutingDatasource 作者肯定就是Get到了这个语言上的小差别。

AbstractRoutingDatasource 重写了这个 getConnection.

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
	/**
	 * 配置多个数据源， 
	 * key：string唯一标识数据源，
	 * value: datasource 数据源 
	 */
	 @Nullable
    private Map<Object, DataSource> resolvedDataSources;
    
    public Connection getConnection() throws SQLException {
        return this.determineTargetDataSource().getConnection();
    }
    /**
     * 确定当前的数据源
     */
	protected DataSource determineTargetDataSource() {
	        // 获取数据库Id（key）
	        Object lookupKey = this.determineCurrentLookupKey();
	        // 根据Id获取数据源
	        DataSource dataSource = (DataSource)this.resolvedDataSources.get(lookupKey);
	        // 忽略一些校验,返回数据源
	       return dataSource；      
	}
	
	/**
	 * 获取当前数据库的Id(Key)
	 * 这个方法就是Springboot留给我们扩展的点了。
	 * 所以呀：
	 * 如果你想实现自己的动态切换数据库的框架，只需要扩展两点就可以了
	 * 1. 拿到你的多个数据源和他们的Id（自己随便指定）组合成一个map 设置给 resolvedDataSources
	 * 2. 实现该方法，确定什么时候用哪一个数据库。
	 */
    @Nullable
    protected abstract Object determineCurrentLookupKey();
}

三、 实现我们自己的动态数据库

1. POM

在这之前，先把POM文件依赖贴一下吧，否则缺少某个库的函数导致代码复现不出来大家该说耍流氓了。

  
  <dependency>
    <groupId>org.springframework.bootgroupId>
       <artifactId>spring-boot-configuration-processorartifactId>
       <optional>trueoptional>
   dependency>
	
	
   <dependency>
       <groupId>org.projectlombokgroupId>
       <artifactId>lombokartifactId>
       <optional>trueoptional>
   dependency>

	
   <dependency>
       <groupId>org.apache.shardingspheregroupId>
       <artifactId>shardingsphere-jdbc-coreartifactId>
       <version>${shardingsphere-jdbc.version}version>
   dependency>
	
   <dependency>
       <groupId>mysqlgroupId>
       <artifactId>mysql-connector-javaartifactId>
   dependency>

   <dependency>
       <groupId>org.springframework.bootgroupId>
       <artifactId>spring-boot-starter-jdbcartifactId>
   dependency>
	
	
   <dependency>
       <groupId>cn.hutoolgroupId>
       <artifactId>hutool-allartifactId>
       <version>5.8.11version>
   dependency>

   
   <dependency>
       <groupId>com.alibabagroupId>
       <artifactId>transmittable-thread-localartifactId>
       <version>2.14.2version>
   dependency>

2. 实现 AbstractRoutingDatasource

ShardingSphereDynamicDataSource

public class ShardingSphereDynamicDataSource extends AbstractRoutingDataSource {
	
	/**
	 * 多数据库 Map，
	 * 这里重新创建了一个Map对象目的有两个
	 * 1. ards 的 resolvedDataSources 是 private 的，子类无法访问。
	 * 2. 设置为static方式的，可以通过静态方法访问，更方便。
	 */
    static final Map<Object, Object> DATA_SOURCE_MAP = new ConcurrentHashMap<>(10);

    private String defaultDataSource;

    public ShardingSphereDynamicDataSource(LinkedHashMap<String, DataSource> dataSourceMap) {
        // 将多数据库Map设置给 resolvedDataSources
        setTargetDataSources(DATA_SOURCE_MAP);
        dataSourceMap.forEach((dsName, ds) -> {
            DATA_SOURCE_MAP.put(dsName, ds);
            if (defaultDataSource == null) {
                // 设置默认数据源
                defaultDataSource = dsName;
                setDefaultTargetDataSource(ds);
            }
        });
    }

    @Override
    protected Object determineCurrentLookupKey() {
    	// 通过ThreadLocal 获取数据库Id，防止多线程设置当前数据源导致的并发问题
        return DynamicDataSourceHelper.dataSourceKey();
    }

	/**
	 * 动态添加数据源
	 */
    public void addDataSource(String dataSourceKey, DataSource dataSource) {
        DATA_SOURCE_MAP.put(dataSourceKey, dataSource);
        afterPropertiesSet();
    }

	/**
	 * 获取默认数据源
	 */
    public String getDefaultDataSource() {
        return defaultDataSource;
    }

	/**
	 * 根据数据源Id获取数据源
	 */
    public DataSource getDataSourceById(String id) {
        return ((DataSource) DATA_SOURCE_MAP.get(id));
    }
}

上面的代码比较简单，只要理解了Springboot是怎么做多数据源的，上面代码就很容易看懂了。

不过里面有一个 DynamicDataSourceHelper ，这个是做什么用的呢？

你想啊，我们有了多数据源了，我们是不是要决定什么时候用哪一个数据库？

这个类就是做这个用的，它其实核心就是维护了一个ThreadLocal, 要设置用哪一个数据库的时候，往这个ThreadLocal 里面设置当前数据库的Key， 上面在获取当前数据库的时候就从这个 ThreadLoca里面取值。

为什么要用ThreadLocal 维护呢，直接设置String不行吗？当然不行，多线程中用数据源的时候，到底谁说了算呢？当然最好的方式是每个线程管自己的。用ThreadLocal专业对口嘛。

另外这里用了阿里的 TransmittableThreadLocal， 目的是为了解决父子线程的传值问题。

DynamicDataSourceHelper

public class DynamicDataSourceHelper {
	
	/**
	 * 用来判断 ShardingSphere 和 普通数据源的，这里可以先不管它，后面会提到。
	 */
    public static final String RAW_DATASOURCE_PREFIX = "sharding::raw::";

    /**
     * 使用Alibaba的 TransmittableThreadLocal 解决数据源切换的父子线程之间数据传递的问题
     */
    private static final ThreadLocal<String> DATA_SOURCE_KEY = new TransmittableThreadLocal<>();
	
	/**
	 * 设置当前使用的数据源Id
	 */
    public static void setDataSource(String dataSourceKey) {
        DATA_SOURCE_KEY.set(dataSourceKey);
    }

	/**
	 * 设置当前使用的原始数据源Id(使用该方法标识使用的不是ShardingSphere数据源，而是原始数据源)
	 */
    public static void setRawJdbcDataSource(String dataSourceKey) {
        if (isRawJdbcDataSourceKey(dataSourceKey)) {
            DATA_SOURCE_KEY.set(dataSourceKey);
        } else {
            DATA_SOURCE_KEY.set(RAW_DATASOURCE_PREFIX + dataSourceKey);
        }
    }

	/**
	 * 使用默认数据源
	 */
    public static void defaultDataSource() {
        DATA_SOURCE_KEY.remove();
    }

	/**
	 * 获取当前使用的数据源Id
	 */
    public static String dataSourceKey() {
        return DATA_SOURCE_KEY.get();
    }

	/**
	 * 判断该数据源Id是否存在
	 */
    public static boolean containsDataSource(String datasource) {
        return ShardingSphereDynamicDataSource.DATA_SOURCE_MAP.containsKey(datasource);
    }

	/**
	 * 根据ShardingShpere 的数据源Id获取到对应的原始数据源Id
	 * 目的是可以获取到ShardingSphere对应的原始数据源。
	 * 还记得上面说我们要能提供原始ddlsql的执行能力吗？
	 * ShardingSphere不支持，单我们可以通过对应的原始数据源来执行。
	 */
    public static String rawJdbcDataSourceKey(String key) {
        if (key.startsWith(RAW_DATASOURCE_PREFIX)) {
            return key;
        }
        return RAW_DATASOURCE_PREFIX + key;
    }
	
	/**
	 * 判断是否是原始数据源，这里默认认为原始数据源的Id比ShardingSphere 的数据源Id多一个前缀
	 * 也就是上面那个静态变量（sharding::raw::）
	 */ 
    public static boolean isRawJdbcDataSourceKey(String key) {
        if (StrUtil.isEmpty(key)) {
            return false;
        }
        return key.startsWith(RAW_DATASOURCE_PREFIX);
    }
}

上面的代码中，已经把怎么切换数据库的逻辑部分写完了，当然它还只是一个架子，还没有具体设置数据源呢，相当于把API给写完了。那这个Api怎么用呢？

public void switchDataSource() {
    // 切换到 ds1 的ShardingSphere数据源
    DynamicDataSourceHelper.setDataSource("ds1");
    mapper.selectSomething();
    jpaRepo.selectByXXX();
    
    // 切换到 ds1 的原始Jdbc数据源
    DynamicDataSourceHelper.setRawJdbcDataSource("ds1");
    mapper.selectSomething();
    jpaRepo.selectByXXX();

    // 切换到 ds2 的ShardingSphere数据源
    DynamicDataSourceHelper.setDataSource("ds2");
    mapper.selectSomething();
    jpaRepo.selectByXXX();
    
    // 切换到 ds2 的原始Jdbc数据源
    DynamicDataSourceHelper.setRawJdbcDataSource("ds2");
    mapper.selectSomething();
    jpaRepo.selectByXXX();
}

3. 创建数据源

上面相当于已经把好看的皮囊写完了，灵魂还没有呢，俗话说得好，“好看的皮囊千篇一律，有趣的灵魂万里挑一”， 没有有趣的灵魂怎么能行呢？

这里主要要确定的一个问题是？我们怎么拿到多个数据源？熟悉那些多数据源开源框架的朋友应该比较了解，配置文件嘛。 所以这里大致制定一个规范，如何读取数据源。配置文件结构如下：

spring:
  shardingsphere:
    props:
      # 是否显示 ShardingSpher 的sql，用于Debug
      sql-show: true
    datasource:
      # 数据源名称列表
      names: ds1,ds2
      # 数据源1
      ds1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/test1?useSSL=false&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai&allowMultiQueries=true
        username: root
        password: 123456
      # 数据2
      ds2:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/test2?useSSL=false&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai&allowMultiQueries=true
        username: root
        password: 123456
    rules:
      sharding:
        tables:
          # 按月分表的数据表（只需要配置逻辑表即可，程序会自动探测存在的表)
          # 但必须保证逻辑表必须存在，即使它在真实程序中不被使用，因为要通过它自动建表
          # 这里可能细心的朋友已经发现了，这样写逻辑岂不是所有数据源的分表都一样了吗？
	      # 这里确实，因为公司项目里面就是所有数据源的数据库都是一样的，所以就这样写了。
	      # 如果大家自己的项目里面多个数据源每个数据库表不一样，分表的数据表也不一样，可以改这一块逻辑。每个数据库的分表单独设置。	   
          binding-tables: data, test_data

上面的哦配置文件应该也比较清晰了，这里就不具体解释了，下面就要通过解析该配置文件创建数据库了。

这里就要做一个小约定了，上面我们配置了两个数据源，但是实际上我们要创建两类，四个数据源。它们分别是：

• ShardingSphere 的数据源 ds1, ds2。
• 原始数据源 sharding::raw::ds1, sharding::raw::ds2

还记的上面的原始数据源前缀吗？就是用在这里的，用它加上数据源的Id创建原始数据源的Id。

/**
 * @Configuration 标识这是一个配置类，Springboot会自动扫描（也方便我们后面制作Springboot-starter）
 * 
 * @AutoConfigureBefore(DataSourceAutoConfiguration.class) 
 * 我们要保证该配置在Springboot的Datasource配置类之前执行，因为我们要用自己 DIY 的数据源了。得插个队。
 * @author wangp
 */
@Slf4j
@Configuration
@AutoConfigureBefore(DataSourceAutoConfiguration.class)
public class AkxyShardingSphereAutoConfiguration {
	
	/**
	 * 读取到有那些表需要进行分表
	 */
    @Value("${spring.shardingsphere.rules.sharding.tables.binding-tables}")
    private List<String> bindingTables;

    @Bean
    public DataSource dataSource(Environment environment) throws SQLException {

        Binder binder = Binder.get(environment);
        Properties properties = binder.bind("spring.shardingsphere.props", Properties.class).orElse(new Properties());
        
        // 从配置文件中读取数据源
        Map<String, DataSource> dataSourceMap = DatasourceHelper.createDataSourceMap(environment);

        LinkedHashMap<String, DataSource> resultDatasourceMap = new LinkedHashMap<>();

        for (String dataSourceName : dataSourceMap.keySet()) {
            DataSource dataSource = dataSourceMap.get(dataSourceName);
            // 创建ShardingSphere 数据源
            DataSource shardingSphereDatasource = ShardingSphereDataSourceFactory.createDataSource(dataSource,
                    Collections.singleton(createShardingRuleConfiguration(dataSource)), properties);
            resultDatasourceMap.put(dataSourceName, shardingSphereDatasource);
        }
        // 同时创建一份 原始的 JDBC DataSource， 并且给它们设置前缀，用于区分不同类型的数据源
        for (String dataSourceName : dataSourceMap.keySet()) {
            resultDatasourceMap.put(DynamicDataSourceHelper.rawJdbcDataSourceKey(dataSourceName),
                    dataSourceMap.get(dataSourceName));
        }
        // 创建动态数据源
        return new ShardingSphereDynamicDataSource(resultDatasourceMap);
    }

	/**
	 * 切片规则配置
	 */
    private ShardingRuleConfiguration createShardingRuleConfiguration(DataSource dataSource) throws SQLException {
        ShardingRuleConfiguration result = new ShardingRuleConfiguration();
        for (String bindingTable : bindingTables) {
        	// 为每一个分表的数据表创建分表规则
            result.getTables().add(getTableRuleConfiguration(dataSource, bindingTable));
        }

		// 设置分表策略， key: acquisition_time 标识分表的数据列，这里的时间列也是写死的，需要用的朋友注意了，可以写在配置文件里，也可以在代码里面改。
		// 设置分表算法： his-data-spi-based 为算法Id 
        result.setDefaultTableShardingStrategy(
                new StandardShardingStrategyConfiguration("acquisition_time", "his-data-spi-based"));
		
		// 设置分表算法Map， 上面的算法Id会从这个Map里面找对应的算法
		// HIS_DATA_SPI_BASED 这个Id是通过 SPI的方式注册的分表算法，SPI的方式具体请参考第二篇文章。
        result.getShardingAlgorithms().put("his-data-spi-based",
                new AlgorithmConfiguration("HIS_DATA_SPI_BASED", new Properties()));
        return result;
    }
	
	/**
	 * 创建分表规则（从ShardingSphere Starter 代码里面抄的~_~）
	 */
    private ShardingTableRuleConfiguration getTableRuleConfiguration(DataSource dataSource, String logicTableName) throws SQLException {
        Set<String> existsActuallyTableSet;
        try (Connection connection = dataSource.getConnection()) {
        	// 查询实际上存在的表（标规则 logictable_yyyyMM）
        	// 因为这里还没有创建ShardingSphere的数据源呢，这里的数据源还是原始的数据源,还没有被代理，所以可以执行一些原始SQL语句
            existsActuallyTableSet = MonthShardingDatabaseUtil.queryActuallyTables(connection, logicTableName);
            // 如果真实表不存在的话, 根据逻辑表创建一个新的表
            if (CollectionUtil.isEmpty(existsActuallyTableSet)) {
            	// 创建一个当前时间对应的月的表
                String createTable = logicTableName + MonthShardingDatabaseUtil.shardingSuffix(new Date());
                if (MonthShardingDatabaseUtil.createTableLike(connection, logicTableName, createTable)) {
                    existsActuallyTableSet = new LinkedHashSet<>();
                    existsActuallyTableSet.add(createTable);
                    log.info("actually table for {} not exists, auto create one : {}", logicTableName, createTable);
                } else {
                    throw new IllegalStateException("Could not create table " + createTable);
                }
            }
        }
        // 组合实际存在的表节点列表， 比如： logic_db.data_202301,logic_db_data_202302
        String actuallyTableNodes = existsActuallyTableSet.stream()
                .map(tableName -> StrUtil.format("{}.{}", "logic_db", tableName))
                .collect(Collectors.joining(","));

        ShardingTableRuleConfiguration result = new ShardingTableRuleConfiguration(logicTableName, actuallyTableNodes);
        // 设置分表策略， key: acquisition_time 标识分表的数据列，这里的时间列也是写死的，需要用的朋友注意了，可以写在配置文件里，也可以在代码里面改。
        result.setTableShardingStrategy(new StandardShardingStrategyConfiguration(
                "acquisition_time", "his-data-spi-based"));
        return result;
    }


    @Bean
    public AutoCreateTableHelper tableHelper(DataSource dataSource) {
    	// 自动建表Helper，后面会提及
        return new AutoCreateTableHelper(dataSource);
    }

}

上面的代码中，从配置文件里面读取数据源列表，读取分表的数据表列表，然后通过他们来构建ShardingSphere数据源和原始JDBC数据源，并通过他们生成我们上面的动态数据源，注册为Springboot的bean。

上面有两个工具类，DatasourceHelper， MonthShardingDatabaseUtil 这两个工具类一个作用是从配置文件读取Datasource，一个是按月分表的工具类，提供了一个辅助方法。希望别嫌代码多，我也贴出来了，我会把代码也传上去，嫌多的伙伴可以不看这一部分,直接下载源码用。

DatasourceHelper

/**
 * @author wangp
 */
public class DatasourceHelper {

    private static final String PREFIX = "spring.shardingsphere.datasource.";

    private static final String DATA_SOURCE_NAME = "name";
    private static final String DATA_SOURCE_NAMES = "names";

    private static final String DATA_SOURCE_TYPE = "type";

    @SuppressWarnings("unchecked")
    public static DataSource getDataSource(final Environment environment, final String dataSourceName) throws NamingException {
        Binder binder = Binder.get(environment);
        BindResult<Map> bind = binder.bind(toDashedForm(String.join("", PREFIX, dataSourceName)), Map.class);
        Map<String, Object> dataSourceProps = bind.get();
        Preconditions.checkState(!dataSourceProps.isEmpty(), "Wrong datasource [%s] properties.", dataSourceName);
        return DataSourcePoolCreator.create(new DataSourceProperties(dataSourceProps.get(DATA_SOURCE_TYPE).toString(),
                getCamelCaseKeys(dataSourceProps)));
    }

    private static String toDashedForm(final String name) {
        StringBuilder result = new StringBuilder(name.length());
        boolean inIndex = false;
        for (int i = 0; i < name.length(); i++) {
            char ch = name.charAt(i);
            if (inIndex) {
                result.append(ch);
                if (ch == ']') {
                    inIndex = false;
                }
            } else {
                if (ch == '[') {
                    inIndex = true;
                    result.append(ch);
                } else {
                    ch = (ch != '_') ? ch : '-';
                    if (Character.isUpperCase(ch) && result.length() > 0 && result.charAt(result.length() - 1) != '-') {
                        result.append('-');
                    }
                    result.append(Character.toLowerCase(ch));
                }
            }
        }
        return result.toString();
    }

    public static Map<String, Object> getCamelCaseKeys(final Map<String, Object> dataSourceProps) {
        Map<String, Object> result = new LinkedHashMap<>(dataSourceProps.size(), 1);
        for (Map.Entry<String, Object> entry : dataSourceProps.entrySet()) {
            String key = entry.getKey();
            result.put(key.contains("-") ? CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, key) : key, entry.getValue());
        }
        return result;
    }

    private static List<String> getDataSourceNames(final Environment environment) {
        StandardEnvironment standardEnv = (StandardEnvironment) environment;
        standardEnv.setIgnoreUnresolvableNestedPlaceholders(true);
        String dataSourceNames = standardEnv.getProperty(PREFIX + DATA_SOURCE_NAME);
        if (Strings.isNullOrEmpty(dataSourceNames)) {
            dataSourceNames = standardEnv.getProperty(PREFIX + DATA_SOURCE_NAMES);
        }
        return new InlineExpressionParser(dataSourceNames).splitAndEvaluate();
    }

    public static Map<String, DataSource> createDataSourceMap(Environment environment) {
        Map<String, DataSource> result = new LinkedHashMap<>();
        for (String each : getDataSourceNames(environment)) {
            try {
                result.put(each, getDataSource(environment, each));
            } catch (final NamingException ex) {
                throw new IllegalStateException(ex);
            }
        }
        return result;
    }
}

MonthShardingDatabaseUtil

/**
 * @author wangp
 */
@Slf4j
public class MonthShardingDatabaseUtil {
    /**
     * 这里使用ThreadLocal的一个目的是因为SimpleDateFormat 不是线程安全的
     */
    private static final ThreadLocal<SimpleDateFormat> formatThreadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMM"));


    /**
     * 根据逻辑表从数据库刷新实际表
     */
    public static Set<String> queryActuallyTables(Connection connection, String logicTableName) {
        // 使用正则表达式过滤符合条件的表 stress_data_[0-9]{4}
        Pattern monthPattern = Pattern.compile("^" + logicTableName + "_[0-9]{6}$");
        try (Statement statement = connection.createStatement()) {
            String sql = "SHOW TABLES LIKE '" + logicTableName + "_%';";
            ResultSet resultSet = statement.executeQuery(sql);

            Set<String> tables = new LinkedHashSet<>();
            while (resultSet.next()) {
                String tableName = resultSet.getString(1);
                if (monthPattern.matcher(tableName).matches()) {
                    tables.add(tableName);
                }
            }
            return tables;
        } catch (SQLException e) {
            log.error("queryActuallyTables failed", e);
            return null;
        }
    }

    /**
     * 创建数据库表, 并开启双重验证判断表是否创建成功
     *
     * @param likeTable   逻辑表名称
     * @param createTable 实际表名称
     */
    public static boolean createTableLike(Connection connection, String likeTable, String createTable) {
        try (Statement statement = connection.createStatement()) {
            // create table stress_data_202210 like stress_data
            statement.execute("CREATE TABLE " + createTable + " LIKE " + likeTable + ";");
            // double check
            ResultSet resultSet = statement.executeQuery("SHOW TABLES LIKE '" + createTable + "';");
            if (resultSet.next()) {
                log.info("Auto create actually table {} success", createTable);
                return resultSet.getString(1) != null;
            } else {
                log.info("Auto create actually table {} failure", createTable);
                return false;
            }
        } catch (SQLException e) {
            // already exists
            if (e.getMessage() != null && e.getMessage().contains("already exists")) {
                return true;
            }
            log.error("fail to create actuallyTable '{}' from logicTable '{}'",
                    createTable, likeTable, e);
            return false;
        }
    }

    /**
     * 按月分表的表后缀
     */
    public static String shardingSuffix(Date shardingValue) {
        return "_" + formatThreadLocal.get().format(shardingValue);
    }
}

四、实现按月分表算法

我们中途休息一下，总结一下上面做了那些事情呢？

1. 实现了多数据源的切换，并注册到Springboot中
2. 从配置文件中读取多数据源，生成ShardingSphere数据域与原生数据库的数据源，设置到动态数据源中。
3. 从配置文件中读取分表的数据库表，设置分表算法，根据自动从数据库中根据逻辑表扫描分表，添加到ShardingSphere数据源中，如果没有真实表存在，根据当前时间自动创建一个分表。

1. 分表算法

通过上面的总结，基本上已经把数据源给配置完成了，现在还缺少灵魂中的灵魂，分表算法。分表算法的添加流程这里就不在详细说了，具体流程可以参考第二篇文章 ShardingSphere笔记（二）：自定义分片算法 — 按月分表。

/**
 * 按月分表的 Sharding 算法
 *
 * @author wangp
 */
@Getter
@Slf4j
public class HisDataMonthShardingAlgorithm implements StandardShardingAlgorithm<Date> {

    private final ThreadLocal<SimpleDateFormat> formatThreadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMM"));

    private Properties props;
    /**
     * 自动建表的下限：时间小于该时间段的就不建表了，没有意义，这个时间可以自己在配置文件中设置，不设置默认为2018年01月
     */
    private Date autoCreateTableLowerDate;

    @Override
    public void init(Properties properties) {
        // 读取配置文件
        this.props = properties;
        String autoCreateTableLowerDate = properties.getProperty("auto-create-table-lower");
        try {
            this.autoCreateTableLowerDate = formatThreadLocal.get().parse(autoCreateTableLowerDate);
        } catch (Exception e) {
            log.error("parse auto-create table lower date failed: {}, use default date 2018-01", e.getMessage());
            try {
                this.autoCreateTableLowerDate = formatThreadLocal.get().parse("201801");
            } catch (ParseException ignored) {
            }
        }

    }


    /**
     * 精确匹配，只有在该条件下才需要自动建表。
     * 

     * 因为自动建表只有在存数据的时候才有意义，查询数据的时候表没有就没有了，存数据的时候没有表可就有问题了
     * 

     * 而存数据都是精确匹配，所以只需要在这里自动建表
     *
     * @param availableTargetNames 当前系统中可用的真实表列表
     * @param shardingValue        精确匹配的条件
     * @return 精确匹配后的表
     */
    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Date> shardingValue) {
        Date value = shardingValue.getValue();
        String actuallyTableName = shardingValue.getLogicTableName() + MonthShardingDatabaseUtil.shardingSuffix(value);
        // 从可用的列表总判断是否存在需要的表，如果表不存在，建表，并把建好的表再次添加到 availableTargetNames 中
        // 这里添加到 availableTargetNames 相当于刷新了ShardingSphere的缓存了，这就是一个骚操作了，后面会贴一下源码
        Collection<String> tables = AutoCreateTableHelper.getInstance()
                .autoDetectionSchemeTables(shardingValue.getLogicTableName(),
                        Collections.singletonList(actuallyTableName), true);
        availableTargetNames.addAll(tables);
        return CollectionUtil.get(tables, 0);
    }

    /**
     * 范围匹配，范围匹配都是查询、更新或者删除，所以表都是存在的不自动建表
     */
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames, RangeShardingValue<Date> shardingValue) {

        // 从查询时间到现在
        Date time;
        // 判断是否有下限
        if (shardingValue.getValueRange().hasLowerBound()) {
            time = shardingValue.getValueRange().lowerEndpoint();
        } else {
            // 无下限使用默认的下限
            time = autoCreateTableLowerDate;
        }

        Date now;
        // 判断是否有上限
        if (shardingValue.getValueRange().hasUpperBound()) {
            now = shardingValue.getValueRange().upperEndpoint();
        } else {
            // 往后延一个月 （无上限的话最多往后延一个月）
            now = DateUtil.offsetMonth(new Date(), 1);
        }

        now = DateUtil.endOfMonth(now);
        List<String> tableNames = new ArrayList<>();
        while (time.before(now)) {
            String actuallyTableName = shardingValue.getLogicTableName() + MonthShardingDatabaseUtil.shardingSuffix(time);
            tableNames.add(actuallyTableName);
            time = DateUtil.offsetMonth(time, 1);
        }
        // 这里不自动建表
        final Collection<String> tables = AutoCreateTableHelper.getInstance()
                .autoDetectionSchemeTables(shardingValue.getLogicTableName(), tableNames, false);
        availableTargetNames.addAll(tables);
        return tables;
    }


    /**
     * SPI 方式实现的分表算法，算法标识ID为 HIS_DATA_SPI_BASED
     */
    @Override
    public String getType() {
        return "HIS_DATA_SPI_BASED";
    }

}

这里分表的逻辑是，查询到对应的真实表后，判断 ShardingSphere 中是否存在该真实表，如果表不存在，自动创建该表，并更新到ShardingSphere的缓存中。

这里就是一个骚操作的地方了，为甚了新加到 availableTargetNames 中的表 ShardingSphere 就认呢？不需要修改分表配置什么的吗？原来我也是这么想的，所以写的代码贼复杂，还要有定时任务重设 ShardingSphere配置，还不成功…, 后来追源码看到了一个神器的东西。如下：

ShardingSphere 源码中的路由逻辑如下：

ShardingStandardRoutingEngine

private Collection<DataNode> routeTables(final TableRule tableRule, final String routedDataSource,
                                         final ShardingStrategy tableShardingStrategy, final List<ShardingConditionValue> tableShardingValues) {
     
    // 从 TableRule 中获取真实表内容
    Collection<String> availableTargetTables = tableRule.getActualTableNames(routedDataSource);
    Collection<String> routedTables = tableShardingValues.isEmpty()
            ? availableTargetTables
            : tableShardingStrategy.doSharding(availableTargetTables, tableShardingValues, tableRule.getTableDataNode(), properties);
    Collection<DataNode> result = new LinkedList<>();
    for (String each : routedTables) {
        result.add(new DataNode(routedDataSource, each));
    }
    return result;
}

而 在TableRule 中，getActualTableNames() 是从一个Map中拿的值。作为缓存。

TableRule

 private final Map> dataSourceToTablesMap = new HashMap<>();

 public Collection getActualTableNames(final String targetDataSource) {
 	 // 从缓存中拿真实表的列表
     return dataSourceToTablesMap.getOrDefault(targetDataSource, Collections.emptySet());
 }
 private void addActualTable(final String datasourceName, final String tableName) {
 	// 添加真实表(框架在初始化的收自动调用)
    dataSourceToTablesMap.computeIfAbsent(datasourceName, key -> new LinkedHashSet<>()).add(tableName);
}

可以看到，这里存的就是真实表列表，也会就是说我们修改的那个 availableTargetNames 就是这个缓存中的对象，人家是直接把对象给你了，那你岂不是想怎么操作就怎么操作了，诶嘿。

所以我前面会说，这个骚操作还挺依赖框架本身的实现的，万一人家哪一天不爽了，不想给你对象了，给你一个拷贝对象，就抓瞎了。

这里说明了，为什么初始的时候一定要存在一个真实表，如果不存在也一定要创建一个，这就是因为如果真实表一个也没有吗，框架本身不会调用 addActualTable 函数，就是说缓存map里面没有列表，就会返回 Collections.emptySet(), 而这个就是非常坑爹的不可修改集合 ，大家学集合基础知识的时候应该都注意过这一点。它不可修改就意味着自动建表的表没办法加进去了，就会报错，所以这里我们必须保证数据库里面一定至少要有一个真实表。

2. 添加SPI

在 resource/META-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAlgorithm 文件中添加

com.akxy.platdatamanage.sharding.HisDataMonthShardingAlgorithm

五、自动建表

上面有一个自动建表的辅助类，这里就只贴源码了，不多做解释了，就是从数据库查询表，然后判断表是否存在，不存在建表，更新缓存。

就是几个关键的点：

• 使用原生JDBC数据源查找数据库中存在的真实表，建表。因为ShardingSphere数据源不支持。这也是我们上面设置了两种数据源的好处，正好就可以利用上。
• 查询到的数据库表进行缓存。提升查询速度。

/**
 * @author wangp
 */
@Slf4j
public class AutoCreateTableHelper implements EnvironmentAware {

    /**
     * 利用Springboot的单例模式，方便使用
     */
    private static AutoCreateTableHelper instance;

    /**
     * 冬天该数据源
     */
    private final ShardingSphereDynamicDataSource dataSource;

    /**
     * 数据库的 数据源 : 逻辑表 : 实际表 缓存
     */
    private final Map<String, Map<String, Set<String>>> dsLogicActuallyTableCache = new ConcurrentHashMap<>();

    public AutoCreateTableHelper(DataSource dataSource) {
        this.dataSource = ((ShardingSphereDynamicDataSource) dataSource);
    }

    public Collection<String> autoDetectionSchemeTables(String logicTableName,
                                                        Collection<String> actuallyTableNames, boolean createTable) {
        // 当前数据源
        String currentDataSource = getCurrentDataSource();
        // 从动态数据库中获取数据源的原始JDBC数据源，因为ShardingSphere数据源做不到建表语句，必须使用原始JDBC数据源
        try (Connection connection = getRawJdbcConnection()) {
            if (connection == null) {
                log.error("Un found raw jdbc resource to get connection for {}", currentDataSource);
                return Collections.emptyList();
            }
            // 获取到缓存的数据源表
            Set<String> cachedTables = getCachedTables(logicTableName, currentDataSource, connection);
            // 不存在的表
            List<String> notExistsTables = new ArrayList<>();
            // 已存在的表
            List<String> existsTables = new ArrayList<>();
            actuallyTableNames.forEach(table -> {
                if (cachedTables.contains(table)) {
                    existsTables.add(table);
                } else {
                    notExistsTables.add(table);
                }
            });
            if (notExistsTables.isEmpty()) {
                return existsTables;
            }
            // 如果自动建表，创建那些不存在的表
            if (createTable) {
                String tableLike = cachedTables.stream().findAny().orElse(logicTableName);
                for (String notExistsTable : notExistsTables) {
                    if (MonthShardingDatabaseUtil.createTableLike(connection, tableLike, notExistsTable)) {
                        cachedTables.add(notExistsTable);
                        existsTables.add(notExistsTable);
                    } else {
                        log.info("Auto create actually table failed");
                    }
                }
            } else {
                // 重新从数据库中刷新数据
                Set<String> databaseTables = MonthShardingDatabaseUtil.queryActuallyTables(connection, logicTableName);
                if (databaseTables != null) {
                    // 刷新缓存
                    cachedTables.addAll(databaseTables);
                    notExistsTables.removeIf(table -> !databaseTables.contains(table));
                    existsTables.addAll(notExistsTables);
                }
            }
            return existsTables;
        } catch (Exception e) {
            log.error("detection scheme table failed", e);
            return Collections.emptyList();
        }
    }

    private String getCurrentDataSource() {
        String dataSourceKey = DynamicDataSourceHelper.dataSourceKey();
        if (StrUtil.isEmpty(dataSourceKey)) {
            return dataSource.getDefaultDataSource();
        }
        return dataSourceKey;
    }


    private Set<String> getCachedTables(String logicTableName, String currentDataSource, Connection connection) {
        if (!dsLogicActuallyTableCache.containsKey(currentDataSource)) {
            Set<String> dataSourceTables = MonthShardingDatabaseUtil.queryActuallyTables(connection, logicTableName);
            if (dataSourceTables == null) {
                return Collections.emptySet();
            }
            Map<String, Set<String>> tableMap = new ConcurrentHashMap<>();
            tableMap.put(logicTableName, dataSourceTables);
            dsLogicActuallyTableCache.put(currentDataSource, tableMap);
        }
        Map<String, Set<String>> tableMap = dsLogicActuallyTableCache.get(currentDataSource);
        if (!tableMap.containsKey(logicTableName)) {
            Set<String> dataSourceTables = MonthShardingDatabaseUtil.queryActuallyTables(connection, logicTableName);
            if (dataSourceTables == null) {
                return Collections.emptySet();
            }
            tableMap.put(logicTableName, dataSourceTables);
        }
        return tableMap.get(logicTableName);
    }

    /**
     * 单例模式： 这里不使用Springboot的bean加载是为了防止作为lib的时候Bean加载时机不同导致的NPL
     */
    public static AutoCreateTableHelper getInstance() {
        return instance;
    }

    Connection getRawJdbcConnection() throws Exception {

        String currentDataSource = getCurrentDataSource();
        DataSource dataSourceById;
        // 如果已经是 RAWJdbc的连接了，直接查找
        if (DynamicDataSourceHelper.isRawJdbcDataSourceKey(currentDataSource)) {
            dataSourceById = dataSource.getDataSourceById(currentDataSource);
            if (dataSourceById != null) {
                return dataSourceById.getConnection();
            }
        } else {
            // 尝试查找Jdbc连接
            dataSourceById = dataSource.getDataSourceById(DynamicDataSourceHelper.rawJdbcDataSourceKey(currentDataSource));
            if (dataSourceById != null) {
                return dataSourceById.getConnection();
            }
            // 如果查找不到，再次尝试使用原始连接查找
            dataSourceById = dataSource.getDataSourceById(currentDataSource);
            if (dataSourceById != null && !(dataSourceById instanceof ShardingSphereDataSource)) {
                return dataSourceById.getConnection();
            }
        }
        return null;
    }

    @Override
    public void setEnvironment(Environment environment) {
        instance = this;
    }
}

六、 拓展

至此、所有的逻辑就已经写完了，使用的时候只需要配置配置文件即可。配置多数据源，配置那些表需要按月分表。

另外必须要提一个的就是，本项目是有缺陷的，因为基本上是为我们公司写的一个框架性项目，能满足本公司使用，额外的扩展性需求大佬们刻印扩展。

另外如果想做成 SpringbootStarter方式使用的话，做到代码的零侵入，直接引入即可使用，可以将其作为 Springboot-starter 来配置。

配置方式为：

resource/META-INF/spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.akxy.platdatamanage.conf.AkxyShardingSphereAutoConfiguration

或者 Springboot 2.7 之后

resource/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

com.akxy.platdatamanage.conf.AkxyShardingSphereAutoConfiguration

两种都配置上，即可兼容不同的Springboot版本。

这样的话使用的时候只需要引入依赖，配置配置文件即可，就像 各种 Springboot-starter 使用那样。

七、源代码

刚写文章的时候看到了 CSDN支持上传代码包，就把源代码放到代码包里面了，不知道这个下载是不是需要积分啥的呢，反正上面已经把所有的代码头贴上去了。实在不行到时候另起一个仓库开源出来。完事，晚安世界。

贴一个最近瞎画的可爱宵宫，嘿嘿：