Shardingjdbc学习

最新推荐文章于 2024-09-22 21:58:06 发布

Filwaod

最新推荐文章于 2024-09-22 21:58:06 发布

阅读量484

点赞数

分类专栏： shardingjdbc 文章标签： sharding-jdbc spring boot mysql

本文链接：https://blog.csdn.net/qq_42665745/article/details/127067698

版权

shardingjdbc 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

一、单机（腾讯云）安装多实例mysql并配置主从复制
二、彻底搞清分库分表（垂直分库，垂直分表，水平分库，水平分表）
三、分库分表的一些概念
四、分库分表的案例
五、分库分表的面试题

一、单机（腾讯云）安装多实例mysql并配置主从复制

参考：https://blog.csdn.net/qq_20607405/article/details/123868479

在这里插入图片描述

二、彻底搞清分库分表（垂直分库，垂直分表，水平分库，水平分表）

参考：https://blog.csdn.net/u014453898/article/details/113177855

1.垂直分表

分库分表包括分库和分表两个部分，在生产中通常包括：垂直分库、水平分库、垂直分表、水平分表四种方式。
先说垂直分表：
通常在商品列表中是不显示商品详情信息的，如下图：
在这里插入图片描述
用户在浏览商品列表时，只有对某商品感兴趣时才会查看该商品的详细描述。因此，商品信息中商品描述字段访问频次较低，且该字段存储占用空间较大，访问单个数据IO时间较长；商品信息中商品名称、商品图片、商品价格等其他字段数据访问频次较高。

由于这两种数据的特性不一样，因此他考虑将商品信息表拆分如下：

将访问频次低的商品描述信息单独存放在一张表中，访问频次较高的商品基本信息单独放在一张表中。
在这里插入图片描述
垂直分表的优缺点：

如果一个表中某些列常用，而另外一些列不常用，则可以采用垂直分表，另外垂直分表可以使得数据行变小，一个数据页就能存放更多的数据，在查询时就会减少I/O次数。其缺点是需要管理冗余列，查询所有数据需要join操作

为什么大字段IO效率低：

第一是由于数据量本身大，需要更长的读取时间；

第二是跨页，页是数据库存储单位，很多查找及定位操作都是以页为单位，单页内的数据行越多数据库整体性能越好，而大字段占用空间大，单页内存储行数少，因此IO效率较低。

第三，数据库以行为单位将数据加载到内存中，这样表中字段长度较短且访问频率较高，内存能加载更多的数据，命中率更高，减少了磁盘IO，从而提升了数据库性能。

通常我们按以下原则进行垂直拆分:

把不常用的字段单独放在一张表;
把text，blob等大字段拆分出来放在附表中;
经常组合查询的列放在一张表中;

2.垂直分库

通过垂直分表性能得到了一定程度的提升，但是还没有达到要求，并且磁盘空间也快不够了，因为数据还是始终限制在一台服务器，库内垂直分表只解决了单一表数据量过大的问题，但没有将表分布到不同的服务器上，因此每个表还是竞争同一个物理机的CPU、内存、网络IO、磁盘。

经过思考，他把原有的SELLER_DB(卖家库)，分为了PRODUCT_DB(商品库)和STORE_DB(店铺库)，并把这两个库分散到不同服务器，如下图：
在这里插入图片描述
由于商品信息与商品描述业务耦合度较高，因此一起被存放在PRODUCT_DB(商品库)；而店铺信息相对独立，因此单独被存放在STORE_DB(店铺库)。

垂直分库是指按照业务将表进行分类，分布到不同的数据库上面，每个库可以放在不同的服务器上，它的核心理念是专库专用。

它带来的提升是：

解决业务层面的耦合，业务清晰

能对不同业务的数据进行分级管理、维护、监控、扩展等

高并发场景下，垂直分库一定程度的提升IO、数据库连接数、降低单机硬件资源的瓶颈

垂直分库通过将表按业务分类，然后分布在不同数据库，并且可以将这些数据库部署在不同服务器上，从而达到多个服务器共同分摊压力的效果，但是依然没有解决单表数据量过大的问题。

