【SpringBoot框架篇】30.使用sharding-jdbc实现读写分离和分库分表

1.简介

ShardingSphere-JDBC 定位为轻量级 Java 框架，在 Java 的 JDBC 层提供的额外服务。 它使用客户端直连数据库，以 jar 包形式提供服务，无需额外部署和依赖，可理解为增强版的 JDBC 驱动，完全兼容 JDBC 和各种 ORM 框架。

适用于任何基于 JDBC 的 ORM 框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template 或直接使用 JDBC；
支持任何第三方的数据库连接池，如：DBCP, C3P0, BoneCP, HikariCP 等；
支持任意实现 JDBC 规范的数据库，目前支持 MySQL，PostgreSQL，Oracle，SQLServer 以及任何可使用 JDBC 访问的数据库。

ShardingSphere-JDBC 提供了 4 种配置方式，用于不同的使用场景。 通过配置，应用开发者可以灵活的使用数据分片、读写分离、数据加密、影子库等功能，并且能够叠加使用。

官网地址

本文使用的工具如下:

• 数据库 mysql
• 持久化 Jpa
• 数据源连接池 hikari

2.引入依赖

  		<!--sharding-jdbc -->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.1.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!--mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>

3.测试用到的类

@Entity
@Table(name = "user")
public class User {

