devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用spring boot集成shardingsphere分库分表简易测试

作者：Monodyee | 2024-04-25 17:38:39

赞

踩

使用spring boot集成shardingsphere分库分表简易测试

根据如下pom整上一个spring-boot项目，spring-boot版本用2.3.5，shardingsphere用5.1.1。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.  
  7.     <groupId>com.shardingsphere</groupId>
  8.     <artifactId>shardingsphere-test</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  10.  
  11.  
  12.     <!--引入spring boot 2.3.5 -->
  13.     <parent>
  14.         <groupId>org.springframework.boot</groupId>
  15.         <artifactId>spring-boot-starter-parent</artifactId>
  16.         <version>2.3.5.RELEASE</version>
  17.         <relativePath/>
  18.     </parent>
  19.  
  20.     <dependencies>
  21.         <!--spring boot的web模块-->
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-web</artifactId>
  25.         </dependency>
  26.         <!--引入shardingsphere-->
  27.         <dependency>
  28.             <groupId>org.apache.shardingsphere</groupId>
  29.             <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
  30.             <version>5.1.1</version>
  31.         </dependency>
  32.  
  33.         <!--引入mybatis plus-->
  34.         <dependency>
  35.             <groupId>com.baomidou</groupId>
  36.             <artifactId>mybatis-plus-boot-starter</artifactId>
  37.             <version>3.3.1</version>
  38.         </dependency>
  39.         <!--引入mysal connector-->
  40.         <dependency>
  41.             <groupId>mysql</groupId>
  42.             <artifactId>mysql-connector-java</artifactId>
  43.             <scope>runtime</scope>
  44.         </dependency>
  45.  
  46.         <!--引入Lombok-->
  47.         <dependency>
  48.             <groupId>org.projectlombok</groupId>
  49.             <artifactId>lombok</artifactId>
  50.         </dependency>
  51.  
  52.         <!--引入spring 测试-->
  53.         <dependency>
  54.             <groupId>org.springframework.boot</groupId>
  55.             <artifactId>spring-boot-starter-test</artifactId>
  56.             <scope>test</scope>
  57.             <exclusions>
  58.                 <exclusion>
  59.                     <groupId>org.junit.vintage</groupId>
  60.                     <artifactId>junit-vintage-engine</artifactId>
  61.                 </exclusion>
  62.             </exclusions>
  63.         </dependency>
  64.         <dependency>
  65.             <groupId>junit</groupId>
  66.             <artifactId>junit</artifactId>
  67.         </dependency>
  68.  
  69.         <!--spring 测试类-->
  70.         <dependency>
  71.             <groupId>org.springframework.boot</groupId>
  72.             <artifactId>spring-boot-test</artifactId>
  73.         </dependency>
  74.         <dependency>
  75.             <groupId>org.springframework</groupId>
  76.             <artifactId>spring-test</artifactId>
  77.             <scope>compile</scope>
  78.         </dependency>
  79.     </dependencies>
  80.  
  81. </project>

再用mysql整一个名为shardingsphere-test的库（编码集utf8mb4,也可以选自己喜欢的编码集），再往里弄上两个测试表。

  1. CREATE TABLE t_course_1 (
  2.   `cid` BIGINT(20) NOT NULL,
  3.   `user_id` BIGINT(20) DEFAULT NULL,
  4.   `cname` VARCHAR(50) DEFAULT NULL,
  5.   `brief` VARCHAR(50) DEFAULT NULL,
  6.   `price` DOUBLE DEFAULT NULL,
  7.   `status` INT(11) DEFAULT NULL,
  8.   PRIMARY KEY (`cid`)
  9. ) ENGINE=INNODB DEFAULT CHARSET=utf8mb4;
  10.  
  11.  
  12. CREATE TABLE t_course_2 (
  13.   `cid` BIGINT(20) NOT NULL,
  14.   `user_id` BIGINT(20) DEFAULT NULL,
  15.   `cname` VARCHAR(50) DEFAULT NULL,
  16.   `brief` VARCHAR(50) DEFAULT NULL,
  17.   `price` DOUBLE DEFAULT NULL,
  18.   `status` INT(11) DEFAULT NULL,
  19.   PRIMARY KEY (`cid`)
  20. ) ENGINE=INNODB DEFAULT CHARSET=utf8mb4;

项目结构如下。