3.水平分库

经过垂直分库后，数据库性能问题得到一定程度的解决，但是随着业务量的增长，PRODUCT_DB(商品库)单库存储数据已经超出预估。粗略估计，目前有8w店铺，每个店铺平均150个不同规格的商品，再算上增长，那商品数量得往1500w+上预估，并且PRODUCT_DB(商品库)属于访问非常频繁的资源，单台服务器已经无法支撑。此时该如何优化？

再次分库？但是从业务角度分析，目前情况已经无法再次垂直分库。

尝试水平分库，将ID为单数的和ID为双数的商品信息分别放在两个库中。
在这里插入图片描述
水平分库是把同一个表的数据按一定规则拆到不同的数据库中，每个库可以放在不同的服务器上。
垂直分库是把不同表拆到不同数据库中，它是对数据行的拆分，不影响表结构。

当一个应用难以再细粒度的垂直切分，或切分后数据量行数巨大，存在单库读写、存储性能瓶颈，这时候就需要进行水平分库了，经过水平切分的优化，往往能解决单库存储量及性能瓶颈。但由于同一个表被分配在不同的数据库，需要额外进行数据操作的路由工作，因此大大提升了系统复杂度。

4.水平分表

按照水平分库的思路对他把PRODUCT_DB_X(商品库)内的表也可以进行水平拆分，其目的也是为解决单表数据量大的问题，如下图：
在这里插入图片描述

与水平分库的思路类似，不过这次操作的目标是表，商品信息及商品描述被分成了两套表。如果商品ID为双数，将此操作映射至商品信息1表；如果商品ID为单数，将操作映射至商品信息2表。此操作要访问表名称的表达式为商品信息[商品ID%2 + 1] 。

库内的水平分表，解决了单一表数据量过大的问题，分出来的小表中只包含一部分数据，从而使得单个表的数据量变小，提高检索性能

5.总结:

垂直分表：可以把一个宽表的字段按访问频次、是否是大字段的原则拆分为多个表，这样既能使业务清晰，还能提升部分性能。拆分后，尽量从业务角度避免联查，否则性能方面将得不偿失。

垂直分库：可以把多个表按业务耦合松紧归类，分别存放在不同的库，这些库可以分布在不同服务器，从而使访问压力被多服务器负载，大大提升性能，同时能提高整体架构的业务清晰度，不同的业务库可根据自身情况定制优化方案。但是它需要解决跨库带来的所有复杂问题。

水平分库：可以把一个表的数据(按数据行)分到多个不同的库，每个库只有这个表的部分数据，这些库可以分布在不同服务器，从而使访问压力被多服务器负载，大大提升性能。它不仅需要解决跨库带来的所有复杂问题，还要解决数据路由的问题。

水平分表：可以把一个表的数据(按数据行)分到多个同一个数据库的多张表中，每个表只有这个表的部分数据，这样做能小幅提升性能，它仅仅作为水平分库的一个补充优化。

一般来说，在系统设计阶段就应该根据业务耦合松紧来确定垂直分库，垂直分表方案，在数据量及访问压力不是特别大的情况，首先考虑缓存、读写分离、索引技术等方案。若数据量极大，且持续增长，再考虑水平分库水平分表方案。

6.分库分表可能遇到的问题

参考：
1.https://www.infoq.cn/article/key-steps-and-likely-problems-of-split-table
2.https://mp.weixin.qq.com/s?__biz=MzAxNTM4NzAyNg==&mid=2247487915&idx=1&sn=1382d40fd27536ad4fbb1e30d1a5433c&scene=21#wechat_redirect

三、分库分表的一些概念

参考：https://mp.weixin.qq.com/s?__biz=MzAxNTM4NzAyNg==&mid=2247488500&idx=1&sn=108bf704a54b0a9638e84698deb3ce4c&chksm=9b858309acf20a1fc606f6d140e9638072405011829bb8decc906a648d3f2f75441c0adac869&token=1691474648&lang=zh_CN#rd

