乐趣区

关于java:ShardingJdbc-实现读写分离-分库分表写得太好了

1、概览

ShardingSphere-Jdbc 定位为轻量级 Java 框架,在 Java 的 Jdbc 层提供的额定服务。它应用客户端直连数据库,以 jar 包模式提供服务,可了解为增强版的 Jdbc 驱动,齐全兼容 Jdbc 和各种 ORM 框架

2、MySQL 主从复制

1)、docker 配置 mysql 主从复制

1)创立主服务器所需目录

mkdir -p /usr/local/mysqlData/master/cnf
mkdir -p /usr/local/mysqlData/master/data

2)定义主服务器配置文件

vim /usr/local/mysqlData/master/cnf/mysql.cnf
[mysqld]
## 设置 server_id, 留神要惟一
server-id=1
## 开启 binlog
log-bin=mysql-bin
## binlog 缓存
binlog_cache_size=1M
## binlog 格局(mixed、statement、row, 默认格局是 statement)
binlog_format=mixed

3)创立并启动 mysql 主服务

docker run -itd -p 3306:3306 --name master -v /usr/local/mysqlData/master/cnf:/etc/mysql/conf.d -v /usr/local/mysqlData/master/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

4)增加复制 master 数据的用户 reader,供从服务器应用

[root@aliyun /]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
6af1df686fff        mysql:5.7           "docker-entrypoint..."   5 seconds ago       Up 4 seconds        0.0.0.0:3306->3306/tcp, 33060/tcp   master
[root@aliyun /]# docker exec -it master /bin/bash
root@41d795785db1:/# mysql -u root -p123456

mysql> GRANT REPLICATION SLAVE ON *.* to 'reader'@'%' identified by 'reader';
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

5)创立从服务器所需目录,编辑配置文件

mkdir /usr/local/mysqlData/slave/cnf -p
mkdir /usr/local/mysqlData/slave/cnf -p
vim /usr/local/mysqlData/slave/cnf/mysql.cnf
[mysqld]
## 设置 server_id, 留神要惟一
server-id=2
## 开启 binlog, 以备 Slave 作为其它 Slave 的 Master 时应用
log-bin=mysql-slave-bin
## relay_log 配置中继日志
relay_log=edu-mysql-relay-bin
## 如果须要同步函数或者存储过程
log_bin_trust_function_creators=true
## binlog 缓存
binlog_cache_size=1M
## binlog 格局(mixed、statement、row, 默认格局是 statement)
binlog_format=mixed
## 跳过主从复制中遇到的所有谬误或指定类型的谬误, 防止 slave 端复制中断
## 如:1062 谬误是指一些主键反复,1032 谬误是因为主从数据库数据不统一
slave_skip_errors=1062

6)创立并运行 mysql 从服务器

docker run -itd -p 3307:3306 --name slaver -v /usr/local/mysqlData/slave/cnf:/etc/mysql/conf.d -v /usr/local/mysqlData/slave/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

7)在从服务器上配置连贯主服务器的信息

首先主服务器上查看 master_log_filemaster_log_pos 两个参数,而后切换到从服务器上进行主服务器的连贯信息的设置

主服务上执行:

root@6af1df686fff:/# mysql -u root -p123456

mysql> show master status;
+------------------+----------+--------------+------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000003 |      591 |              |                  |                   |
+------------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)

docker 查看主服务器容器的 ip 地址

[root@aliyun /]# docker inspect --format='{{.NetworkSettings.IPAddress}}' master
172.17.0.2

从服务器上执行:

[root@aliyun /]# docker exec -it slaver /bin/bash
root@fe8b6fc2f1ca:/# mysql -u root -p123456  

mysql> change master to master_host='172.17.0.2',master_user='reader',master_password='reader',master_log_file='mysql-bin.000003',master_log_pos=591;

8)从服务器启动 I /O 线程和 SQL 线程

mysql> start slave;
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> show slave status\G
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 172.17.0.2
                  Master_User: reader
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000003
          Read_Master_Log_Pos: 591
               Relay_Log_File: edu-mysql-relay-bin.000002
                Relay_Log_Pos: 320
        Relay_Master_Log_File: mysql-bin.000003
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes

Slave_IO_Running: Yes,Slave_SQL_Running: Yes 即示意启动胜利

2)、binlog 和 redo log 回顾

1)redo log(重做日志)

InnoDB 首先将 redo log 放入到 redo log buffer,而后按肯定频率将其刷新到 redo log file