application.yml的配置及解释如下：

  1. spring:
  2.   application:
  3.     name: sharding-jdbc-demo # 应用名称
  4.   shardingsphere:
  5.     # 设置全局属性
  6.     props:
  7.       # 打开SQL显示功能，将会打印出执行的原始SQL和实际路由后的SQL
  8.       sql-show: true
  9.     # 数据源配置
  10.     datasource:
  11.       # 定义数据源名称列表，这里只有一个名为db1的数据源
  12.       names: db1
  13.       # 数据源db1的具体配置
  14.       db1:
  15.         # 数据源实现类，此处使用HikariCP连接池
  16.         type: com.zaxxer.hikari.HikariDataSource
  17.         # JDBC驱动类名，对应MySQL数据库驱动
  18.         driver-class-name: com.mysql.jdbc.Driver
  19.         # 数据库连接URL，连接本地MySQL服务器上的shardingsphere-test数据库，并设置字符编码和禁用SSL
  20.         url: jdbc:mysql://127.0.0.1:3306/shardingsphere-test?characterEncoding=UTF-8&useSSL=false
  21.         # 数据库用户名
  22.         username: root
  23.         # 数据库密码
  24.         password: root
  25.  
  26.     # 规则配置部分
  27.     rules:
  28.       # 分片规则相关配置
  29.       sharding:
  30.         # 1.定义分片表的实际分布情况
  31.         tables:
  32.           # 针对表t_course的分片配置
  33.           t_course:
  34.             # 实际数据节点分布，表明t_course表被分成两张表，分别命名为t_course_0和t_course_1，并存储在db1数据库中
  35.             actual-data-nodes: "db1.t_course_$->{1..2}"
  36.             # 配置策略
  37.             table-strategy:
  38.               # 用于单分片键的标准分片场景
  39.               standard:
  40.                 sharding-column: cid
  41.                 # 分片算法名字
  42.                 sharding-algorithm-name: course_inline
  43.             # 分布式主键生成策略配置
  44.             key-generate-strategy:
  45.               # 主键列名为cid
  46.               column: cid
  47.               # 引用已定义的分布式序列生成器  alg-snowflake
  48.               key-generator-name: snowflake
  49.  
  50.         # 2.定义分布式序列生成器
  51.         key-generators:
  52.           # 定义名为alg-snowflake的分布式序列生成器  alg-snowflake
  53.           snowflake:
  54.             # 类型为SNOWFLAKE算法，用于生成全局唯一ID
  55.             type: SNOWFLAKE
  56.  
  57.         # 3.定义分片算法
  58.         sharding-algorithms:
  59.           # 定义名为table-inline的分片算法
  60.           course_inline:
  61.             # 使用INLINE类型的行表达式分片算法
  62.             type: INLINE
  63.             # 算法属性配置
  64.             props:
  65.               # 行表达式算法具体内容，按照cid模2加1的值来确定数据落入哪张表，例如：cid%2+1=0，则落入t_course_1，等于1则落入t_course_2
  66.               algorithm-expression: t_course_$->{cid % 2 + 1}
  67.  
  68.         # 4.定义分片策略
  69.         #sharding-strategies:
  70.           # 对于表t_course的分片策略定义
  71.           #t_course_strategy:
  72.             # 使用标准分片策略
  73.             #type: STANDARD
  74.             # 指定分片键为cid列
  75.             #sharding-column: cid
  76.             # 引用已定义的分片算法
  77.             #sharding-algorithm-name: course_inline
  78.  
  79.  
  80. # SQL输出日志
  81. mybatis-plus:
  82.   configuration:
  83.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

再弄一个对应数据库的实体类。

  1. import com.baomidou.mybatisplus.annotation.IdType;
  2. import com.baomidou.mybatisplus.annotation.TableId;
  3. import com.baomidou.mybatisplus.annotation.TableName;
  4. import lombok.Data;
  5. import lombok.ToString;
  6.  
  7. @TableName("t_course")
  8. @Data
  9. @ToString
  10. public class Course {
  11.  
  12.     //@TableId(type = IdType.AUTO)
  13.     @TableId
  14.     private Long cid;
  15.  
  16.     private Long userId;
  17.  
  18.     private Long corderNo;
  19.  
  20.     private String cname;
  21.  
  22.     private String brief;
  23.  
  24.     private Double price;
  25.  
  26.     private Integer status;
  27.  
  28. }