里面的概念挺全的！！！

四、分库分表的案例

参考：https://blog.csdn.net/qq_38225558/article/details/121087197

application.yml

server:
  port: 80

spring:
  application:
    name: demo

  # sharding-jdbc配置
  shardingsphere:
    # 是否开启SQL显示
    props:
      sql:
        show: true
    # ====================== ↓↓↓↓↓↓ 数据源配置 ↓↓↓↓↓↓ ======================
    datasource:
      names: ds-master-0,ds-slave-0-1,ds-master-1,ds-slave-1-1
      # ====================== ↓↓↓↓↓↓ 配置第1个主从库 ↓↓↓↓↓↓ ======================
      # 主库1
      ds-master-0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://81.69.26.22:3306/ds0?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false # MySQL在高版本需要指明是否进行SSL连接 解决则加上 &useSSL=false
        username: root
        password: 123456
      # 主库1-从库1
      ds-slave-0-1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://81.69.26.22:3308/ds0?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false # MySQL在高版本需要指明是否进行SSL连接 解决则加上 &useSSL=false
        username: root
        password: 123456
      # ====================== ↓↓↓↓↓↓ 配置第2个主从库 ↓↓↓↓↓↓ ======================
      # 主库2
      ds-master-1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://81.69.26.22:3306/ds1?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false # MySQL在高版本需要指明是否进行SSL连接 解决则加上 &useSSL=false
        username: root
        password: 123456
      # 主库2-从库1
      ds-slave-1-1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://81.69.26.22:3308/ds1?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false # MySQL在高版本需要指明是否进行SSL连接 解决则加上 &useSSL=false
        username: root
        password: 123456

    sharding:
      #绑定表
      #      binding-tables: t_order,t_order_item
      #广播表
      #      broadcast-tables: t_config
      # ====================== ↓↓↓↓↓↓ 读写分离配置 ↓↓↓↓↓↓ ======================
      master-slave-rules:
        ds-master-0:
          # 主库
          master-data-source-name: ds-master-0
          # 从库
          slave-data-source-names: ds-slave-0-1
          # 从库查询数据的负载均衡算法 目前有2种算法 round_robin（轮询）和 random（随机）
          # 算法接口 org.apache.shardingsphere.spi.masterslave.MasterSlaveLoadBalanceAlgorithm
          # 实现类 RandomMasterSlaveLoadBalanceAlgorithm 和 RoundRobinMasterSlaveLoadBalanceAlgorithm
          load-balance-algorithm-type: ROUND_ROBIN
        ds-master-1:
          master-data-source-name: ds-master-1
          slave-data-source-names: ds-slave-1-1
          load-balance-algorithm-type: ROUND_ROBIN

      # ====================== ↓↓↓↓↓↓ 分库分表配置 ↓↓↓↓↓↓ ======================
      tables:
        t_user:
          actual-data-nodes: ds-master-$->{0..1}.t_user$->{0..1}

            # 配置属性可参考 org.apache.shardingsphere.core.yaml.config.sharding.YamlShardingStrategyConfiguration

            # =========== ↓↓↓↓↓↓ 行表达式分片策略 ↓↓↓↓↓↓ ===========
            # 在配置中使用 Groovy 表达式，提供对 SQL语句中的 = 和 IN 的分片操作支持，只支持单分片健。

          # ====== ↓↓↓↓↓↓ 分库 ↓↓↓↓↓↓ ======
          database-strategy:
            inline:
              sharding-column: user_id # 添加数据分库字段(根据字段插入数据到哪个库 ex：user_id)
              algorithm-expression: ds-master-$->{user_id % 2} # 根据user_id取模拆分到不同的库中
            # ====== ↓↓↓↓↓↓ 分表 ↓↓↓↓↓↓ ======
          table-strategy:
            inline:
              sharding-column: sex   # 添加数据分表字段(根据字段插入数据到哪个表 ex：sex)
              algorithm-expression: t_user$->{sex % 2} # 分片算法表达式 => 根据用户性别取模拆分到不同的表中

          # =========== ↓↓↓↓↓↓ 标准分片策略 ↓↓↓↓↓↓ ===========

          # 精确分片算法 => sql在分库/分表键上执行 = 与 IN 时触发计算逻辑，否则不走分库/分表，全库/全表执行。
          #          database-strategy:
          #            standard:
          #              sharding-column: user_id # 分库用到的键
          #              precise-algorithm-class-name: com.zhengqing.demo.config.sharding.precise.MyDbPreciseShardingAlgorithm # 自定义分库算法实现类
          #          table-strategy:
          #            standard:
          #              sharding-column: sex # 添加数据分表字段(根据字段插入数据到那个表 ex：sex)
          #              precise-algorithm-class-name: com.zhengqing.demo.config.sharding.precise.MyTablePreciseShardingAlgorithm # 自定义分表算法实现类

          # 范围分片算法 => sql在分库/分表键上执行 BETWEEN AND、>、<、>=、<= 时触发计算逻辑，否则不走分库/分表，全库/全表执行。
          #          database-strategy:
          #            standard:
          #              sharding-column: user_id
          #              precise-algorithm-class-name: com.zhengqing.demo.config.sharding.range.MyDbPreciseShardingAlgorithm
          #              range-algorithm-class-name: com.zhengqing.demo.config.sharding.range.MyDbRangeShardingAlgorithm
          #          table-strategy:
          #            standard:
          #              sharding-column: sex
          #              precise-algorithm-class-name: com.zhengqing.demo.config.sharding.range.MyTablePreciseShardingAlgorithm
          #              range-algorithm-class-name: com.zhengqing.demo.config.sharding.range.MyTableRangeShardingAlgorithm

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

          #          database-strategy:
          #            complex:
          #              sharding-columns: user_id,sex
          #              algorithm-class-name: com.zhengqing.demo.config.sharding.complex.MyDbComplexKeysShardingAlgorithm
          #          table-strategy:
          #            complex:
          #              sharding-columns: user_id,sex
          #              algorithm-class-name: com.zhengqing.demo.config.sharding.complex.MyTableComplexKeysShardingAlgorithm

          # =========== ↓↓↓↓↓↓ hint分片策略 ↓↓↓↓↓↓ ===========
          # 通过 Hint API实现个性化配置 => 可查看 com.zhengqing.demo.service.impl.UserServiceImpl.listPageForHint