下列三种状况下会将 redo log buffer 刷新到 redo log file:

  • Master Thread 每一秒将 redo log buffer 刷新到 redo log file
  • 每个事务提交时会将 redo log buffer 刷新到 redo log file
  • 当 redo log 缓冲池残余空间小于 1 / 2 时,会将 redo log buffer 刷新到 redo log file

MySQL 里常说的 WAL 技术,全称是 Write Ahead Log,即当事务提交时,先写 redo log,再批改页。也就是说,当有一条记录须要更新的时候,InnoDB 会先把记录写到 redo log 外面,并更新 Buffer Pool 的 page,这个时候更新操作就算实现了

Buffer Pool 是物理页的缓存,对 InnoDB 的任何批改操作都会首先在 Buffer Pool 的 page 上进行,而后这样的页将被标记为脏页并被放到专门的 Flush List 上,后续将由专门的刷脏线程阶段性的将这些页面写入磁盘

InnoDB 的 redo log 是固定大小的,比方能够配置为一组 4 个文件,每个文件的大小是 1GB,循环应用,从头开始写,写到开端就又回到结尾循环写(程序写,节俭了随机写磁盘的 IO 耗费)

Write Pos 是以后记录的地位,一边写一边后移,写到第 3 号文件开端后就回到 0 号文件结尾。Check Point 是以后要擦除的地位,也是往后推移并且循环的,擦除记录前要把记录更新到数据文件

Write Pos 和 Check Point 之间空着的局部,能够用来记录新的操作。如果 Write Pos 追上 Check Point,这时候不能再执行新的更新,须要停下来擦掉一些记录,把 Check Point 推动一下

当数据库产生宕机时,数据库不须要重做所有的日志,因为 Check Point 之前的页都曾经刷新回磁盘,只需对 Check Point 后的 redo log 进行复原,从而缩短了复原的工夫

当缓冲池不够用时,依据 LRU 算法会溢出最近起码应用的页,若此页为脏页,那么须要强制执行 Check Point,将脏页刷新回磁盘

2)binlog(归档日志)

MySQL 整体来看就有两块:一块是 Server 层,次要做的是 MySQL 性能层面的事件;还有一块是引擎层,负责存储相干的具体事宜。redo log 是 InnoDB 引擎特有的日志,而 Server 层也有本人的日志,称为 binlog

binlog 记录了对 MySQL 数据库执行更改的所有操作,不包含 SELECT 和 SHOW 这类操作,次要作用是用于数据库的主从复制及数据的增量复原

应用 mysqldump 备份时,只是对一段时间的数据进行全备,然而如果备份后忽然发现数据库服务器故障,这个时候就要用到 binlog 的日志了

binlog 格局有三种:STATEMENT,ROW,MIXED

  • STATEMENT 模式:binlog 外面记录的就是 SQL 语句的原文。长处是并不需要记录每一行的数据变动,缩小了 binlog 日志量,节约 IO,进步性能。毛病是在某些状况下会导致 master-slave 中的数据不统一
  • ROW 模式:不记录每条 SQL 语句的上下文信息,仅需记录哪条数据被批改了,批改成什么样了,解决了 STATEMENT 模式下呈现 master-slave 中的数据不统一。毛病是会产生大量的日志,尤其是 alter table 的时候会让日志暴涨
  • MIXED 模式:以上两种模式的混合应用,个别的复制应用 STATEMENT 模式保留 binlog,对于 STATEMENT 模式无奈复制的操作应用 ROW 模式保留 binlog,MySQL 会依据执行的 SQL 语句抉择日志保留形式

3)redo log 和 binlog 日志的不同

  • redo log 是 InnoDB 引擎特有的;binlog 是 MySQL 的 Server 层实现的,所有引擎都能够应用
  • redo log 是物理日志,记录的是在某个数据也上做了什么批改;binlog 是逻辑日志,记录的是这个语句的原始逻辑,比方给 ID= 2 这一行的 c 字段加 1
  • redo log 是循环写的,空间固定会用完;binlog 是能够追加写入的,binlog 文件写到肯定大小后会切换到下一个,并不会笼罩以前的日志

4)两阶段提交

create table T(ID int primary key, c int);
update T set c=c+1 where ID=2;