再搞一个mapper。

  1. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  2. import com.shardingsphere.demo.entity.Course;
  3. import org.apache.ibatis.annotations.Mapper;
  4.  
  5. @Mapper
  6. public interface CourseMapper extends BaseMapper<Course> {
  7.  
  8. }

再搞一个service接口。

  1. public interface CoureInterface {
  2.  
  3.     public void addCoure();
  4. }

按道上的规矩再搞一个service接口的实现类。

  1. import com.shardingsphere.demo.coure.CoureInterface;
  2. import com.shardingsphere.demo.entity.Course;
  3. import com.shardingsphere.demo.mapper.CourseMapper;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  6.  
  7. @Service
  8. public class CoureInterfaceImpl implements CoureInterface {
  9.  
  10.     @Autowired
  11.     private CourseMapper courseMapper;
  12.  
  13.     @Override
  14.     public void addCoure() {
  15.         for (int i = 0; i < 30; i++) {
  16.             Course course = new Course();
  17.             // 注意: cid使用雪花算法配置了(还可以使用MybatisPlus UUID)，此处不用配置
  18.             course.setUserId(1000L + i);
  19.             course.setCname("ShardingSphere");
  20.             course.setBrief("ShardingSphere测试");
  21.             course.setPrice(66.6);
  22.             course.setStatus(1);
  23.             courseMapper.insert(course);
  24.         }
  25.     }
  26. }

再弄上一个controller，来接收远方的呼唤。

  1. import com.shardingsphere.demo.coure.CoureInterface;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  5.  
  6. @RestController
  7. public class CourseController {
  8.  
  9.     @Autowired
  10.     private CoureInterface coureInterface;
  11.  
  12.     @RequestMapping(path = "/demo/addCourse")
  13.     public void addCourse(){
  14.         coureInterface.addCoure();
  15.     }
  16. }

最后再弄上一个spring boot的启动类，用来启动这个sping boot项目。

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3.  
  4. @SpringBootApplication
  5. public class ShardingSphereTest {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(ShardingSphereTest.class, args);
  8.     }
  9. }

我们启动服务后，直接浏览器访问这个接口简单测试一下。

localhost:8080/demo/addCourse

再去数据库看一眼，发现如我们所想，数据已经被拆分到两个表中了。

趁热打铁，我们再进阶一小点，把库也给分了算了。

再找一台机器创建一个跟上面一模一样的数据库（shardingsphere-test），库里的表也跟上面建的一模一样两张表（t_course_1，t_course_2），这样我们就富裕了，有了俩数据库。