#          database-strategy:
#            hint:
#              algorithm-class-name: com.zhengqing.demo.config.sharding.hint.MyDbHintShardingAlgorithm
#          table-strategy:
#            hint:
#              algorithm-class-name: com.zhengqing.demo.config.sharding.hint.MyTableHintShardingAlgorithm

里面的代码都可以运行，但只是例子，没有实际场景，还是有点不理解

补充公司中实际使用的java配置形式：

配置文件：application.yml

server:
  port: 80

spring:
  application:
    name: demo
  datasource:
    type: com.zaxxer.hikari.HikariDataSource

db:
  driver: com.mysql.jdbc.Driver
  0:
    url: jdbc:mysql://127.0.0.1:3306/ds0?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false
    username: root
    password: 123456

  1:
    url: jdbc:mysql://127.0.0.1:3306/ds1?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false
    username: root
    password: 123456

shardingJdbc.conf

{
    "bindingTables": [
        "t_order,t_order_item"
    ],
    "broadcastTables": [
        "t_config"
    ],
    "shardingAlgorithm": [
            {
                "logicTable": "t_user",
                "actualDataNodes": "ds$->{0..1}.t_user$->{0..1}",
                "db": {
                    "column": "user_id",
                    "algorithm": "ds$->{user_id % 2}"
                },
                "table": {
                    "column": "sex",
                    "algorithm": "t_user$->{sex % 2}"
                },
                "primaryKey":{
                    "column":"user_id",
                    "type":"SNOWFLAKE"
                }
            },
            {
                "logicTable": "t_order",
                "actualDataNodes": "ds0.t_order_$->{0..1}",
                "table": {
                    "column": "order_id",
                    "algorithm": "t_order_->{order_id % 2}"
                },
                "primaryKey":{
                    "column":"order_id",
                    "type":"SNOWFLAKE"
                }
            },
            {
                "logicTable": "t_order_item",
                "actualDataNodes": "ds0.t_order_item_$->{0..1}",
                "table": {
                    "column": "order_id",
                    "algorithm": "t_order_item_->{order_id % 2}"
                },
                "primaryKey":{
                    "column":"item_id",
                    "type":"SNOWFLAKE"
                }
            }
    ]
}

