写在前面

上一篇文章出现的问题，就是sharing-jdbc无法根据一个不固定的字段（停车场id）进行动态分表，因为actual-data-nodes是在项目启动的时候就加载好的，不支持动态修改。
还好这一切都是可以解决的。
那么这一篇文章，就是解决了actual-data-nodes动态修改问题。解决方案大致说明一下就是基于sharding-jdbc + sharding的服务编排治理+redis，实现了订单表根据停车场id动态分表，每增删停车场，在不重启项目的情况下动态的改变actual-data-nodes

思路

首先参考了这篇老哥的博文：https://blog.csdn.net/qq_32588349/article/details/99440985 给了我很大的启发
根据官方文档描述，shardingsphere提供了配置中心、注册中心的服务治理功能。并且有这句描述：
sharding-jdbc 如何实时修改分表规则（不重启项目） - 图1
这应该就是我想要的东西，但是我确实不知道该怎么入手，就让公司的架构师给我处理了一下。然后最终得到了下面这个方案。在这里要感谢两位老哥！

大概的描述一下本demo的业务：

  1. sharing-jdbc ： 引入基于java的配置包（不用starter包）
  2. 需要分的表为：订单表（t_order）
  3. 分表的依据字段：停车场id(car_park_id)
  4. 分库字段：不需要分库
  5. 初始化数据库要有一个默认表：t_order_defalut,这个表只是为了第一次启动项目，还没有停车场信息的时候，用来默认的，里面不会存任何数据
  6. redis hash存放<停车场id，停车场名称>
  7. redis zset存放 订单actual-data-nodes，score为当前时间的时间戳，方便获取最新的用来替换

配置步骤