需要改造的地方就是我们的application.yml配置文件，加上分库操作。

  1. spring:
  2.   application:
  3.     name: sharding-jdbc-demo-database # 应用名称
  4.   shardingsphere:
  5.     # 设置全局属性
  6.     props:
  7.       # 打开SQL显示功能，将会打印出执行的原始SQL和实际路由后的SQL
  8.       sql-show: true
  9.     # 数据源配置
  10.     datasource:
  11.       # 定义数据源名称列表，这里有两个数据源（数据的名字可以一样，也可以不一样）
  12.       names: db1, db2
  13.       # 数据源db1的具体配置
  14.       db1:
  15.         # 数据源实现类，此处使用HikariCP连接池
  16.         type: com.zaxxer.hikari.HikariDataSource
  17.         # JDBC驱动类名，对应MySQL数据库驱动
  18.         driver-class-name: com.mysql.jdbc.Driver
  19.         # 数据库连接URL，连接本地MySQL服务器上的shardingsphere-test数据库，并设置字符编码和禁用SSL
  20.         url: jdbc:mysql://127.0.0.1:3306/shardingsphere-test?characterEncoding=UTF-8&useSSL=false
  21.         # 数据库用户名
  22.         username: root
  23.         # 数据库密码
  24.         password: root
  25.       # 数据源db1的具体配置
  26.       db2:
  27.         # 数据源实现类，此处使用HikariCP连接池
  28.         type: com.zaxxer.hikari.HikariDataSource
  29.         # JDBC驱动类名，对应MySQL数据库驱动
  30.         driver-class-name: com.mysql.jdbc.Driver
  31.         # 数据库连接URL，连接本地MySQL服务器上的shardingsphere-test数据库，并设置字符编码和禁用SSL
  32.         url: jdbc:mysql://124.223.XXX.XXX:3306/shardingsphere-test?characterEncoding=UTF-8&useSSL=false
  33.         # 数据库用户名
  34.         username: root
  35.         # 数据库密码
  36.         password: root
  37.  
  38.     # 规则配置部分
  39.     rules:
  40.       # 分片规则相关配置
  41.       sharding:
  42.         # 1.定义分片表的实际分布情况
  43.         tables:
  44.           # 针对表t_course的分片配置
  45.           t_course:
  46.             # 实际数据节点分布，表明t_course表被分成两张表，分别命名为t_course_0和t_course_1，并存储在db1数据库中
  47.             actual-data-nodes: "db$->{1..2}.t_course_$->{1..2}"
  48.             # 配置库策略
  49.             database-strategy:
  50.               standard:
  51.                 sharding-column: user_id
  52.                 sharding-algorithm-name: table_inline
  53.  
  54.             # 配置表策略
  55.             table-strategy:
  56.               # 用于单分片键的标准分片场景
  57.               standard:
  58.                 sharding-column: cid
  59.                 # 分片算法名字
  60.                 sharding-algorithm-name: course_inline
  61.             # 分布式主键生成策略配置
  62.             key-generate-strategy:
  63.               # 主键列名为cid
  64.               column: cid
  65.               # 引用已定义的分布式序列生成器  alg-snowflake
  66.               key-generator-name: snowflake
  67.  
  68.         # 2.定义分布式序列生成器
  69.         key-generators:
  70.           # 定义名为alg-snowflake的分布式序列生成器  alg-snowflake
  71.           snowflake:
  72.             # 类型为SNOWFLAKE算法，用于生成全局唯一ID
  73.             type: SNOWFLAKE
  74.  
  75.         # 3.定义分片算法
  76.         sharding-algorithms:
  77.           #定义库分片算法
  78.           table_inline:
  79.             type: INLINE
  80.             props:
  81.               algorithm-expression: db$->{user_id % 2 + 1}
  82.           # 定义名为table-inline的分片算法，表分片
  83.           course_inline:
  84.             # 使用INLINE类型的行表达式分片算法
  85.             type: INLINE
  86.             # 算法属性配置
  87.             props:
  88.               # 行表达式算法具体内容，按照cid模2加1的值来确定数据落入哪张表，例如：cid%2+1=0，则落入t_course_1，等于1则落入t_course_2
  89.               algorithm-expression: t_course_$->{cid % 2 + 1}
  90.  
  91.         # 4.定义分片策略
  92.         #sharding-strategies:
  93.           # 对于表t_course的分片策略定义
  94.           #t_course_strategy:
  95.             # 使用标准分片策略
  96.             #type: STANDARD
  97.             # 指定分片键为cid列
  98.             #sharding-column: cid
  99.             # 引用已定义的分片算法
  100.             #sharding-algorithm-name: course_inline
  101.  
  102.  
  103. # SQL输出日志
  104. mybatis-plus:
  105.   configuration:
  106.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

然后重启服务,重新访问localhost:8080/demo/addCourse 调用添加数据的服务接口，此时再查数据库就会发现数据已经被shardingsphere分到不同库的不同表里了。

分库查询

        入库了以后，我们写个测试类尝试查询一下，看看会是怎么样。

  1. @SpringBootTest
  2. @RunWith(SpringRunner.class)
  3. @Slf4j
  4. public class MyTest {
  5.     @Autowired(required = false)
  6.     private CourseMapper courseMapper;
  7.  
  8.      /**
  9.      * 水平分片：查询所有记录
  10.      * 查询了两个数据源，每个数据源中使用UNION ALL连接两个表
  11.      */
  12.     @Test
  13.     public void testShardingSelectOne(){
  14.         List<Course> courses = courseMapper.selectList(null);
  15.         courses.forEach(System.out::println);
  16.     }
  17.  
  18. }