    @Id
    @GeneratedValue(strategy= GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Integer age;
	//省略get set方法
}
//操作User对象的仓库
public interface UserRepository extends JpaRepository<User,Integer> {

}

测试代码

@SpringBootTest
class ShardingsphereApplicationTests {
    @Autowired
    private UserRepository userRepository;
    @Test
    void contextLoads() {
        for (int i = 0; i < 100; i++) {
            User user = new User();
            user.setAge(i);
            user.setName("张三" + i);
            userRepository.save(user);
        }
        List<User> userList=userRepository.findAll();
        System.out.println("用户的数量="+userList.size());
    }
}

4.读写分类配置

需配置mysql的主从同步
请参考我写过的博客配置: 点我跳转

读写分离用到的配置

server:
  port: 8030

spring:
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
  shardingsphere:
    datasource:
      # 数据源名称集合
      names: master,slave1
      #主库
      master:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbcUrl: jdbc:mysql://192.168.239.128:3306/test?createDatabaseIfNotExist=true&useSSL=false&serverTimezone=GMT%2b8&characterEncoding=utf8&connectTimeout=1000&socketTimeout=15000&autoR
        username: root
        password: 123456
        pool-name: MyHikariCP_1
        minimum-idle: 10
        maximum-pool-size: 30
        idle-timeout: 600000
        max-lifetime: 1800000
        connection-timeout: 30000
        connection-test-query: SELECT 1
      #从库  
      slave1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbcUrl: jdbc:mysql://192.168.239.128:3307/test?createDatabaseIfNotExist=true&useSSL=false&serverTimezone=GMT%2b8&characterEncoding=utf8&connectTimeout=1000&socketTimeout=15000&autoR
        username: root
        password: 123456
        pool-name: MyHikariCP_2
        minimum-idle: 10
        maximum-pool-size: 30
        idle-timeout: 600000
        max-lifetime: 1800000
        connection-timeout: 30000
        connection-test-query: SELECT 1
    sharding:
      master-slave-rules:
        master-slave-group:
          # 指定主节点名字        写操作
          master-datasource-name: master
          # 指定从节点名字,多个读节点用逗号分开  读操作
          slave-data-source-names: slave1
    masterslave:
      # 配置从库选择策略，提供轮询与随机，这里选择用轮询
      load-balance-algorithm-type: round_robin
    #打印sharding的日志
    props:
      sql:
        show: true

运行标题3的测试类结果入下

可以看到写的操作用的是master数据源,读的操作用的slave1数据源。

5.分库分表配置

• 分库根据年龄取模
• 分表根据id取模
• 分库分表的测试在同一台机器上面

server:
  port: 8030

database:
  #数据库连接地址
  ip: 127.0.0.1
  #数据库端口
  port: 3306
  username: root
  password: 123456
  #连接信息前缀
  url-prefix: jdbc:mysql://${database.ip}:${database.port}
  url-suffix: createDatabaseIfNotExist=true&useSSL=false&serverTimezone=GMT%2b8&characterEncoding=utf8&connectTimeout=1000&socketTimeout=15000&autoReconnect=true
  #配置数据库名称集合
  datasource:
    db1: test1
    db2: test2

spring:
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
  shardingsphere:
    datasource:
      # 数据源名称集合
      names: ${database.datasource.db1}, ${database.datasource.db2}
      test1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbcUrl: ${database.url-prefix}/${database.datasource.db1}?${database.url-suffix}
        username: ${database.username}
        password: ${database.password}
        pool-name: MyHikariCP_1
        minimum-idle: 10
        maximum-pool-size: 30
        idle-timeout: 600000
        max-lifetime: 1800000
        connection-timeout: 30000
        connection-test-query: SELECT 1
      test2:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbcUrl: ${database.url-prefix}/${database.datasource.db2}?${database.url-suffix}
        username: ${database.username}
        password: ${database.password}
        pool-name: MyHikariCP_2
        minimum-idle: 10
        maximum-pool-size: 30
        idle-timeout: 600000
        max-lifetime: 1800000
        connection-timeout: 30000
        connection-test-query: SELECT 1
    sharding:
      # 默认分库 未配置分片规则的表将通过默认数据源定位
      default-data-source-name: ${database.datasource.db1}
      # 分表
      tables:
        #表名
        user:
          #数据库名称$->{数量范围}.表名称$->{数量范围}
          actual-data-nodes: test$->{1..2}.user$->{1..2}
          #分库策略
          database-strategy:
            # 行表达式模式
            inline:
              # 配置库分片的字段
              sharding-column: age
              # 表达式，分库的算法，这个是通过年龄取模然后决定落到哪个库
              algorithm-expression: test$->{age % 2 + 1}
          # 配置表分片策略
          table-strategy:
            # 行表达式
            inline:
              # 配置表分片的字段
              sharding-column: id
              # 配置表分片算法
              algorithm-expression: user$->{id % 2 +1}
          key-generator:
            column: id
            # 雪花算法生成id
            type: SNOWFLAKE
    #打印sharding的日志
    props:
      sql:
        show: true

6.分库配置

根据id取模分库

server:
  port: 8030

database:
  #数据库连接地址
  ip: 127.0.0.1
  #数据库端口
  port: 3306
  username: root
  password: 123456
  #连接信息前缀
  url-prefix: jdbc:mysql://${database.ip}:${database.port}
  #连接信息后缀
  url-suffix: createDatabaseIfNotExist=true&useSSL=false&serverTimezone=GMT%2b8&characterEncoding=utf8&connectTimeout=1000&socketTimeout=15000&autoReconnect=true
  #配置数据库名称集合
  datasource:
    db1: test1
    db2: test2

spring:
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
  shardingsphere:
    datasource:
      # 数据源名称集合
      names: ${database.datasource.db1}, ${database.datasource.db2}
      test1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbcUrl: ${database.url-prefix}/${database.datasource.db1}?${database.url-suffix}
        username: ${database.username}
        password: ${database.password}
      test2:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbcUrl: ${database.url-prefix}/${database.datasource.db2}?${database.url-suffix}
        username: ${database.username}
        password: ${database.password}
    sharding:
      # 默认分库 未配置分片规则的表将通过默认数据源定位
      default-data-source-name: ${database.datasource.db1}
      # 分表
      tables:
        #表名
        user:
          #数据库名称$->{数量范围}.表名称
          actual-data-nodes: test$->{1..2}.user
          #分库策略
          database-strategy:
            # 行表达式模式
            inline:
              #配置库分片的字段
              sharding-column: id
              # 表达式，分库的算法，这个是通过id取模然后决定落到哪个库
              algorithm-expression: test$->{id% 2 + 1}
          key-generator:
            column: id
            # 雪花算法生成id
            type: SNOWFLAKE
    #打印sharding的日志
    props:
      sql:
        show: true

7.分表配置

根据id取模分表

server:
  port: 8030

database:
  #数据库连接地址
  ip: 127.0.0.1
  #数据库端口
  port: 3306
  username: root
  password: 123456
  #连接信息前缀
  url-prefix: jdbc:mysql://${database.ip}:${database.port}
  url-suffix: createDatabaseIfNotExist=true&useSSL=false&serverTimezone=GMT%2b8&characterEncoding=utf8&connectTimeout=1000&socketTimeout=15000&autoReconnect=true
  #配置数据库名称集合
  datasource:
    db0: test

spring:
  jpa:
    hibernate:
      # 自动建表 最好改成 none
      ddl-auto: update
    show-sql: true
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
  shardingsphere:
    datasource:
      # 数据源名称集合
      names: ${database.datasource.db0}
      test:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbcUrl: ${database.url-prefix}/${database.datasource.db0}?${database.url-suffix}
        username: ${database.username}
        password: ${database.password}
        pool-name: MyHikariCP
        minimum-idle: 10
        maximum-pool-size: 30
        idle-timeout: 600000
        max-lifetime: 1800000
        connection-timeout: 30000
        connection-test-query: SELECT 1
    sharding:
      # 默认分库 未配置分片规则的表将通过默认数据源定位
      default-data-source-name: ${database.datasource.db0}
      # 分表
      tables:
        #表名
        user:
          #数据库名称.表名称$->{数量范围}
          actual-data-nodes: test.user$->{1..2}
          # 配置表分片策略
          table-strategy:
            # 行表达式
            inline:
              # 配置表分片的字段
              sharding-column: id
              # 配置表分片算法
              algorithm-expression: user$->{id % 2 +1}
          key-generator:
            column: id
            # 雪花算法生成id
            type: SNOWFLAKE
    #打印sharding的日志
    props:
      sql:
        show: true

8.项目配套代码

gitee代码地址

创作不易,要是觉得我写的对你有点帮助的话,麻烦在gitee上帮我点下 Star

【SpringBoot框架篇】其它文章如下,后续会继续更新。

• 1.搭建第一个springboot项目
• 2.Thymeleaf模板引擎实战
• 3.优化代码,让代码更简洁高效
• 4.集成jta-atomikos实现分布式事务
• 5.分布式锁的实现方式
• 6.docker部署,并挂载配置文件到宿主机上面
• 7.项目发布到生产环境
• 8.搭建自己的spring-boot-starter
• 9.dubbo入门实战
• 10.API接口限流实战
• 11.Spring Data Jpa实战
• 12.使用druid的monitor工具查看sql执行性能
• 13.使用springboot admin对springboot应用进行监控
• 14.mybatis-plus实战
• 15.使用shiro对web应用进行权限认证
• 16.security整合jwt实现对前后端分离的项目进行权限认证
• 17.使用swagger2生成RESTful风格的接口文档
• 18.使用Netty加websocket实现在线聊天功能
• 19.使用spring-session加redis来实现session共享
• 20.自定义@Configuration配置类启用开关
• 21.对springboot框架编译后的jar文件瘦身
• 22.集成RocketMQ实现消息发布和订阅
• 23.集成smart-doc插件零侵入自动生成RESTful格式API文档
• 24.集成FastDFS实现文件的分布式存储
• 25.集成Minio实现文件的私有化对象存储
• 26.集成spring-boot-starter-validation对接口参数校验
• 27.集成mail实现邮件推送带网页样式的消息
• 28.使用JdbcTemplate操作数据库
• 29.Jpa+vue实现单模型的低代码平台
• 30.使用sharding-jdbc实现读写分离和分库分表
• 31.基于分布式锁或xxx-job实现分布式任务调度
• 32.基于注解+redis实现表单防重复提交
• 33.优雅集成i18n实现国际化信息返回
• 34.使用Spring Retry完成任务的重试