sql脚本

  1. /*
  2. Navicat MySQL Data Transfer
  4. Source Server         : 开发数据库 4.71
  5. Source Server Version : 50730
  6. Source Host           : 192.168.4.71:3307
  7. Source Database       : sharding_carpark
  9. Target Server Type    : MYSQL
  10. Target Server Version : 50730
  11. File Encoding         : 65001
  13. Date: 2020-05-11 18:25:00
  14. */
  16. SET FOREIGN_KEY_CHECKS=0;
  18. -- ----------------------------
  19. -- Table structure for t_car_park
  20. -- ----------------------------
  21. DROP TABLE IF EXISTS `t_car_park`;
  22. CREATE TABLE `t_car_park` (
  23.   `id` varchar(64) NOT NULL,
  24.   `name` varchar(100) DEFAULT NULL COMMENT '名称',
  25.   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  26.   PRIMARY KEY (`id`)
  27. ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='停车场表';
  29. -- ----------------------------
  30. -- Table structure for t_order_default
  31. -- ----------------------------
  32. DROP TABLE IF EXISTS `t_order_default`;
  33. CREATE TABLE `t_order_default` (
  34.   `id` varchar(64) NOT NULL,
  35.   `name` varchar(100) DEFAULT NULL COMMENT '名称',
  36.   `car_park_id` varchar(64) DEFAULT NULL COMMENT '停车场id',
  37.   `no` varchar(100) DEFAULT NULL COMMENT '订单号',
  38.   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  39.   PRIMARY KEY (`id`)
  40. ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='测试分表';

pom文件

  1.         <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-web</artifactId>
  4.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.boot</groupId>
  8.             <artifactId>spring-boot-starter-test</artifactId>
  9.             <scope>test</scope>
  10.             <exclusions>
  11.                 <exclusion>
  12.                     <groupId>org.junit.vintage</groupId>
  13.                     <artifactId>junit-vintage-engine</artifactId>
  14.                 </exclusion>
  15.             </exclusions>
  16.         </dependency>
  18.         <dependency>
  19.             <groupId>org.springframework.boot</groupId>
  20.             <artifactId>spring-boot-starter-data-redis</artifactId>
  21.         </dependency>
  23.         <!--mybatisplus-->
  24.         <dependency>
  25.             <groupId>com.baomidou</groupId>
  26.             <artifactId>mybatis-plus-boot-starter</artifactId>
  27.             <version>3.3.1.tmp</version>
  28.         </dependency>
  30.         <!--lombok-->
  31.         <dependency>
  32.             <groupId>org.projectlombok</groupId>
  33.             <artifactId>lombok</artifactId>
  34.             <scope>provided</scope>
  35.         </dependency>
  37.         <!--fastjson-->
  38.         <dependency>
  39.             <groupId>com.alibaba</groupId>
  40.             <artifactId>fastjson</artifactId>
  41.             <version>1.2.60</version>
  42.         </dependency>
  44.         <!--mysql-->
  45.         <dependency>
  46.             <groupId>mysql</groupId>
  47.             <artifactId>mysql-connector-java</artifactId>
  48.             <version>5.1.44</version>
  49.         </dependency>
  51.         <!--druid-->
  52.         <dependency>
  53.             <groupId>com.alibaba</groupId>
  54.             <artifactId>druid</artifactId>
  55.             <version>1.1.20</version>
  56.         </dependency>
  58.         <dependency>
  59.             <groupId>org.springframework.boot</groupId>
  60.             <artifactId>spring-boot-starter-log4j2</artifactId>
  61.         </dependency>
  63.         <dependency>
  64.             <groupId>org.apache.shardingsphere</groupId>
  65.             <artifactId>sharding-jdbc-core</artifactId>
  66.             <version>4.0.0</version>
  67.         </dependency>
  69.         <dependency>
  70.             <groupId>org.apache.shardingsphere</groupId>
  71.             <artifactId>sharding-jdbc-orchestration</artifactId>
  72.             <version>4.0.0</version>
  73.         </dependency>

重点关注：sharding-jdbc-core、sharding-jdbc-orchestration这两个包，这两个包是必备的。

application.yml

  1. server:
  2.   port: 8086
  3.   tomcat:
  4.     max-threads: 100
  5. spring:
  6.   druid:
  7.     datasource:
  8.       type: com.alibaba.druid.pool.DruidDataSource
  9.       url: jdbc:mysql://192.168.4.71:3307/sharding_carPark?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
  10.       driver-class-name: com.mysql.jdbc.Driver
  11.       username: root
  12.       password: 123456
  13.       maxActive: 20
  14.       initialSize: 5
  15.       maxWait: 60000
  16.       minIdle: 5
  17.       timeBetweenEvictionRunsMillis: 60000
  18.       minEvictableIdleTimeMillis: 300000
  19.       validationQuery: SELECT 1 FROM DUAL
  20.       testWhileIdle: true
  21.       testOnBorrow: false
  22.       testOnReturn: false
  23.       #是否缓存preparedStatement，也就是PSCache。在mysql下建议关闭。 PSCache对支持游标的数据库性能提升巨大，比如说oracle。
  24.       poolPreparedStatements: false
  25.       #要启用PSCache，-1为关闭 必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true  可以把这个数值配置大一些，比如说100
  26.       maxOpenPreparedStatements: -1
  27.       #配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
  28.       filters: stat,wall,log4j2
  29.       #通过connectProperties属性来打开mergeSql功能；慢SQL记录
  30.       connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
  31.       #合并多个DruidDataSource的监控数据
  32.       useGlobalDataSourceStat: true
  33.       loginUsername: druid
  34.       loginPassword: druid
  35.   redis:
  36.     database: 1
  37.     host: 192.168.4.71
  38.     port: 6379
  39.     password: 123456
  40.     jedis:
  41.       pool:
  42.         max-active: 8
  43.         max-wait: -1
  44.         max-idle: 8
  45.         min-idle: 0
  46. logging:
  47.   level:
  48.     com.example.demo: debug

这里的配置文件比较常规

LocalRegistryCenter 本地注册中心

  1. package com.example.demo.config.shardingconfig;
  3. import org.apache.shardingsphere.orchestration.reg.api.RegistryCenter;
  4. import org.apache.shardingsphere.orchestration.reg.api.RegistryCenterConfiguration;
  5. import org.apache.shardingsphere.orchestration.reg.listener.DataChangedEventListener;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Properties;
  10. import java.util.concurrent.ConcurrentHashMap;
  12. public class LocalRegistryCenter implements RegistryCenter {
  13.     public static Map<String, DataChangedEventListener> listeners = new ConcurrentHashMap<>();
  15.     private RegistryCenterConfiguration config;
  17.     private Properties properties;
  18.     /**
  19.      * public 是为了在重置节点的时候减少去重新读配置
  20.      */
  21.     public static Map<String, String> values = new ConcurrentHashMap<>();
  23.     @Override
  24.     public void init(RegistryCenterConfiguration config) {
  25.         this.config = config;
  26.     }
  28.     @Override
  29.     public String get(String key) {
  30.         return values.get(key);
  31.     }
  33.     @Override
  34.     public String getDirectly(String key) {
  35.         return values.get(key);
  36.     }
  38.     @Override
  39.     public boolean isExisted(String key) {
  40.         return values.containsKey(key);
  41.     }
  43.     @Override
  44.     public List<String> getChildrenKeys(String key) {
  45.         return null;
  46.     }
  48.     @Override
  49.     public void persist(String key, String value) {
  50.         values.put(key, value);
  51.     }
  53.     @Override
  54.     public void update(String key, String value) {
  55.         values.put(key, value);
  56.     }
  58.     @Override
  59.     public void persistEphemeral(String key, String value) {
  60.         values.put(key, value);
  61.     }
  63.     @Override
  64.     public void watch(String key, DataChangedEventListener dataChangedEventListener) {
  65.         if (null != dataChangedEventListener) {
  66.             // 将数据改变的事件监听器缓存下来
  67.             listeners.put(key, dataChangedEventListener);
  68.         }
  69.     }
  71.     @Override
  72.     public void close() {
  73.         config = null;
  74.     }
  76.     @Override
  77.     public void initLock(String key) {
  79.     }
  81.     @Override
  82.     public boolean tryLock() {
  83.         return false;
  84.     }
  86.     @Override
  87.     public void tryRelease() {
  89.     }
  91.     @Override
  92.     public String getType() {
  93.         // 【关键点1】，留着文章后续引用
  94.         return "shardingLocalRegisterCenter";
  95.     }
  97.     @Override
  98.     public Properties getProperties() {
  99.         return properties;
  100.     }
  102.     @Override
  103.     public void setProperties(Properties properties) {
  104.         this.properties = properties;
  105.     }
  106. }

下面这步很重要
在本地文件中添加注册中心

  1. 在resources文件夹下面新建Directory，名称为：META-INF
  2. 在META-INF继续创建名为service的Directory
  3. 添加file，名为org.apache.shardingsphere.orchestration.reg.api.RegistryCenter（注意这个是固定的），里面的内容是：com.example.demo.config.shardingconfig.LocalRegistryCenter（你本地注册中心类存放的全路径）
    像这样
    sharding-jdbc 如何实时修改分表规则（不重启项目） - 图2

基于java的配置类

  1. package com.example.demo.config.shardingconfig;
  3. import com.alibaba.druid.filter.Filter;
  4. import com.alibaba.druid.filter.logging.Slf4jLogFilter;
  5. import com.alibaba.druid.filter.stat.StatFilter;
  6. import com.alibaba.druid.pool.DruidDataSource;
  7. import com.alibaba.druid.util.StringUtils;
  8. import com.alibaba.druid.wall.WallConfig;
  9. import com.alibaba.druid.wall.WallFilter;
  10. import com.example.demo.config.datasource.DataSourceProperties;
  11. import com.example.demo.config.redis.RedisConfig;
  12. import com.example.demo.config.redis.RedisPrefixEnum;
  13. import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
  14. import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
  15. import org.apache.shardingsphere.api.config.sharding.strategy.StandardShardingStrategyConfiguration;
  16. import org.apache.shardingsphere.orchestration.config.OrchestrationConfiguration;
  17. import org.apache.shardingsphere.orchestration.reg.api.RegistryCenterConfiguration;
  18. import org.apache.shardingsphere.shardingjdbc.orchestration.api.OrchestrationShardingDataSourceFactory;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.boot.autoconfigure.AutoConfigureAfter;
  21. import org.springframework.context.annotation.Bean;
  22. import org.springframework.context.annotation.Configuration;
  23. import org.springframework.data.redis.core.RedisTemplate;
  25. import javax.sql.DataSource;
  26. import java.sql.SQLException;
  27. import java.util.*;
  29. /**
  30.  * @title: ShardingRuleConfig
  31.  * @projectName shardingJavaDemo
  32.  * @description: TODO
  33.  * @author zhy
  34.  * @date 2020/5/910:23
  35.  */
  36. @Configuration
  37. @AutoConfigureAfter({DataSourceProperties.class, RedisConfig.class})
  38. public class ShardingRuleConfig {
  40.     private String defaultDataSource = DatasourceEnum.DEFAULT.getValue();
  42.     @Autowired
  43.     private RedisTemplate<String,Object> redisTemplate;
  45.     @Autowired
  46.     private DataSourceProperties properties;
  48.     /**
  49.       * shardingjdbc数据源
  50.       * @param
  51.       * @throws
  52.       * @return javax.sql.DataSource
  53.       * @author zhy
  54.       * @date 2020/5/9 10:33
  55.       */
  56.     @Bean
  57.     public DataSource dataSource() throws SQLException {
  58.         // 配置真实数据源
  59.         Map<String, DataSource> dataSourceMap = new HashMap<>();
  60.         //多数据源配置
  61.         //数据源1
  62.         DruidDataSource dataSource0 = druidDataSource();
  63.         dataSourceMap.put(defaultDataSource, dataSource0);
  64.         //数据源2
  65. //        DruidDataSource dataSource1 = createDb1();
  66. //        dataSourceMap.put("ds1", dataSource1);
  68.         // 配置分片规则
  69.         ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
  70.         //订单表分片规则
  71.         TableRuleConfiguration orderRuleConfig = orderRuleConfig();
  72.         shardingRuleConfig.getTableRuleConfigs().add(orderRuleConfig);
  73.         //可以继续用add添加分片规则
  74.         //shardingRuleConfig.getTableRuleConfigs().add(orderRuleConfig);
  75.         //多数据源一定要指定默认数据源，只有一个数据源就不需要
  76.         //shardingRuleConfig.setDefaultDataSourceName("ds0");
  77.         Properties p = new Properties();
  78.         //打印sql语句，生产环境关闭
  79.         p.setProperty("sql.show",Boolean.TRUE.toString());
  80.         OrchestrationConfiguration orchestrationConfig = new OrchestrationConfiguration(
  81.                 "orchestration-sharding-data-source", new RegistryCenterConfiguration("shardingLocalRegisterCenter"),
  82.                 false);
  83.         return OrchestrationShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfig, p,
  84.                 orchestrationConfig);
  85.     }
  87.     /**
  88.      * 订单分片规则
  89.      * @param
  90.      * @throws
  91.      * @return io.shardingjdbc.core.api.config.TableRuleConfiguration
  92.      * @author zhy
  93.      * @date 2020/5/7 10:28
  94.      */
  95.     private TableRuleConfiguration orderRuleConfig(){
  96.         String logicTable = ShardingTableEnum.ORDER.getValue();
  97.         String orderNodesByRedisCarPark = getActualDataNodesByCatalog(ShardingTableEnum.ORDER);
  98.         //t_order_default 这张表是默认表，需要事先建好，防止首次启动报错
  99.         String actualDataNodes = StringUtils.isEmpty(orderNodesByRedisCarPark) ? "ds0.t_order_default" : orderNodesByRedisCarPark;
  100.         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration(logicTable,actualDataNodes);
  101.         //设置分表策略
  102.         tableRuleConfig.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("car_park_id",new CarParkShardingTableAlgorithm()));
  103.         //根据时间将策略放进redis中,方便读取替换
  104.         redisTemplate.opsForZSet().add(RedisPrefixEnum.SHARDING_RULE_ORDER.getValue(),actualDataNodes,new Date().getTime());
  105.         return tableRuleConfig;
  106.     }
  109.     /**
  110.       * 根据分表类型获取初始化actualDataNodes
  111.       * @param logicTable
  112.       * @throws
  113.       * @return java.lang.String
  114.       * @author zhy
  115.       * @date 2020/5/11 14:52
  116.       */
  117.     public String getActualDataNodesByCatalog(ShardingTableEnum logicTable){
  118.         String redisKey = RedisPrefixEnum.CAR_PARK_ID_CATALOG.getValue();
  119.         //获取所有的停车场
  120.         Set<Object> keys = redisTemplate.opsForHash().keys(redisKey);
  121.         if (keys.isEmpty()){
  122.             return null;
  123.         }
  124.         StringBuilder sb = new StringBuilder();
  125.         keys.forEach(obj -> {
  126.             sb.append(defaultDataSource).append(".").append(logicTable.getValue()).append("_").append(obj.toString()).append(",");
  127.         });
  128.         sb.deleteCharAt(sb.length() - 1);
  129.         return sb.toString();
  130.     }
  132.     /**
  133.      * 获取druid数据库链接
  134.      * @param
  135.      * @throws
  136.      * @return com.alibaba.druid.pool.DruidDataSource
  137.      * @author zhy
  138.      * @date 2020/5/7 10:29
  139.      */
  140.     private DruidDataSource druidDataSource() {
  141.         DruidDataSource dataSource = new DruidDataSource();
  142.         dataSource.setDriverClassName(properties.getDriverClassName());
  143.         dataSource.setUrl(properties.getUrl());
  144.         dataSource.setUsername(properties.getUsername());
  145.         dataSource.setPassword(properties.getPassword());
  146.         dataSource.setInitialSize(properties.getInitialSize());
  147.         dataSource.setMinIdle(properties.getMinIdle());
  148.         dataSource.setMaxActive(properties.getMaxActive());
  149.         dataSource.setMaxWait(properties.getMaxWait());
  150.         dataSource.setTimeBetweenEvictionRunsMillis(properties.getTimeBetweenEvictionRunsMillis());
  151.         dataSource.setMinEvictableIdleTimeMillis(properties.getMinEvictableIdleTimeMillis());
  152.         String validationQuery = properties.getValidationQuery();
  153.         if (validationQuery != null && !"".equals(validationQuery)) {
  154.             dataSource.setValidationQuery(validationQuery);
  155.         }
  156.         dataSource.setTestWhileIdle(properties.isTestWhileIdle());
  157.         dataSource.setTestOnBorrow(properties.isTestOnBorrow());
  158.         dataSource.setTestOnReturn(properties.isTestOnReturn());
  159.         if (properties.isPoolPreparedStatements()) {
  160.             dataSource.setMaxPoolPreparedStatementPerConnectionSize(properties.getMaxPoolPreparedStatementPerConnectionSize());
  161.         }
  162.         String connectionPropertiesStr = properties.getConnectionProperties();
  163.         if (connectionPropertiesStr != null && !"".equals(connectionPropertiesStr)) {
  164.             Properties connectProperties = new Properties();
  165.             String[] propertiesList = connectionPropertiesStr.split(";");
  166.             for (String propertiesTmp : propertiesList) {
  167.                 String[] obj = propertiesTmp.split("=");
  168.                 String key = obj[0];
  169.                 String value = obj[1];
  170.                 connectProperties.put(key, value);
  171.             }
  172.             dataSource.setConnectProperties(connectProperties);
  173.         }
  174.         dataSource.setUseGlobalDataSourceStat(properties.isUseGlobalDataSourceStat());
  175.         WallConfig wallConfig = new WallConfig();
  176.         wallConfig.setMultiStatementAllow(true);
  177.         WallFilter wallFilter = new WallFilter();
  178.         wallFilter.setConfig(wallConfig);
  179.         //打开日志记录过滤器，可通过log4j2,记录sql   application.yml中配置【logging:config: classpath:logConfig/log4j2.xml】
  180.         Slf4jLogFilter slf4jLogFilter = new Slf4jLogFilter();
  181.         slf4jLogFilter.setStatementCreateAfterLogEnabled(false);
  182.         slf4jLogFilter.setStatementCloseAfterLogEnabled(false);
  183.         slf4jLogFilter.setResultSetOpenAfterLogEnabled(false);
  184.         slf4jLogFilter.setResultSetCloseAfterLogEnabled(false);
  185.         List<Filter> filters = new ArrayList<>();
  186.         filters.add(wallFilter);
  187.         filters.add(new StatFilter());
  188.         filters.add(slf4jLogFilter);
  190.         dataSource.setProxyFilters(filters);
  191.         return dataSource;
  192.     }
  193. }