PropertiesConfig

@Slf4j
public class PropertiesConfig {
    public static String getShardingJdbcConfig() {
        InputStream is = PropertiesConfig.class.getClassLoader().getResourceAsStream("shardingJdbc.conf");
        try {
            byte[] buf = new byte[1024];
            int length = 0;
            StringBuffer sb = new StringBuffer();
            while ((length = is.read(buf)) != -1) {
                sb.append(new String(buf, 0, length));
            }
            is.close();
            return sb.toString();
        } catch (IOException e) {
            log.error("读取分库分表数据异常");
        }
        throw new NullPointerException();
    }
}

DataSourceConfig

@Slf4j
@Configuration
@EnableTransactionManagement
public class DataSourceConfig {
    @Value("${db.driver}")
    private String driver;

    @Value("${db.0.url}")
    private String url0;

    @Value("${db.0.username}")
    private String userName0;

    @Value("${db.0.password}")
    private String passWord0;

    @Value("${db.1.url}")
    private String url1;

    @Value("${db.1.username}")
    private String userName1;

    @Value("${db.1.password}")
    private String passWord1;

    private final String LOGIC_TABLE = "logicTable";
    private final String ACTUAL_DATA_NODES = "actualDataNodes";
    private final String DB = "db";
    private final String TABLE = "table";
    private final String COLUMN = "column";
    private final String ALGORITHM = "algorithm";
    private final String PRIMARY_KEY = "primaryKey";
    private final String TYPE = "type";

