• sharding-jdbc实现分库分表

    一、ShardingSphere介绍

    　　ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。 他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、云原生等各种多样化的应用场景。详细一点的介绍直接看官网：概览 :: ShardingSphere

    二、关于分库分表的思考

    1、分库分表为了什么？

    分库分表就是为了解决由于数据量过大而导致数据库性能（IO瓶颈，CPU瓶颈）降低的问题，将原来独立的数据库拆分成若干数据库组成 ，将数据大表拆分成若干数据表组成，使得单一数据库、单一数据表的数据量变小，从而达到提升数据库性能的目的。

    2、数据库的分区、垂直分库、垂直分表、水平分库、水平分表各自解决那些问题？

    • 分区表

      • 分区表的分区方式有range、list、hash、key四种方式，但常用的是range、list方式
      • 分区表可以单独对分区数据进行操作，在特定的场景下，方便对数据的老化和查询
      • 分区表可以提高单表的存储，并且数据还可以分布在不同的物理设备上

    • 垂直分库

      • 解决业务层面的耦合，业务清晰
      • 能对不同业务的数据进行分级管理、维护、监控、扩展等
      • 高并发场景下，垂直分库一定程度的提升IO、数据库连接数、降低单机硬件资源的瓶颈

    • 垂直分表（将一张表拆成多张表）

      • 为了避免IO争抢并减少锁表的几率
      • 充分发挥热数据的操作效率
      • 可以把不常用的字段单独放在一张表，如一些详细信息以及text，blob等大字段

    • 水平分库

      • 解决了单库大数据，高并发的性能瓶颈
      • 提高了系统的稳定性及可用性

    • 水平分表

      • 优化单一表数据量过大而产生的性能问题
      • 避免IO争抢并减少锁表的几率

    3、分库分表的策略一般在什么情况下使用，使用哪种？

    • 首先一般来说，在系统设计阶段就应该根据业务耦合松紧来确定垂直分库、垂直分表的方案。
    • 当数据量随着业务凉的提升不断增大，但访问压力还不是特别大的情况下，我们首先考虑缓存、读写分离、索引等技术方案。
    • 当数据量增长到特别大且持续增长时，即将或者已经出现性能瓶颈时，再考虑水平分库水平分表的方案。

    4、水平分库表如何解决扩容、热点问题？

    • 最好的方式莫过于设计前期对数据量的正确预估和业务场景的判断，尽量避免后期出现热点问题和扩容问题。
    • 对于通过hash取模方案，没有热点问题，但会出现扩容问题，解决方案有：
      • 停服迁移
      • 升级从库
      • 双写迁移
    • 对于通过range方案，无需迁移数据，但肯能出现热点问题。所以在实际业务中，我们可以通过range+hash的配合使用来达到即支持扩容又尽可能避免热点。

    5、分库分表如何解决跨库事务？

    • 2PC两阶段提交协议
    • TCC事务补偿机制
    • 最终一致性方案
    • 最大努力通知型

    三、Springboot整合ShardingJDBC

    方式一：基于配置文件集成，方便简单但是不够灵活，代码：https://github.com/xianlongbai/sharding-jdbc-boot-demo

    方式二：这里我们主要基于java config的方式来集成到springboot

    1、pom.xml模块添加sharding-jdbc整合依赖

    1.   
    2.         
    3.             org.springframework.boot
    4.             spring-boot-starter-web
    5.         
    6.         
    7.             org.mybatis.spring.boot
    8.             mybatis-spring-boot-starter
    9.             2.2.2
    10.         
    11.         
    12.             org.springframework.boot
    13.             spring-boot-starter-aop
    14.         
    15.         
    16.             org.springframework.boot
    17.             spring-boot-starter-test
    18.         
    19.  
    20.         
    21.             junit
    22.             junit
    23.             4.13.1
    24.         
    25.  
    26.         
    27.         
    28.             javax.servlet
    29.             javax.servlet-api
    30.         
    31.         
    32.         
    33.             org.apache.commons
    34.             commons-lang3
    35.         
    36.  
    37.         
    38.             com.alibaba.fastjson2
    39.             fastjson2
    40.             2.0.10
    41.         
    42.         
    43.             org.projectlombok
    44.             lombok
    45.             1.18.8
    46.         
    47.         
    48.             mysql
    49.             mysql-connector-java
    50.             runtime
    51.         
    52.  
    53.         
    54.             org.springframework.boot
    55.             spring-boot-starter-test
    56.             test
    57.         
    58.         
    59.         
    60.             com.alibaba
    61.             druid-spring-boot-starter
    62.             1.2.4
    63.         
    64.  
    65.         
    66.         
    67.             org.apache.shardingsphere
    68.             sharding-jdbc-core
    69.             4.1.1
    70.         
    71.  
    72.         
    73.         
    74.         
    75.         
    76.         
    77.         
    78.  
    79.  
    80.

    2、创建两个测试数据库

    1. create database `ry-order1`;
    2. create database `ry-order2`;

    3、创建两个测试订单表

    1. -- ----------------------------
    2. -- 订单信息表sys_order_0
    3. -- ----------------------------
    4. drop table if exists sys_order_0;
    5. create table sys_order_0
    6. (
    7.   order_id      bigint(20)      not null                   comment '订单ID',
    8.   user_id       bigint(64)      not null                   comment '用户编号',
    9.   status        char(1)         not null                   comment '状态（0交易成功 1交易失败）',
    10.   order_no      varchar(64)     default null               comment '订单流水',
    11.   primary key (order_id)
    12. ) engine=innodb comment = '订单信息表';
    13.  
    14. -- ----------------------------
    15. -- 订单信息表sys_order_1
    16. -- ----------------------------
    17. drop table if exists sys_order_1;
    18. create table sys_order_1
    19. (
    20.   order_id      bigint(20)      not null                   comment '订单ID',
    21.   user_id       bigint(64)      not null                   comment '用户编号',
    22.   status        char(1)         not null                   comment '状态（0交易成功 1交易失败）',
    23.   order_no      varchar(64)     default null               comment '订单流水',
    24.   primary key (order_id)
    25. ) engine=innodb comment = '订单信息表';

    4、配置文件application-druid.yml添加测试数据源

    application.yml文件

    1. server:
    2.   # 服务器的HTTP端口，默认为80
    3.   port: 8080
    4.   servlet:
    5.     # 应用的访问路径
    6.     context-path: /
    7.  
    8. # Spring配置
    9. spring:
    10.   #加载application-druid.yml文件
    11.   profiles:
    12.     active: druid
    13.  
    14. # MyBatis
    15. mybatis:
    16.     # 搜索指定包别名
    17.     typeAliasesPackage: com.common.pojo
    18.     # 配置mapper的扫描，找到所有的mapper.xml映射文件
    19.     mapperLocations: classpath*:mapper/**/*Mapper.xml
    20.     # 加载全局的配置文件
    21. #    #configLocation: classpath:mybatis/mybatis-config.xml

    application-druid.yml文件

    1. # 数据源配置
    2. spring:
    3.   datasource:
    4.     type: com.alibaba.druid.pool.DruidDataSource
    5.     driverClassName: com.mysql.cj.jdbc.Driver
    6.     druid:
    7.       # 主库数据源
    8.       master:
    9.         url: jdbc:mysql://localhost:3306/ry?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    10.         username: root
    11.         password: 123456
    12.       # 订单库1
    13.       order1:
    14.         enabled: true
    15.         url: jdbc:mysql://localhost:3306/ry-order1?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    16.         username: root
    17.         password: 123456
    18.       # 订单库2
    19.       order2:
    20.         enabled: true
    21.         url: jdbc:mysql://localhost:3306/ry-order2?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    22.         username: root
    23.         password: 123456
    24.       # 初始连接数
    25.       initialSize: 5
    26.       # 最小连接池数量
    27.       minIdle: 10
    28.       # 最大连接池数量
    29.       maxActive: 20
    30.       # 配置获取连接等待超时的时间
    31.       maxWait: 60000
    32.       # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    33.       timeBetweenEvictionRunsMillis: 60000
    34.       # 配置一个连接在池中最小生存的时间，单位是毫秒
    35.       minEvictableIdleTimeMillis: 300000
    36.       # 配置一个连接在池中最大生存的时间，单位是毫秒
    37.       maxEvictableIdleTimeMillis: 900000
    38.       # 配置检测连接是否有效
    39.       validationQuery: SELECT 1 FROM DUAL
    40.       testWhileIdle: true
    41.       testOnBorrow: false
    42.       testOnReturn: false
    43.       webStatFilter:
    44.         enabled: true
    45.       statViewServlet:
    46.         enabled: true
    47.         # 设置白名单，不填则允许所有访问
    48.         allow:
    49.         url-pattern: /druid/*
    50.         # 控制台管理用户名和密码
    51.         login-username: admin
    52.         login-password: 123456
    53.       filter:
    54.         stat:
    55.           enabled: true
    56.           # 慢SQL记录
    57.           log-slow-sql: true
    58.           slow-sql-millis: 1000
    59.           merge-sql: true
    60.         wall:
    61.           config:
    62.             multi-statement-allow: true

    5、数据源切换处理

    1.  
    2. import org.slf4j.Logger;
    3. import org.slf4j.LoggerFactory;
    4.  
    5. /**
    6.  * 数据源切换处理
    7.  */
    8. public class DynamicDataSourceContextHolder {
    9.  
    10.     public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);
    11.  
    12.     /**
    13.      * 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
    14.      * 所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
    15.      */
    16.     private static final ThreadLocal CONTEXT_HOLDER = new ThreadLocal<>();
    17.  
    18.     /**
    19.      * 设置数据源的变量
    20.      */
    21.     public static void setDataSourceType(String dsType) {
    22.         log.info("切换到{}数据源", dsType);
    23.         CONTEXT_HOLDER.set(dsType);
    24.     }
    25.  
    26.     /**
    27.      * 获得数据源的变量
    28.      */
    29.     public static String getDataSourceType() {
    30.         return CONTEXT_HOLDER.get();
    31.     }
    32.  
    33.     /**
    34.      * 清空数据源变量
    35.      */
    36.     public static void clearDataSourceType() {
    37.         CONTEXT_HOLDER.remove();
    38.     }
    39. }

    6、动态数据源切换

    通过AbstractRoutingDataSource实现数据源动态切换
    Springboot提供了AbstractRoutingDataSource 根据用户定义的规则选择当前的数据源，这样我们可以在执行查询之前，切换到需要的数据源。实现可动态路由的数据源，在每次数据库查询操作前执行。它的抽象方法 determineCurrentLookupKey() 决定使用哪个数据源。
     

    1. import com.common.utils.DynamicDataSourceContextHolder;
    2. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
    3.  
    4. import javax.sql.DataSource;
    5. import java.util.Map;
    6.  
    7. /**
    8.  * 动态数据源切换
    9.  */
    10. public class DynamicDataSource extends AbstractRoutingDataSource {
    11.  
    12.     public DynamicDataSource(DataSource defaultTargetDataSource, Map targetDataSources) {
    13.         super.setDefaultTargetDataSource(defaultTargetDataSource);
    14.         super.setTargetDataSources(targetDataSources);
    15.         super.afterPropertiesSet();
    16.     }
    17.  
    18.     @Override
    19.     protected Object determineCurrentLookupKey() {
    20.         return DynamicDataSourceContextHolder.getDataSourceType();
    21.     }
    22. }

    7、自定义数据源切换注解

    1. import com.common.enums.DataSourceType;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. /**
    6.  * 自定义多数据源切换注解
    7.  * 
    8.  * 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准
    9.  */
    10. @Target({ElementType.METHOD, ElementType.TYPE})
    11. @Retention(RetentionPolicy.RUNTIME)
    12. @Documented
    13. @Inherited
    14. public @interface DataSource {
    15.     /**
    16.      * 切换数据源名称
    17.      */
    18.     public DataSourceType value() default DataSourceType.MASTER;
    19. }
    1.  
    2. /**
    3.  * 数据源
    4.  *
    5.  */
    6. public enum DataSourceType {
    7.     /**
    8.      * 主库
    9.      */
    10.     MASTER,
    11.  
    12.     /**
    13.      * 从库
    14.      */
    15.     SLAVE,
    16.  
    17.     /**
    18.      * 分库分表
    19.      */
    20.     SHARDING
    21. }

    8、druid配置属性

    1.  
    2. /**
    3.  * druid 配置属性
    4.  */
    5. @Configuration
    6. public class DruidProperties {
    7.  
    8.     @Value("${spring.datasource.druid.initialSize}")
    9.     private int initialSize;
    10.  
    11.     @Value("${spring.datasource.druid.minIdle}")
    12.     private int minIdle;
    13.  
    14.     @Value("${spring.datasource.druid.maxActive}")
    15.     private int maxActive;
    16.  
    17.     @Value("${spring.datasource.druid.maxWait}")
    18.     private int maxWait;
    19.  
    20.     @Value("${spring.datasource.druid.timeBetweenEvictionRunsMillis}")
    21.     private int timeBetweenEvictionRunsMillis;
    22.  
    23.     @Value("${spring.datasource.druid.minEvictableIdleTimeMillis}")
    24.     private int minEvictableIdleTimeMillis;
    25.  
    26.     @Value("${spring.datasource.druid.maxEvictableIdleTimeMillis}")
    27.     private int maxEvictableIdleTimeMillis;
    28.  
    29.     @Value("${spring.datasource.druid.validationQuery}")
    30.     private String validationQuery;
    31.  
    32.     @Value("${spring.datasource.druid.testWhileIdle}")
    33.     private boolean testWhileIdle;
    34.  
    35.     @Value("${spring.datasource.druid.testOnBorrow}")
    36.     private boolean testOnBorrow;
    37.  
    38.     @Value("${spring.datasource.druid.testOnReturn}")
    39.     private boolean testOnReturn;
    40.  
    41.     public DruidDataSource dataSource(DruidDataSource datasource) {
    42.         /** 配置初始化大小、最小、最大 */
    43.         datasource.setInitialSize(initialSize);
    44.         datasource.setMaxActive(maxActive);
    45.         datasource.setMinIdle(minIdle);
    46.  
    47.         /** 配置获取连接等待超时的时间 */
    48.         datasource.setMaxWait(maxWait);
    49.  
    50.         /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
    51.         datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
    52.  
    53.         /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
    54.         datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
    55.         datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);
    56.  
    57.         /**
    58.          * 用来检测连接是否有效的sql，要求是一个查询语句，常用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
    59.          */
    60.         datasource.setValidationQuery(validationQuery);
    61.         /** 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 */
    62.         datasource.setTestWhileIdle(testWhileIdle);
    63.         /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
    64.         datasource.setTestOnBorrow(testOnBorrow);
    65.         /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
    66.         datasource.setTestOnReturn(testOnReturn);
    67.         return datasource;
    68.     }
    69. }

    9、多数据源配置

    1. import com.alibaba.druid.pool.DruidDataSource;
    2. import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
    3. import com.alibaba.druid.spring.boot.autoconfigure.properties.DruidStatProperties;
    4. import com.alibaba.druid.util.Utils;
    5. import com.common.config.properties.DruidProperties;
    6. import com.common.datasource.DynamicDataSource;
    7. import com.common.enums.DataSourceType;
    8. import com.common.utils.SpringUtils;
    9. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    10. import org.springframework.boot.context.properties.ConfigurationProperties;
    11. import org.springframework.boot.web.servlet.FilterRegistrationBean;
    12. import org.springframework.context.annotation.Bean;
    13. import org.springframework.context.annotation.Configuration;
    14. import org.springframework.context.annotation.Primary;
    15.  
    16. import javax.servlet.*;
    17. import javax.sql.DataSource;
    18. import java.io.IOException;
    19. import java.util.HashMap;
    20. import java.util.Map;
    21.  
    22. /**
    23.  * druid 配置多数据源
    24.  *
    25.  */
    26. @Configuration
    27. public class DruidConfig {
    28.  
    29.     @Bean
    30.     @ConfigurationProperties("spring.datasource.druid.master")
    31.     public DataSource masterDataSource(DruidProperties druidProperties) {
    32.         DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
    33.         return druidProperties.dataSource(dataSource);
    34.     }
    35.  
    36.     @Bean
    37.     @ConfigurationProperties("spring.datasource.druid.slave")
    38.     @ConditionalOnProperty(prefix = "spring.datasource.druid.slave", name = "enabled", havingValue = "true")
    39.     public DataSource slaveDataSource(DruidProperties druidProperties) {
    40.         DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
    41.         return druidProperties.dataSource(dataSource);
    42.     }
    43.  
    44.     @Bean(name = "dynamicDataSource")
    45.     @Primary
    46.     public DynamicDataSource dataSource(DataSource masterDataSource) {
    47.         Map targetDataSources = new HashMap<>();
    48.         targetDataSources.put(DataSourceType.MASTER.name(), masterDataSource);
    49.         setDataSource(targetDataSources, DataSourceType.SLAVE.name(), "slaveDataSource");
    50.         setDataSource(targetDataSources, DataSourceType.SHARDING.name(), "shardingDataSource");
    51.         return new DynamicDataSource(masterDataSource, targetDataSources);
    52.     }
    53.  
    54.     /**
    55.      * 设置数据源
    56.      *
    57.      * @param targetDataSources 备选数据源集合
    58.      * @param sourceName        数据源名称
    59.      * @param beanName          bean名称
    60.      */
    61.     public void setDataSource(Map targetDataSources, String sourceName, String beanName) {
    62.         try {
    63.             DataSource dataSource = SpringUtils.getBean(beanName);
    64.             targetDataSources.put(sourceName, dataSource);
    65.         } catch (Exception e) {
    66.         }
    67.     }
    68.  
    69.     /**
    70.      * 去除监控页面底部的广告
    71.      */
    72.     @SuppressWarnings({"rawtypes", "unchecked"})
    73.     @Bean
    74.     @ConditionalOnProperty(name = "spring.datasource.druid.statViewServlet.enabled", havingValue = "true")
    75.     public FilterRegistrationBean removeDruidFilterRegistrationBean(DruidStatProperties properties) {
    76.         // 获取web监控页面的参数
    77.         DruidStatProperties.StatViewServlet config = properties.getStatViewServlet();
    78.         // 提取common.js的配置路径
    79.         String pattern = config.getUrlPattern() != null ? config.getUrlPattern() : "/druid/*";
    80.         String commonJsPattern = pattern.replaceAll("\\*", "js/common.js");
    81.         final String filePath = "support/http/resources/js/common.js";
    82.         // 创建filter进行过滤
    83.         Filter filter = new Filter() {
    84.             @Override
    85.             public void init(javax.servlet.FilterConfig filterConfig) throws ServletException {
    86.             }
    87.  
    88.             @Override
    89.             public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    90.                     throws IOException, ServletException {
    91.                 chain.doFilter(request, response);
    92.                 // 重置缓冲区，响应头不会被重置
    93.                 response.resetBuffer();
    94.                 // 获取common.js
    95.                 String text = Utils.readFromResource(filePath);
    96.                 // 正则替换banner, 除去底部的广告信息
    97.                 text = text.replaceAll("
      "      , "");
    98.                 text = text.replaceAll("powered.*?shrek.wang", "");
    99.                 response.getWriter().write(text);
    100.             }
    101.  
    102.             @Override
    103.             public void destroy() {
    104.             }
    105.         };
    106.         FilterRegistrationBean registrationBean = new FilterRegistrationBean();
    107.         registrationBean.setFilter(filter);
    108.         registrationBean.addUrlPatterns(commonJsPattern);
    109.         return registrationBean;
    110.     }
    111. }

    10、分库分表配置

    1.  
    2. import com.alibaba.druid.pool.DruidDataSource;
    3. import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
    4. import com.common.config.properties.DruidProperties;
    5. import com.common.sharding.ShardingAlgorithm;
    6. import org.apache.shardingsphere.api.config.sharding.KeyGeneratorConfiguration;
    7. import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
    8. import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
    9. import org.apache.shardingsphere.api.config.sharding.strategy.InlineShardingStrategyConfiguration;
    10. import org.apache.shardingsphere.api.config.sharding.strategy.StandardShardingStrategyConfiguration;
    11. import org.apache.shardingsphere.shardingjdbc.api.ShardingDataSourceFactory;
    12. import org.springframework.beans.factory.annotation.Qualifier;
    13. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    14. import org.springframework.boot.context.properties.ConfigurationProperties;
    15. import org.springframework.context.annotation.Bean;
    16. import org.springframework.context.annotation.Configuration;
    17.  
    18. import javax.sql.DataSource;
    19. import java.sql.SQLException;
    20. import java.util.HashMap;
    21. import java.util.Map;
    22. import java.util.Properties;
    23.  
    24. /**
    25.  * sharding 配置信息
    26.  */
    27. @Configuration
    28. public class ShardingDataSourceConfig {
    29.  
    30.  
    31.     @Bean
    32.     @ConfigurationProperties("spring.datasource.druid.order1")
    33.     @ConditionalOnProperty(prefix = "spring.datasource.druid.order1", name = "enabled", havingValue = "true")
    34.     public DataSource order1DataSource(DruidProperties druidProperties) {
    35.         DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
    36.         return druidProperties.dataSource(dataSource);
    37.     }
    38.  
    39.     @Bean
    40.     @ConfigurationProperties("spring.datasource.druid.order2")
    41.     @ConditionalOnProperty(prefix = "spring.datasource.druid.order2", name = "enabled", havingValue = "true")
    42.     public DataSource order2DataSource(DruidProperties druidProperties) {
    43.         DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
    44.         return druidProperties.dataSource(dataSource);
    45.     }
    46.  
    47. //    @Bean(name = "shardingDataSource")
    48. //    public DataSource shardingDataSource(@Qualifier("order1DataSource") DataSource order1DataSource, @Qualifier("order2DataSource") DataSource order2DataSource) throws SQLException {
    49. //        Map dataSourceMap = new HashMap<>();
    50. //        dataSourceMap.put("order1", order1DataSource);
    51. //        dataSourceMap.put("order2", order2DataSource);
    52. //
    53. //        // sys_order 表规则配置 (Groovy表达式)
    54. //        TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration("sys_order", "order$->{1..2}.sys_order_$->{0..1}");
    55. //
    56. //        // 配置分库策略
    57. //        orderTableRuleConfig.setDatabaseShardingStrategyConfig(new InlineShardingStrategyConfiguration("user_id", "order$->{user_id % 2 + 1}"));
    58. //        // 配置分表策略
    59. //        orderTableRuleConfig.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_id", "sys_order_$->{order_id % 2}"));
    60. //        // 分布式主键
    61. //        orderTableRuleConfig.setKeyGeneratorConfig(new KeyGeneratorConfiguration("SNOWFLAKE", "order_id"));
    62. //
    63. //        // 配置分片规则
    64. //        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
    65. //        shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
    66. //
    67. //        // 数据库分片策略
    68. //        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("user_id", new ShardingAlgorithm()));
    69. //
    70. //        //系统参数配置
    71. //        Properties shardingProperties = new Properties();
    72. //        shardingProperties.put("sql.show", true);
    73. //
    74. //        // 获取数据源对象
    75. //        DataSource dataSource = ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfig, shardingProperties);
    76. //        return dataSource;
    77. //    }
    78.  
    79.     @Bean(name = "shardingDataSource")
    80.     public DataSource shardingDataSource(@Qualifier("order1DataSource") DataSource order1DataSource, @Qualifier("order2DataSource") DataSource order2DataSource) throws SQLException {
    81.  
    82.         Map dataSourceMap = new HashMap<>();
    83.         dataSourceMap.put("order1", order1DataSource);
    84.         dataSourceMap.put("order2", order2DataSource);
    85.  
    86.         //表规则配置
    87.         TableRuleConfiguration tableRuleConfiguration = new TableRuleConfiguration("sys_order", "order$->{1..2}.sys_order_$->{0..1}");
    88.         //分库
    89.         tableRuleConfiguration.setDatabaseShardingStrategyConfig(new InlineShardingStrategyConfiguration("user_id", "order$->{user_id % 2 + 1}"));
    90.         // 配置分表策略
    91.         //orderTableRuleConfig.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_id", "sys_order_$->{order_id % 2}"));
    92.         //自定义分表规则
    93.         tableRuleConfiguration.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("order_id", new ShardingAlgorithm()));
    94.         // 分布式主键
    95.         tableRuleConfiguration.setKeyGeneratorConfig(new KeyGeneratorConfiguration("SNOWFLAKE", "order_id"));
    96.         //设置表复杂sharding规则
    97. //        TableRuleConfiguration orderInfoTableRule = new TableRuleConfiguration("order_info");
    98. //        ComplexShardingStrategyConfiguration complexShardingStrategyConfiguration =
    99. //                new ComplexShardingStrategyConfiguration("order_no,merchant_id",
    100. //                        new ComplexDatabaseShardingAlgorithm());
    101. //        orderInfoTableRule.setDatabaseShardingStrategyConfig(complexShardingStrategyConfiguration);
    102.  
    103.         ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
    104.         shardingRuleConfig.getTableRuleConfigs().add(tableRuleConfiguration);
    105.         // shardingRuleConfig.getTableRuleConfigs().add(orderInfoTableRule);
    106.         //系统参数配置
    107.         Properties properties = new Properties();
    108.         properties.put("sql.show", true);
    109.  
    110.         return ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfig, properties);
    111.     }
    112. }

    11、分库分表测试

    业务处理层

    1.  
    2. import com.common.annotation.DataSource;
    3. import com.common.enums.DataSourceType;
    4. import com.common.mapper.SysOrderMapper;
    5. import com.common.pojo.SysOrder;
    6. import com.common.service.ISysOrderService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.stereotype.Service;
    9.  
    10. import java.util.List;
    11.  
    12. /**
    13.  * 订单Service业务层处理
    14.  */
    15. @Service
    16. public class SysOrderServiceImpl implements ISysOrderService {
    17.  
    18.     @Autowired
    19.     private SysOrderMapper myShardingMapper;
    20.  
    21.     /**
    22.      * 查询订单
    23.      *
    24.      * @param orderId 订单编号
    25.      * @return 订单信息
    26.      */
    27.     @Override
    28.     @DataSource(DataSourceType.SHARDING)
    29.     public SysOrder selectSysOrderById(Long orderId) {
    30.         return myShardingMapper.selectSysOrderById(orderId);
    31.     }
    32.  
    33.     /**
    34.      * 查询订单列表
    35.      *
    36.      * @param sysOrder 订单信息
    37.      * @return 订单列表
    38.      */
    39.     @Override
    40.     @DataSource(DataSourceType.SHARDING)
    41.     public List selectSysOrderList(SysOrder sysOrder) {
    42.         return myShardingMapper.selectSysOrderList(sysOrder);
    43.     }
    44.  
    45.     /**
    46.      * 新增订单
    47.      *
    48.      * @param sysOrder 订单
    49.      * @return 结果
    50.      */
    51.     @Override
    52.     @DataSource(DataSourceType.SHARDING)
    53.     public int insertSysOrder(SysOrder sysOrder) {
    54.         return myShardingMapper.insertSysOrder(sysOrder);
    55.     }
    56. }

    controller

    1.  
    2. import com.common.pojo.SysOrder;
    3. import com.common.service.ISysOrderService;
    4. import com.common.utils.ResponseUtils;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.web.bind.annotation.GetMapping;
    7. import org.springframework.web.bind.annotation.PathVariable;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9. import org.springframework.web.bind.annotation.RestController;
    10.  
    11. import java.util.UUID;
    12.  
    13. /**
    14.  * 订单 Controller
    15.  */
    16. @RestController
    17. @RequestMapping("/order")
    18. public class SysOrderController {
    19.  
    20.  
    21.     @Autowired
    22.     private ISysOrderService sysOrderService;
    23.  
    24.     @GetMapping("/add/{userId}")
    25.     public ResponseUtils add(@PathVariable("userId") Long userId) {
    26.         SysOrder sysOrder = new SysOrder();
    27.         sysOrder.setUserId(userId);
    28.         sysOrder.setStatus("0");
    29.         sysOrder.setOrderNo(UUID.randomUUID().toString());
    30.         return ResponseUtils.success(sysOrderService.insertSysOrder(sysOrder));
    31.     }
    32.  
    33.     @GetMapping("/list")
    34.     public ResponseUtils list() {
    35.         return ResponseUtils.success(sysOrderService.selectSysOrderList(new SysOrder()));
    36.     }
    37.  
    38.     @GetMapping("/query/{orderId}")
    39.     public ResponseUtils query(@PathVariable("orderId") Long orderId) {
    40.         return ResponseUtils.success(sysOrderService.selectSysOrderById(orderId));
    41.     }
    42. }

    测试验证

    访问http://localhost:8080/order/add/1入库到ry-order2

    访问http://localhost:8080/order/add/2入库到ry-order1

    同时根据订单号order_id % 2入库到sys_order_0或者sys_order_1

    11、源码下载

    https://gitee.com/wdae/sharding-jdbc-demo-master.git

  • 相关阅读:
    如何伪造http头，让后端认为是本地访问
    信息系统项目管理师（高项）01
    Shell判断：流程控制—if（三）
    IOTE 2023盛况回顾，美格智能聚连接之力促数字新生长
    UE4_材质_湿度着色器及Desaturation算法_ben材质教程
    java spring security oauth2 动态 修改当前登录用户的基础信息以及权限2.0(无需重新登录)
    模型调参优化
    BigDecimal 类型的计算方法
    mysql 统计当天，当周，当月，当年和总量的SQL语句如何写？
    企业架构LNMP学习笔记37
  • 原文地址：https://blog.csdn.net/qq_40428665/article/details/126953144