我们来看一下查询结果。

  1. Creating a new SqlSession
  2. SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@30b0d5a7] was not registered for synchronization because synchronization is not active
  3. JDBC Connection [org.apache.shardingsphere.driver.jdbc.core.connection.ShardingSphereConnection@411e567e] will not be managed by Spring
  4. ==>  Preparing: SELECT cid,user_id,cname,brief,price,status FROM t_course 
  5. ==> Parameters: 
  6. 2024-04-19 21:17:29.909  INFO 25740 --- [           main] ShardingSphere-SQL                       : Logic SQL: SELECT  cid,user_id,cname,brief,price,status  FROM t_course
  7. 2024-04-19 21:17:29.909  INFO 25740 --- [           main] ShardingSphere-SQL                       : SQLStatement: MySQLSelectStatement(table=Optional.empty, limit=Optional.empty, lock=Optional.empty, window=Optional.empty)
  8. 2024-04-19 21:17:29.910  INFO 25740 --- [           main] ShardingSphere-SQL                       : Actual SQL: db1 ::: SELECT  cid,user_id,cname,brief,price,status  FROM t_course_1 UNION ALL SELECT  cid,user_id,cname,brief,price,status  FROM t_course_2
  9. 2024-04-19 21:17:29.910  INFO 25740 --- [           main] ShardingSphere-SQL                       : Actual SQL: db2 ::: SELECT  cid,user_id,cname,brief,price,status  FROM t_course_1 UNION ALL SELECT  cid,user_id,cname,brief,price,status  FROM t_course_2
  10. <==    Columns: cid, user_id, cname, brief, price, status
  11. <==        Row: 1781311094111928321, 1000, ShardingSphere, ShardingSphere尝试查询, 99.0, 1
  12. <==        Row: 1781311097660309505, 1002, ShardingSphere, ShardingSphere尝试查询, 99.0, 1
  13. <==        Row: 1781311098117488641, 1004, ShardingSphere, ShardingSphere尝试查询, 99.0, 1
  14. <==        Row: 1781311098650165249, 1006, ShardingSphere, ShardingSphere尝试查询, 99.0, 1
  15. <==        Row: 1781311097660309506, 1003, ShardingSphere, ShardingSphere尝试查询, 99.0, 1
  16. <==        Row: 1781311098184597506, 1005, ShardingSphere, ShardingSphere尝试查询, 99.0, 1
  17. <==        Row: 1781311098650165250, 1007, ShardingSphere, ShardingSphere尝试查询, 99.0, 1
  18. <==        Row: 1781311096750145537, 1001, ShardingSphere, ShardingSphere尝试查询, 99.0, 1
  19. <==      Total: 8

可以看到，它是把每个库的每张表进行union操作，返回返回总结果。

多表关联查询

        如果我们要是多表查询呢？先建上两张有关联的表来试一下。如下两个数据库分别创建t_order0，t_order1，t_order_item0，t_order_item1，仍然分库分表创建，只不过让t_order和t_order_item有联系，即有如此关联：SELECT o.*,i.* FROM t_order o JOIN t_order_item i ON o.order_no = i.order_no；

  1. CREATE TABLE t_order0 (
  2.   id BIGINT,
  3.   order_no VARCHAR(30),
  4.   user_id BIGINT,
  5.   amount DECIMAL(10,2),
  6.   PRIMARY KEY(id) 
  7. );
  8. CREATE TABLE t_order1 (
  9.   id BIGINT,
  10.   order_no VARCHAR(30),
  11.   user_id BIGINT,
  12.   amount DECIMAL(10,2),
  13.   PRIMARY KEY(id) 
  14. );
  15.  
  16.  
  17. CREATE TABLE t_order_item0(
  18.     id BIGINT,
  19.     order_no VARCHAR(30),
  20.     user_id BIGINT,
  21.     price DECIMAL(10,2),
  22.     `count` INT,
  23.     PRIMARY KEY(id)
  24. );
  25.  
  26. CREATE TABLE t_order_item1(
  27.     id BIGINT,
  28.     order_no VARCHAR(30),
  29.     user_id BIGINT,
  30.     price DECIMAL(10,2),
  31.     `count` INT,
  32.     PRIMARY KEY(id)
  33. );