    @Bean
    public DataSourceTransactionManager transactionManager(
            @Qualifier("buildDataSource") DataSource dataSource
    ) {
        log.info("加载数据库连接");
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(
            @Qualifier("mybatisPlusInterceptor") MybatisPlusInterceptor mybatisPlusInterceptor
//            ,CustomMetaObjectHandler customMetaObjectHandler
    ) throws Exception {
        MybatisSqlSessionFactoryBean sessionFactoryBean = new MybatisSqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(buildDataSource());
        sessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:**/*Mapper.xml"));
        sessionFactoryBean.setPlugins(mybatisPlusInterceptor);
//        GlobalConfig globalConfig = new GlobalConfig();
//        globalConfig.setMetaObjectHandler(customMetaObjectHandler);
//        sessionFactoryBean.setGlobalConfig(globalConfig);
        return sessionFactoryBean.getObject();
    }

    @Bean
    public DataSource buildDataSource() throws SQLException {
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        String shardingJdbcConfig = PropertiesConfig.getShardingJdbcConfig();
        JSONObject jsonObject = JSON.parseObject(shardingJdbcConfig);
        JSONArray bindingTables = JSON.parseArray(jsonObject.get("bindingTables").toString());
        shardingRuleConfig.setBindingTableGroups(bindingTables.toJavaList(String.class));
        JSONArray broadcastTables = JSON.parseArray(jsonObject.get("broadcastTables").toString());
        shardingRuleConfig.setBroadcastTables(broadcastTables.toJavaList(String.class));
        JSONArray shardingAlgorithm = JSON.parseArray(jsonObject.get("shardingAlgorithm").toString());
        int size = shardingAlgorithm.size();
        for (int i = 0; i < size; i++) {
            JSONObject jsonObj = JSON.parseObject(shardingAlgorithm.get(i).toString());
            String logicTable = jsonObj.getString(LOGIC_TABLE);
            String actualDataNodes = jsonObj.getString(ACTUAL_DATA_NODES);
            if (StringUtils.isBlank(logicTable)) {
                throw new NullPointerException();
            }
            if (StringUtils.isBlank(actualDataNodes)) {
                throw new NullPointerException();
            }
            TableRuleConfiguration tableRule = new TableRuleConfiguration(logicTable, actualDataNodes);
            if (jsonObj.containsKey(DB)) {
                JSONObject db = jsonObj.getJSONObject(DB);
                tableRule.setDatabaseShardingStrategyConfig(new InlineShardingStrategyConfiguration(db.getString(COLUMN), db.getString(ALGORITHM)));
            }
            if (jsonObj.containsKey(TABLE)) {
                JSONObject table = jsonObj.getJSONObject(TABLE);
                String tableField = table.getString(COLUMN);
                if ("year".equalsIgnoreCase(tableField)) {
                    tableRule.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration(tableField, new MyTablePreciseShardingAlgorithm()));
                } else {
                    tableRule.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration(tableField, table.getString(ALGORITHM)));
                }
            }
            if (jsonObj.containsKey(PRIMARY_KEY)) {
                JSONObject pk = jsonObj.getJSONObject(PRIMARY_KEY);
                Properties p = new Properties();
                p.setProperty("worker.id", System.getProperty("workerId"));
                tableRule.setKeyGeneratorConfig(new KeyGeneratorConfiguration(pk.getString(TYPE), pk.getString(COLUMN), p));
            }
            shardingRuleConfig.getTableRuleConfigs().add(tableRule);
        }
        Properties p = new Properties();
        p.setProperty("sql.show", "true");
        return ShardingDataSourceFactory.createDataSource(
                createDataSourceMap(),
                shardingRuleConfig,
                p
        );
    }

    private Map<String, DataSource> createDataSourceMap() {
        Map<String, DataSource> result = new LinkedHashMap<>(2);
        result.put("ds0", ds0());
        result.put("ds1", ds1());
        return result;
    }

    public DataSource ds0() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(url0);
        dataSource.setUsername(userName0);
        dataSource.setPassword(passWord0);
        dataSource.setDriverClassName(driver);
        return dataSource;
    }

    public DataSource ds1() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(url1);
        dataSource.setUsername(userName1);
        dataSource.setPassword(passWord1);
        dataSource.setDriverClassName(driver);
        return dataSource;
    }

//    public DataSource ds0() {
//        DruidDataSource dataSource = new DruidDataSource();
//        dataSource.setUrl(url0);
//        dataSource.setUsername(userName0);
//        dataSource.setPassword(passWord0);
//        dataSource.setDriverClassName(driver);
//        dataSource.setMinIdle(10);
//        dataSource.setMaxActive(30);
//        dataSource.setInitialSize(5);
//        dataSource.setMaxWait(60000);
//        dataSource.setMinEvictableIdleTimeMillis(300000);
//        dataSource.setTimeBetweenEvictionRunsMillis(60000);
//        dataSource.setValidationQuery("SELECT 1");
//        dataSource.setTestOnBorrow(true);
//        dataSource.setTestWhileIdle(true);
//        dataSource.setPoolPreparedStatements(false);
//        dataSource.setTestOnReturn(false);
//        dataSource.setMaxPoolPreparedStatementPerConnectionSize(20);
//        return dataSource;
//    }
}

SnowFlakeWordIdConfig

@Configuration
@Slf4j
public class SnowFlakeWordIdConfig {
    static {
        try {
            InetAddress ip4 = Inet4Address.getLocalHost();
            String addressIp = ip4.getHostAddress();
            String workerId = Math.abs(addressIp.hashCode()) % 1024 + "";
            System.setProperty("workerId", workerId);
            log.info("workerId======》:{}", workerId);
        } catch (UnknownHostException e) {
        }
    }
}