执行器和 InnoDB 引擎在执行这个 update 语句时的外部流程:

  • 执行器先找到引擎取 ID= 2 这一行。ID 是主键,引擎间接用树搜寻找到这一行。如果 ID= 2 这一行所在的数据也原本就在内存中,就间接返回给执行器;否则,须要先从磁盘读入内存,而后再返回
  • 执行器拿到引擎给的行数据,把这个值加上 1,失去新的一行数据,再调用引擎接口写入这行新数据
  • 引擎将这行新数据更新到内存中,同时将这个更新操作记录到 redo log 外面,此时 redo log 处于 prepare 状态。而后告知执行器执行实现了,随时能够提交事务
  • 执行器生成这个操作的 binlog,并把 binlog 写入磁盘
  • 执行器调用引擎的提交事务接口,引擎把刚刚写入的 redo log 改成提交状态,更新实现

update 语句的执行流程图如下,图中浅色框示意在 InnoDB 外部执行的,深色框示意是在执行器中执行的

将 redo log 的写入拆成了两个步骤:prepare 和 commit,这就是两阶段提交

3)、MySQL 主从复制原理

从库 B 和主库 A 之间维持了一个长连贯。主库 A 外部有一个线程,专门用于服务从库 B 的这个长连贯。一个事务日志同步的残缺过程如下:

  • 在从库 B 上通过 change master 命令,设置主库 A 的 IP、端口、用户名、明码,以及要从哪个地位开始申请 binlog,这个地位蕴含文件名和日志偏移量
  • 在从库 B 上执行 start slave 命令,这时从库会启动两个线程,就是图中的 I / O 线程和 SQL 线程。其中 I / O 线程负责与主库建设连贯
  • 主库 A 校验完用户名、明码后,开始依照从库 B 传过来的地位,从本地读取 binlog,发给 B
  • 从库 B 拿到 binlog 后,写到本地文件,称为中继日志
  • SQL 线程读取中继日志,解析出日志里的命令,并执行

因为多线程复制计划的引入,SQL 线程演化成了多个线程

主从复制不是齐全实时地进行同步,而是异步实时。这两头存在主从服务之间的执行延时,如果主服务器的压力很大,则可能导致主从服务器延时较大

3、Sharding-Jdbc 实现读写拆散

Spring Boot 根底就不介绍了,举荐下这个实战教程:
https://www.javastack.cn/cate…

1)、新建 Springboot 工程,引入相干依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.4</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.21</version>
    </dependency>
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        <version>4.0.0-RC1</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2)、application.properties 配置文件

spring.main.allow-bean-definition-overriding=true
#显示 sql
spring.shardingsphere.props.sql.show=true

#配置数据源
spring.shardingsphere.datasource.names=ds1,ds2,ds3

#master-ds1 数据库连贯信息
spring.shardingsphere.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds1.url=jdbc:mysql://47.101.58.187:3306/sharding-jdbc-db?useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=123456
spring.shardingsphere.datasource.ds1.maxPoolSize=100
spring.shardingsphere.datasource.ds1.minPoolSize=5

#slave-ds2 数据库连贯信息
spring.shardingsphere.datasource.ds2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds2.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds2.url=jdbc:mysql://47.101.58.187:3307/sharding-jdbc-db?useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.ds2.username=root
spring.shardingsphere.datasource.ds2.password=123456
spring.shardingsphere.datasource.ds2.maxPoolSize=100
spring.shardingsphere.datasource.ds2.minPoolSize=5

#slave-ds3 数据库连贯信息
spring.shardingsphere.datasource.ds3.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds3.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds3.url=jdbc:mysql://47.101.58.187:3307/sharding-jdbc-db?useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.ds3.username=root
spring.shardingsphere.datasource.ds3.password=123456
spring.shardingsphere.datasource.ds.maxPoolSize=100
spring.shardingsphere.datasource.ds3.minPoolSize=5

#配置默认数据源 ds1 默认数据源, 次要用于写
spring.shardingsphere.sharding.default-data-source-name=ds1
#配置主从名称
spring.shardingsphere.masterslave.name=ms
#置主库 master, 负责数据的写入
spring.shardingsphere.masterslave.master-data-source-name=ds1
#配置从库 slave 节点
spring.shardingsphere.masterslave.slave-data-source-names=ds2,ds3
#配置 slave 节点的负载平衡平衡策略, 采纳轮询机制
spring.shardingsphere.masterslave.load-balance-algorithm-type=round_robin

#整合 mybatis 的配置
mybatis.type-aliases-package=com.ppdai.shardingjdbc.entity

3)、创立 t_user 表

CREATE TABLE `t_user` (`id` int(11) NOT NULL AUTO_INCREMENT,
  `nickname` varchar(100) DEFAULT NULL,
  `password` varchar(100) DEFAULT NULL,
  `sex` int(11) DEFAULT NULL,
  `birthday` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4;

4)、定义 Controller、Mapper、Entity