动态替换的shardingService

  1. package com.example.demo.config.shardingconfig;
  3. import com.example.demo.config.datasource.DataSourceProperties;
  4. import com.example.demo.config.redis.RedisConfig;
  5. import com.example.demo.config.redis.RedisPrefixEnum;
  6. import org.apache.shardingsphere.orchestration.reg.listener.DataChangedEvent;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.boot.autoconfigure.AutoConfigureAfter;
  9. import org.springframework.data.redis.core.RedisTemplate;
  10. import org.springframework.stereotype.Component;
  12. import java.util.ArrayList;
  13. import java.util.Set;
  15. /**
  16.  * @title: ShardingService
  17.  * @projectName shardingJavaDemo
  18.  * @description: TODO
  19.  * @author zhy
  20.  * @date 2020/5/1115:08
  21.  */
  22. @Component
  23. @AutoConfigureAfter({RedisConfig.class})
  24. public class ShardingService {
  26.     @Autowired
  27.     private RedisTemplate<String,Object> redisTemplate;
  29.     @Autowired
  30.     private ShardingRuleConfig shardingRuleConfig;
  32.     /**
  33.       * 替换sharding里的分表规则ActualDataNodes的值
  34.       * @param oldRule
  35.       * @param newRule
  36.       * @throws
  37.       * @return void
  38.       * @author zhy
  39.       * @date 2020/5/11 15:12
  40.       */
  41.     public void replaceActualDataNodes(String oldRule,String newRule){
  42.         // 获取已有的配置
  43.         String rules = LocalRegistryCenter.values
  44.                 .get("/orchestration-sharding-data-source/config/schema/logic_db/rule");
  45.         // 修改规则
  46.         String rule = rules.replace(oldRule, newRule);
  47.         LocalRegistryCenter.listeners.get("/orchestration-sharding-data-source/config/schema")
  48.                 .onChange(new DataChangedEvent(
  49.                         "/orchestration-sharding-data-source/config/schema/logic_db/rule",
  50.                         rule, DataChangedEvent.ChangedType.UPDATED));
  51.         LocalRegistryCenter.values.put("/orchestration-sharding-data-source/config/schema/logic_db/rule",rule);
  52.     }
  54.     /**
  55.       * 获取当前的分表规则
  56.       * @param shardingTableEnum
  57.       * @throws
  58.       * @return java.lang.String
  59.       * @author zhy
  60.       * @date 2020/5/11 15:56
  61.       */
  62.     public String getActualDataNodesInRedis(ShardingTableEnum shardingTableEnum){
  63.         String redisKey = RedisPrefixEnum.SHARDING_RULE_ORDER.getValue();
  64.         //倒序获取一条最新的纪录
  65.         Set<Object> objects = redisTemplate.opsForZSet().reverseRange(redisKey, 0, 1);
  66.         return new ArrayList<>(objects).get(0).toString();
  67.     }
  69.     /**
  70.       * 根据redis中存储的停车场id获取分表规则
  71.       * @param shardingTableEnum
  72.       * @throws
  73.       * @return java.lang.String
  74.       * @author zhy
  75.       * @date 2020/5/11 16:09
  76.       */
  77.     public String getActualDataNodesByCatalog(ShardingTableEnum shardingTableEnum){
  78.         return shardingRuleConfig.getActualDataNodesByCatalog(shardingTableEnum);
  79.     }
  80. }

最后贴上源码

https://github.com/zhyhuayong/shardingJavaDemo
大家可以参考源码，要测试的同学记得修改自己的数据库配置哦