再在配置文件中将这俩表的配置搞好。

  1. spring:
  2.   application:
  3.     name: sharding-jdbc-demo-database # 应用名称
  4.   shardingsphere:
  5.     # 设置全局属性
  6.     props:
  7.       # 打开SQL显示功能，将会打印出执行的原始SQL和实际路由后的SQL
  8.       sql-show: true
  9.     # 数据源配置
  10.     datasource:
  11.       # 定义数据源名称列表，这里有两个数据源（数据的名字可以一样，也可以不一样）
  12.       names: db1, db2
  13.       # 数据源db1的具体配置
  14.       db1:
  15.         # 数据源实现类，此处使用HikariCP连接池
  16.         type: com.zaxxer.hikari.HikariDataSource
  17.         # JDBC驱动类名，对应MySQL数据库驱动
  18.         driver-class-name: com.mysql.jdbc.Driver
  19.         # 数据库连接URL，连接本地MySQL服务器上的shardingsphere-test数据库，并设置字符编码和禁用SSL
  20.         url: jdbc:mysql://127.0.0.1:3306/shardingsphere-test?characterEncoding=UTF-8&useSSL=false
  21.         # 数据库用户名
  22.         username: root
  23.         # 数据库密码
  24.         password: root
  25.       # 数据源db1的具体配置
  26.       db2:
  27.         # 数据源实现类，此处使用HikariCP连接池
  28.         type: com.zaxxer.hikari.HikariDataSource
  29.         # JDBC驱动类名，对应MySQL数据库驱动
  30.         driver-class-name: com.mysql.jdbc.Driver
  31.         # 数据库连接URL，连接本地MySQL服务器上的shardingsphere-test数据库，并设置字符编码和禁用SSL
  32.         url: jdbc:mysql://124.223.XXX.XXX:3306/shardingsphere-test?characterEncoding=UTF-8&useSSL=false
  33.         # 数据库用户名
  34.         username: root
  35.         # 数据库密码
  36.         password: 123456
  37.  
  38.     # 规则配置部分
  39.     rules:
  40.       # 分片规则相关配置
  41.       sharding:
  42.         # 1.定义分片表的实际分布情况
  43.         tables:
  44.           # 针对表t_course的分片配置
  45.           t_course:
  46.             # 实际数据节点分布，表明t_course表被分成两张表，分别命名为t_course_0和t_course_1，并存储在db1数据库中
  47.             actual-data-nodes: "db$->{1..2}.t_course_$->{1..2}"
  48.             # 配置库策略
  49.             database-strategy:
  50.               standard:
  51.                 sharding-column: user_id
  52.                 sharding-algorithm-name: table_inline
  53.  
  54.             # 配置表策略
  55.             table-strategy:
  56.               # 用于单分片键的标准分片场景
  57.               standard:
  58.                 sharding-column: cid
  59.                 # 分片算法名字
  60.                 sharding-algorithm-name: course_inline
  61.             # 分布式主键生成策略配置
  62.             key-generate-strategy:
  63.               # 主键列名为cid
  64.               column: cid
  65.               # 引用已定义的分布式序列生成器  alg-snowflake
  66.               key-generator-name: snowflake
  67.  
  68.           #order表的分片分库策略
  69.           t_order:
  70.             # 实际数据节点分布，表明t_course表被分成两张表，分别命名为t_course_0和t_course_1，并存储在db1数据库中
  71.             actual-data-nodes: "db$->{1..2}.t_order$->{0..1}"
  72.             # 配置分库策略
  73.             database-strategy:
  74.               standard:
  75.                 sharding-column: user_id
  76.                 sharding-algorithm-name: order_inline
  77.  
  78.             # 配置分表策略
  79.             table-strategy:
  80.               # 用于单分片键的标准分片场景,根据order_no的hash值进行分片
  81.               standard:
  82.                 sharding-column: order_no
  83.                 # 分片算法名字
  84.                 sharding-algorithm-name: order_no_mod
  85.             # 分布式主键生成策略配置
  86.             key-generate-strategy:
  87.               # 主键列名为cid
  88.               column: id
  89.               # 引用已定义的分布式序列生成器  alg-snowflake
  90.               key-generator-name: snowflake
  91.  
  92.           #order表的分片分库策略
  93.           t_order_item:
  94.             # 实际数据节点分布，表明t_course表被分成两张表，分别命名为t_course_0和t_course_1，并存储在db1数据库中
  95.             actual-data-nodes: "db$->{1..2}.t_order_item$->{0..1}"
  96.             # 配置分库策略
  97.             database-strategy:
  98.               standard:
  99.                 sharding-column: user_id
  100.                 sharding-algorithm-name: order_inline
  101.  
  102.             # 配置分表策略
  103.             table-strategy:
  104.               # 用于单分片键的标准分片场景,根据order_no的hash值进行分片
  105.               standard:
  106.                 sharding-column: order_no
  107.                 # 分片算法名字
  108.                 sharding-algorithm-name: order_no_mod
  109.             # 分布式主键生成策略配置
  110.             key-generate-strategy:
  111.               # 主键列名为cid
  112.               column: id
  113.               # 引用已定义的分布式序列生成器  alg-snowflake
  114.               key-generator-name: snowflake
  115.  
  116.         # 2.定义分布式序列生成器
  117.         key-generators:
  118.           # 定义名为alg-snowflake的分布式序列生成器  alg-snowflake
  119.           snowflake:
  120.             # 类型为SNOWFLAKE算法，用于生成全局唯一ID
  121.             type: SNOWFLAKE
  122.  
  123.         # 3.定义你想配置表的分片算法
  124.         sharding-algorithms:
  125.           #定义库分片算法
  126.           table_inline:
  127.             type: INLINE
  128.             props:
  129.               algorithm-expression: db$->{user_id % 2 + 1}
  130.           # 定义名为table-inline的分片算法，表分片
  131.           course_inline:
  132.             # 使用INLINE类型的行表达式分片算法
  133.             type: INLINE
  134.             # 算法属性配置
  135.             props:
  136.               # 行表达式算法具体内容，按照cid模2加1的值来确定数据落入哪张表，例如：cid%2+1=0，则落入t_course_1，等于1则落入t_course_2
  137.               algorithm-expression: t_course_$->{cid % 2 + 1}
  138.  
  139.           order_inline:
  140.             type: INLINE
  141.             props:
  142.               algorithm-expression: db$->{user_id % 2 + 1}
  143.           order_no_mod:
  144.             # 使用HASH_MOD类型的行表达式分片算法
  145.             type: HASH_MOD
  146.             # 算法属性配置
  147.             props:
  148.               # 行表达式算法具体内容，
  149.               sharding-count: 2
  150.  
  151.         # 4.定义分片策略
  152.         #sharding-strategies:
  153.           # 对于表t_course的分片策略定义
  154.           #t_course_strategy:
  155.             # 使用标准分片策略
  156.             #type: STANDARD
  157.             # 指定分片键为cid列
  158.             #sharding-column: cid
  159.             # 引用已定义的分片算法
  160.             #sharding-algorithm-name: course_inline
  161.  
  162.  
  163. # SQL输出日志
  164. mybatis-plus:
  165.   configuration:
  166.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

