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

2次阅读

共计 16170 个字符，预计需要花费 41 分钟才能阅读完成。

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

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_file、master_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 即示意启动胜利

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，这就是两阶段提交

从库 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 线程演化成了多个线程

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

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 节点，并且轮询进入

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

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

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

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

用户数据依据订单 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

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 表。

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

需要：

对 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 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

正文完

java

发表至： java

2021-11-09

0

关于java:高并发优雅的做限流

关于java:IT人必知互联网主流商业模式

关于java:三大最常使用的java框架

关于java:面试突击-23说一下线程生命周期以及转换过程

关于深度学习:模型推理ncnn-模型转换及量化流程

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

1、概览

2、MySQL 主从复制

1）、docker 配置 mysql 主从复制

2）、binlog 和 redo log 回顾

3）、MySQL 主从复制原理

3、Sharding-Jdbc 实现读写拆散

4、MySQL 分库分表原理

1）、分库分表

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

5、Sharding-Jdbc 实现分库分表

1）、逻辑表

2）、inline 分片策略

3）、分布式主键配置

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

站内搜索