@Data
public class User {
    private Integer id;

    private String nickname;

    private String password;

    private Integer sex;

    private String birthday;
}
@RestController
@RequestMapping("/api/user")
public class UserController {
    @Autowired
    private UserMapper userMapper;

    @PostMapping("/save")
    public String addUser() {User user = new User();
        user.setNickname("zhangsan" + new Random().nextInt());
        user.setPassword("123456");
        user.setSex(1);
        user.setBirthday("1997-12-03");
        userMapper.addUser(user);
        return "success";
    }

    @GetMapping("/findUsers")
    public List<User> findUsers() {return userMapper.findUsers();
    }
}
public interface UserMapper {@Insert("insert into t_user(nickname,password,sex,birthday) values(#{nickname},#{password},#{sex},#{birthday})")
    void addUser(User user);

    @Select("select * from t_user")
    List<User> findUsers();}

5)、验证

启动日志中三个数据源初始化胜利:

调用 http://localhost:8080/api/user/save 始终进入到 ds1 主节点

调用 http://localhost:8080/api/user/findUsers 始终进入到 ds2、ds3 节点,并且轮询进入

4、MySQL 分库分表原理

1)、分库分表

程度拆分:同一个表的数据拆到不同的库不同的表中。能够依据工夫、地区或某个业务键维度,也能够通过 hash 进行拆分,最初通过路由拜访到具体的数据。拆分后的每个表构造保持一致

垂直拆分:就是把一个有很多字段的表给拆分成多个表,或者是多个库下来。每个库表的构造都不一样,每个库表都蕴含局部字段。一般来说,能够依据业务维度进行拆分,如订单表能够拆分为订单、订单反对、订单地址、订单商品、订单扩大等表;也能够,依据数据冷热水平拆分,20% 的热点字段拆到一个表,80% 的冷字段拆到另外一个表

2)、不停机分库分表数据迁徙

个别数据库的拆分也是有一个过程的,一开始是单表,前面缓缓拆成多表。那么咱们就看下如何平滑的从 MySQL 单表适度到 MySQL 的分库分表架构

  • 利用 MySQL+Canal 做增量数据同步,利用分库分表中间件,将数据路由到对应的新表中
  • 利用分库分表中间件,全量数据导入到对应的新表中
  • 通过单表数据和分库分表数据两两比拟,更新不匹配的数据到新表中
  • 数据稳固后,将单表的配置切换到分库分表配置上

5、Sharding-Jdbc 实现分库分表

1)、逻辑表

用户数据依据订单 id%2 拆分为 2 个表,别离是:t_order0 和 t_order1。他们的逻辑表名是:t_order

多数据源雷同表:

# 多数据源 $->{0..N}. 逻辑表名 $->{0..N} 雷同表
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds$->{0..1}.t_order$->{0..1}

多数据源不同表:

# 多数据源 $->{0..N}. 逻辑表名 $->{0..N} 不同表
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds0.t_order$->{0..1},ds1.t_order$->{2..4}

单库分表:

# 单数据源的配置形式
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds0.t_order$->{0..4}

全副手动指定:

spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds0.t_order0,ds1.t_order0,ds0.t_order1,ds1.t_order1

2)、inline 分片策略

spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds$->{0..1}.t_order$->{0..1}
#数据源分片策略
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column=user_id
#数据源分片算法
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression=ds$->{user_id%2}
#表分片策略
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
#表分片算法
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order$->{order_id%2}

下面的配置通过 user_id%2 来决定具体数据源,通过 order_id%2 来决定具体表

insert into t_order(user_id,order_id) values(2,3),user_id%2 = 0应用数据源 ds0,order_id%2 = 1应用 t_order1,insert 语句最终操作的是数据源 ds0 的 t_order1 表。

3)、分布式主键配置

Sharding-Jdbc 能够配置分布式主键生成策略。默认应用雪花算法(snowflake),生成 64bit 的长整型数据,也反对 UUID 的形式

# 主键的列名
spring.shardingsphere.sharding.tables.t_order.key-generator.column=id
#主键生成策略
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE

4)、inline 分片策略实现分库分表

需要:

对 1000w 的用户数据进行分库分表,对用户表的数据进行分表和分库的操作。依据年龄奇数存储在 t_user1,偶数 t_user0,同时性别奇数存储在 ds1,偶数 ds0

表构造:

CREATE TABLE `t_user0` (`id` bigint(20) DEFAULT NULL,
  `nickname` varchar(200) DEFAULT NULL,
  `password` varchar(200) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `sex` int(11) DEFAULT NULL,
  `birthday` varchar(100) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `t_user1` (`id` bigint(20) DEFAULT NULL,
  `nickname` varchar(200) DEFAULT NULL,
  `password` varchar(200) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `sex` int(11) DEFAULT NULL,
  `birthday` varchar(100) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

两个数据库中都蕴含 t_user0 和 t_user1 两张表

application.properties:

spring.main.allow-bean-definition-overriding=true
#显示 sql
spring.shardingsphere.props.sql.show=true

#配置数据源
spring.shardingsphere.datasource.names=ds0,ds1

#ds0 数据库连贯信息
spring.shardingsphere.datasource.ds0.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds0.url=jdbc:mysql://47.101.58.187:3306/t_user_db0?useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.ds0.username=root
spring.shardingsphere.datasource.ds0.password=123456
spring.shardingsphere.datasource.ds0.maxPoolSize=100
spring.shardingsphere.datasource.ds0.minPoolSize=5

#ds1 数据库连贯信息
spring.shardingsphere.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds1.url=jdbc:mysql://47.101.58.187:3306/t_user_db1?useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=123456
spring.shardingsphere.datasource.ds1.maxPoolSize=100
spring.shardingsphere.datasource.ds1.minPoolSize=5

#整合 mybatis 的配置
mybatis.type-aliases-package=com.ppdai.shardingjdbc.entity

spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=ds$->{0..1}.t_user$->{0..1}
#数据源分片策略
spring.shardingsphere.sharding.tables.t_user.database-strategy.inline.sharding-column=sex
#数据源分片算法
spring.shardingsphere.sharding.tables.t_user.database-strategy.inline.algorithm-expression=ds$->{sex%2}
#表分片策略
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.sharding-column=age
#表分片算法
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.algorithm-expression=t_user$->{age%2}
#主键的列名
spring.shardingsphere.sharding.tables.t_user.key-generator.column=id
spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE

Spring Boot 根底就不介绍了,举荐下这个实战教程:
https://www.javastack.cn/cate…

测试类:

@SpringBootTest
class ShardingJdbcApplicationTests {

    @Autowired
    private UserMapper userMapper;

    /**
     * sex: 奇数
     * age: 奇数
     * ds1.t_user1
     */
    @Test
    public void test01() {User user = new User();
        user.setNickname("zhangsan" + new Random().nextInt());
        user.setPassword("123456");
        user.setAge(17);
        user.setSex(1);
        user.setBirthday("1997-12-03");
        userMapper.addUser(user);
    }

    /**
     * sex: 奇数
     * age: 偶数
     * ds1.t_user0
     */
    @Test
    public void test02() {User user = new User();
        user.setNickname("zhangsan" + new Random().nextInt());
        user.setPassword("123456");
        user.setAge(18);
        user.setSex(1);
        user.setBirthday("1997-12-03");
        userMapper.addUser(user);
    }

    /**
     * sex: 偶数
     * age: 奇数
     * ds0.t_user1
     */
    @Test
    public void test03() {User user = new User();
        user.setNickname("zhangsan" + new Random().nextInt());
        user.setPassword("123456");
        user.setAge(17);
        user.setSex(2);
        user.setBirthday("1997-12-03");
        userMapper.addUser(user);
    }

    /**
     * sex: 偶数
     * age: 偶数
     * ds0.t_user0
     */
    @Test
    public void test04() {User user = new User();
        user.setNickname("zhangsan" + new Random().nextInt());
        user.setPassword("123456");
        user.setAge(18);
        user.setSex(2);
        user.setBirthday("1997-12-03");
        userMapper.addUser(user);
    }
}

参考文档:\
https://shardingsphere.apache… \
https://www.bilibili.com/vide…

原文链接:https://blog.csdn.net/qq_4037… \
版权申明:本文为 CSDN 博主「邋遢的漂泊剑客」的原创文章,遵循 CC 4.0 BY-SA 版权协定,转载请附上原文出处链接及本申明。

近期热文举荐:

1.1,000+ 道 Java 面试题及答案整顿(2021 最新版)

2. 别在再满屏的 if/ else 了,试试策略模式,真香!!

3. 卧槽!Java 中的 xx ≠ null 是什么新语法?

4.Spring Boot 2.5 重磅公布,光明模式太炸了!

5.《Java 开发手册(嵩山版)》最新公布,速速下载!

感觉不错,别忘了顺手点赞 + 转发哦!

退出移动版