OrderMapper改造一下，进行表关联。 

  1. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  2. import com.shardingsphere.demo.entity.Order;
  3. import com.shardingsphere.demo.vo.OrderVo;
  4. import org.apache.ibatis.annotations.Mapper;
  5. import org.apache.ibatis.annotations.Select;
  6.  
  7. import java.util.List;
  8.  
  9. @Mapper
  10. public interface OrderMapper extends BaseMapper<Order> {
  11.  
  12.     @Select({"SELECT o.order_no, SUM(i.price * i.count) AS amount",
  13.             "FROM t_order o JOIN t_order_item i ON o.order_no = i.order_no",
  14.             "GROUP BY o.order_no"})
  15.     List<OrderVo> getOrderAmount();
  16. }

再写个测试方法。

  1.     /**
  2.      * 测试关联表查询
  3.      */
  4.     @Test
  5.     public void testGetOrderAmount(){
  6.  
  7.         List<OrderVo> orderAmountList = orderMapper.getOrderAmount();
  8.         orderAmountList.forEach(System.out::println);
  9.     }

看看执行结果：

  1. ==>  Preparing: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order o JOIN t_order_item i ON o.order_no = i.order_no GROUP BY o.order_no 
  2. ==> Parameters: 
  3. 2024-04-19 21:27:52.938  INFO 21784 --- [           main] ShardingSphere-SQL                       : Logic SQL: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order o JOIN t_order_item i ON o.order_no = i.order_no GROUP BY o.order_no
  4. 2024-04-19 21:27:52.939  INFO 21784 --- [           main] ShardingSphere-SQL                       : SQLStatement: MySQLSelectStatement(table=Optional.empty, limit=Optional.empty, lock=Optional.empty, window=Optional.empty)
  5. 2024-04-19 21:27:52.939  INFO 21784 --- [           main] ShardingSphere-SQL                       : Actual SQL: db2 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order0 o JOIN t_order_item0 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  6. 2024-04-19 21:27:52.939  INFO 21784 --- [           main] ShardingSphere-SQL                       : Actual SQL: db2 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order1 o JOIN t_order_item0 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  7. 2024-04-19 21:27:52.939  INFO 21784 --- [           main] ShardingSphere-SQL                       : Actual SQL: db2 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order0 o JOIN t_order_item1 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  8. 2024-04-19 21:27:52.939  INFO 21784 --- [           main] ShardingSphere-SQL                       : Actual SQL: db2 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order1 o JOIN t_order_item1 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  9. 2024-04-19 21:27:52.939  INFO 21784 --- [           main] ShardingSphere-SQL                       : Actual SQL: db1 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order0 o JOIN t_order_item0 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  10. 2024-04-19 21:27:52.939  INFO 21784 --- [           main] ShardingSphere-SQL                       : Actual SQL: db1 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order1 o JOIN t_order_item0 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  11. 2024-04-19 21:27:52.939  INFO 21784 --- [           main] ShardingSphere-SQL                       : Actual SQL: db1 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order0 o JOIN t_order_item1 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  12. 2024-04-19 21:27:52.939  INFO 21784 --- [           main] ShardingSphere-SQL                       : Actual SQL: db1 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order1 o JOIN t_order_item1 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  13. <==    Columns: order_no, amount
  14. <==        Row: ShardingSphere1, 40.00
  15. <==        Row: ShardingSphere2, 40.00
  16. <==        Row: ShardingSphere5, 6.00
  17. <==        Row: ShardingSphere6, 6.00
  18. <==      Total: 4

        发现了一个问题：可以看到同一个数据源中，查询的次数是t_order和t_order_item的笛卡尔积数量，但是t_order0中的订单数据只会在对应数据源中t_order_item0，不会在t_order_item1中，所以有些关联查询是没有意义的，那么接下来就引入了绑定表的概念。

绑定表

        指分片规则一致的一组分片表。 使用绑定表进行多表关联查询时，必须使用分片键进行关联，否则会出现笛卡尔积关联或跨库关联，从而影响查询效率。所以我们来配置一下，将t_order和t_order_item绑定一下，只需要在rules这里增加如下配置，如果你的配置文件是.properties类型的，需要这样配：spring.shardingsphere.rules.sharding.binding-tables[0]=t_order,t_order_item。

  1. # 规则配置部分
  2.     rules:
  3.       # 分片规则相关配置
  4.       sharding:
  5.         #绑定表
  6.         binding-tables:
  7.           - t_order,t_order_item

再次查询：

  1. ==>  Preparing: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order o JOIN t_order_item i ON o.order_no = i.order_no GROUP BY o.order_no 
  2. ==> Parameters: 
  3. 2024-04-19 21:43:08.069  INFO 24608 --- [           main] ShardingSphere-SQL                       : Logic SQL: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order o JOIN t_order_item i ON o.order_no = i.order_no GROUP BY o.order_no
  4. 2024-04-19 21:43:08.069  INFO 24608 --- [           main] ShardingSphere-SQL                       : SQLStatement: MySQLSelectStatement(table=Optional.empty, limit=Optional.empty, lock=Optional.empty, window=Optional.empty)
  5. 2024-04-19 21:43:08.070  INFO 24608 --- [           main] ShardingSphere-SQL                       : Actual SQL: db1 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order0 o JOIN t_order_item0 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  6. 2024-04-19 21:43:08.070  INFO 24608 --- [           main] ShardingSphere-SQL                       : Actual SQL: db1 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order1 o JOIN t_order_item1 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  7. 2024-04-19 21:43:08.070  INFO 24608 --- [           main] ShardingSphere-SQL                       : Actual SQL: db2 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order0 o JOIN t_order_item0 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  8. 2024-04-19 21:43:08.070  INFO 24608 --- [           main] ShardingSphere-SQL                       : Actual SQL: db2 ::: SELECT o.order_no, SUM(i.price * i.count) AS amount FROM t_order1 o JOIN t_order_item1 i ON o.order_no = i.order_no GROUP BY o.order_no ORDER BY o.order_no ASC 
  9. <==    Columns: order_no, amount
  10. <==        Row: ShardingSphere1, 40.00
  11. <==        Row: ShardingSphere2, 40.00
  12. <==        Row: ShardingSphere5, 6.00
  13. <==        Row: ShardingSphere6, 6.00
  14. <==      Total: 4

突然一家伙少了四条查询。

  • 如果不配置绑定表：测试的结果为8个SQL。 多表关联查询会出现笛卡尔积关联。
  • 如果配置绑定表：测试的结果为4个SQL。 多表关联查询不会出现笛卡尔积关联，关联查询效率将大大提升。
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/486480
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号