ShardingSphere5-JDBC读写分离
# ShardingSphere5-JDBC读写分离
# 1. MySQL主从同步
# 1.1. MySQL主从同步原理
基本原理:
slave会从master读取binlog来进行数据同步
具体步骤:
step1:
master将数据改变记录到二进制日志(binary log)
中。step2:
当slave上执行start slave
命令之后,slave会创建一个IO 线程
用来连接master,请求master中的binlog。step3:
当slave连接master时,master会创建一个log dump 线程
,用于发送 binlog 的内容。在读取 binlog 的内容的操作中,会对主节点上的 binlog 加锁,当读取完成并发送给从服务器后解锁。step4:
IO 线程接收主节点 binlog dump 进程发来的更新之后,保存到中继日志(relay log)
中。step5:
slave的SQL线程
,读取relay log日志,并解析成具体操作,从而实现主从操作一致,最终数据一致。
# 1.2. 一主多从配置
服务器规划:使用docker
方式创建,主从服务器IP一致,端口号不一致
- 主服务器:容器名
cnlxc-mysql-master
,端口3306
- 从服务器:容器名
cnlxc-mysql-slave1
,端口3307
- 从服务器:容器名
cnlxc-mysql-slave2
,端口3308
**注意:**如果此时防火墙是开启的,则先关闭防火墙,并重启docker
,否则后续安装的MySQL无法启动
#关闭docker
systemctl stop docker
#关闭防火墙
systemctl stop firewalld
#启动docker
systemctl start docker
2
3
4
5
6
# 准备主服务器 🚗
- step1:在docker中创建并启动MySQL主服务器:
端口3306
docker run -d \
-p 3306:3306 \
-v /cnlxc/mysql/master/conf:/etc/mysql/conf.d \
-v /cnlxc/mysql/master/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name cnlxc-mysql-master \
mysql:8.0.29
2
3
4
5
6
7
- step2:创建MySQL主服务器配置文件:
默认情况下MySQL的binlog日志是自动开启的,可以通过如下配置定义一些可选配置
vim /cnlxc/mysql/master/conf/my.cnf
配置如下内容
[mysqld]
# 服务器唯一id,默认值1
server-id=1
# 设置日志格式,默认值ROW
binlog_format=STATEMENT
# 二进制日志名,默认binlog
# log-bin=binlog
# 设置需要复制的数据库,默认复制全部数据库
#binlog-do-db=mytestdb
# 设置不需要复制的数据库
#binlog-ignore-db=mysql
#binlog-ignore-db=infomation_schema
2
3
4
5
6
7
8
9
10
11
12
重启MySQL容器
docker restart cnlxc-mysql-master
binlog格式说明:
- binlog_format=STATEMENT:日志记录的是主机数据库的
写指令
,性能高,但是now()之类的函数以及获取系统参数的操作会出现主从数据不同步的问题。 - binlog_format=ROW(默认):日志记录的是主机数据库的
写后的数据
,批量操作时性能较差,解决now()或者 user()或者 @@hostname 等操作在主从机器上不一致的问题。 - binlog_format=MIXED:是以上两种level的混合使用,有函数用ROW,没函数用STATEMENT,但是无法识别系统变量
binlog-ignore-db和binlog-do-db的优先级问题:
- step3:使用命令行登录MySQL主服务器:
#进入容器:env LANG=C.UTF-8 避免容器中显示中文乱码
docker exec -it cnlxc-mysql-master env LANG=C.UTF-8 /bin/bash
#进入容器内的mysql命令行
mysql -uroot -p
#修改默认密码校验方式 [确保新旧版本连接工具,还有ShardingSphere都可以连接]
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
2
3
4
5
6
- step4:主机中创建slave用户:
-- 创建slave用户
CREATE USER 'cnlxc_slave'@'%';
-- 设置密码
ALTER USER 'cnlxc_slave'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
-- 授予复制权限
GRANT REPLICATION SLAVE ON *.* TO 'cnlxc_slave'@'%';
-- 刷新权限
FLUSH PRIVILEGES;
2
3
4
5
6
7
8
只有赋值权限
- step5:主机中查询master状态:
执行完此步骤后不要再操作主服务器MYSQL
,防止主服务器状态值变化
SHOW MASTER STATUS;
记下File
和Position
的值。执行完此步骤后不要再操作主服务器MYSQL,防止主服务器状态值变化。
mysql> SHOW MASTER STATUS;
+---------------+----------+--------------+------------------+-------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+---------------+----------+--------------+------------------+-------------------+
| binlog.000003 | 1351 | | | |
+---------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)
2
3
4
5
6
7
8
# 准备从服务器1 🚗
可以配置多台从机slave1、slave2...,这里以配置slave1为例
- step1:在docker中创建并启动MySQL从服务器:
端口3307
docker run -d \
-p 3307:3306 \
-v /cnlxc/mysql/slave1/conf:/etc/mysql/conf.d \
-v /cnlxc/mysql/slave1/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name cnlxc-mysql-slave1 \
mysql:8.0.29
2
3
4
5
6
7
- step2:创建MySQL从服务器配置文件:
vim /cnlxc/mysql/slave1/conf/my.cnf
配置如下内容:
[mysqld]
# 服务器唯一id,每台服务器的id必须不同,如果配置其他从机,注意修改id
server-id=2
# 中继日志名,默认xxxxxxxxxxxx-relay-bin
#relay-log=relay-bin
2
3
4
5
重启MySQL容器
docker restart cnlxc-mysql-slave1
- step3:使用命令行登录MySQL从服务器:
#进入容器:
docker exec -it cnlxc-mysql-slave1 env LANG=C.UTF-8 /bin/bash
#进入容器内的mysql命令行
mysql -uroot -p
#修改默认密码校验方式
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
2
3
4
5
6
- step4:在从机上配置主从关系:
在从机上执行以下SQL操作
CHANGE MASTER TO MASTER_HOST='192.168.47.129',
MASTER_USER='cnlxc_slave',MASTER_PASSWORD='123456', MASTER_PORT=3306,
MASTER_LOG_FILE='binlog.000003',MASTER_LOG_POS=1351;
2
3
注意:
MASTER_HOST:主机IP
MASTER_USER:主机创建的从机访问账号(只有复制权限)
MASTER_PASSWORD:主机创建的从机访问账号的密码
MASTER_PORT:主机密码
MASTER_LOG_FILE
、MASTER_LOG_POS
:应分别主机上的File
和Position
的值。
# 准备从服务器2
可以配置多台从机slave1、slave2...,这里以配置slave1为例
点击查看
- step1:在docker中创建并启动MySQL从服务器:
端口3308
docker run -d \
-p 3308:3306 \
-v /cnlxc/mysql/slave2/conf:/etc/mysql/conf.d \
-v /cnlxc/mysql/slave2/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name cnlxc-mysql-slave2 \
mysql:8.0.29
2
3
4
5
6
7
- step2:创建MySQL从服务器配置文件:
vim /cnlxc/mysql/slave2/conf/my.cnf
配置如下内容:
[mysqld]
# 服务器唯一id,每台服务器的id必须不同,如果配置其他从机,注意修改id
server-id=3
# 中继日志名,默认xxxxxxxxxxxx-relay-bin
#relay-log=relay-bin
2
3
4
5
重启MySQL容器
docker restart cnlxc-mysql-slave2
- step3:使用命令行登录MySQL从服务器:
#进入容器:
docker exec -it cnlxc-mysql-slave2 env LANG=C.UTF-8 /bin/bash
#进入容器内的mysql命令行
mysql -uroot -p
#修改默认密码校验方式
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
2
3
4
5
6
- step4:在从机上配置主从关系:
在从机上执行以下SQL操作
CHANGE MASTER TO MASTER_HOST='192.168.47.129',
MASTER_USER='cnlxc_slave',MASTER_PASSWORD='123456', MASTER_PORT=3306,
MASTER_LOG_FILE='binlog.000003',MASTER_LOG_POS=1351;
2
3
注意:
MASTER_HOST:主机IP
MASTER_USER:主机创建的从机访问账号(只有复制权限)
MASTER_PASSWORD:主机创建的从机访问账号的密码
MASTER_PORT:主机密码
MASTER_LOG_FILE
、MASTER_LOG_POS
:应分别主机上的File
和Position
的值。
# 启动主从同步
启动从机的复制功能
,执行SQL:
START SLAVE;
-- 查看状态(不需要分号)
SHOW SLAVE STATUS\G
2
3
2个从机同样操作
**两个关键进程:**下面两个参数都是Yes,则说明主从配置成功!
# 实现主从同步
在主机
中执行以下SQL,在从机中查看数据库、表和数据是否已经被同步
CREATE DATABASE db_user;
USE db_user;
CREATE TABLE t_user (
id BIGINT AUTO_INCREMENT,
uname VARCHAR(30),
PRIMARY KEY (id)
);
INSERT INTO t_user(uname) VALUES('zhang3');
INSERT INTO t_user(uname) VALUES(@@hostname);
2
3
4
5
6
7
8
9
# 停止和重置
需要的时候,可以使用如下SQL语句
-- 在从机上执行。功能说明:停止I/O 线程和SQL线程的操作。
stop slave;
-- 在从机上执行。功能说明:用于删除SLAVE数据库的relaylog日志文件,并重新启用新的relaylog文件。
reset slave;
-- 在主机上执行。功能说明:删除所有的binglog日志文件,并将日志索引文件清空,重新开始所有新的日志文件。
-- 用于第一次进行搭建主从库时,进行主库binlog初始化工作;
reset master;
2
3
4
5
6
7
8
9
# 常见问题
点击查看
# 问题1
启动主从同步后,常见错误是Slave_IO_Running: No 或者 Connecting
的情况,此时查看下方的 Last_IO_ERROR
错误日志,根据日志中显示的错误信息在网上搜索解决方案即可
典型的错误例如:Last_IO_Error: Got fatal error 1236 from master when reading data from binary log: 'Client requested master to start replication from position > file size'
解决方案:
-- 在从机停止slave
SLAVE STOP;
-- 在主机查看mater状态
SHOW MASTER STATUS;
-- 在主机刷新日志
FLUSH LOGS;
-- 再次在主机查看mater状态(会发现File和Position发生了变化)
SHOW MASTER STATUS;
-- 修改从机连接主机的SQL,并重新连接即可
2
3
4
5
6
7
8
9
10
# 问题2
启动docker容器后提示 WARNING: IPv4 forwarding is disabled. Networking will not work.
此错误,虽然不影响主从同步的搭建,但是如果想从远程客户端通过以下方式连接docker中的MySQL则没法连接
C:\Users\administrator>mysql -h 192.168.100.201 -P 3306 -u root -p
解决方案:
#修改配置文件:
vim /usr/lib/sysctl.d/00-system.conf
#追加
net.ipv4.ip_forward=1
#接着重启网络
systemctl restart network
2
3
4
5
6
# 2. ShardingSphere-JDBC读写分离
# 2.1 创建SpringBoot程序
# 代码实现
点击查看
创建项目
项目类型:Spring Initializr
SpringBoot脚手架:http://start.aliyun.com
项目名:sharding-jdbc-demo
SpringBoot版本:2.3.12.RELEASE
添加依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
<version>5.1.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.3.1</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>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
创建实体类
@TableName("t_user")
@Data
public class User {
@TableId(type = IdType.AUTO)
private Long id;
private String uname;
}
2
3
4
5
6
7
创建Mapper
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
2
3
# 配置读写分离 😄
shardingsphere用户手册:文档地址 (opens new window)
SpringBoot环境下配置
配置真实数据源:文档地址 (opens new window)
application.properties:
点击查看
# 应用名称
spring.application.name=sharging-jdbc-demo
# 开发环境设置
spring.profiles.active=dev
# 内存模式
spring.shardingsphere.mode.type=Memory
# 配置真实数据源
spring.shardingsphere.datasource.names=master,slave1,slave2
# 配置第 1 个数据源
spring.shardingsphere.datasource.master.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.master.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.master.jdbc-url=jdbc:mysql://192.168.47.129:3306/db_user
spring.shardingsphere.datasource.master.username=root
spring.shardingsphere.datasource.master.password=123456
# 配置第 2 个数据源
spring.shardingsphere.datasource.slave1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.slave1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.slave1.jdbc-url=jdbc:mysql://192.168.47.129:3307/db_user
spring.shardingsphere.datasource.slave1.username=root
spring.shardingsphere.datasource.slave1.password=123456
# 配置第 3 个数据源
spring.shardingsphere.datasource.slave2.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.slave2.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.slave2.jdbc-url=jdbc:mysql://192.168.47.129:3308/db_user
spring.shardingsphere.datasource.slave2.username=root
spring.shardingsphere.datasource.slave2.password=123456
# 读写分离类型,如: Static,Dynamic
# <readwrite-splitting-data-source-name>:myds
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.type=Static
# 写数据源名称
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.props.write-data-source-name=master
# 读数据源名称,多个从数据源用逗号分隔
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.props.read-data-source-names=slave1,slave2
# 负载均衡算法名称
# myds:自定义的名称
# 负载均衡时候使用那个算法切换那个算法名称(对应负载均衡算法配置)
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.load-balancer-name=alg_round
#spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.load-balancer-name=alg_random
#spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.load-balancer-name=alg_weight
# 负载均衡算法配置
# 负载均衡算法类型 轮询算法:ROUND_ROBIN;随机访问算法:RANDOM;权重访问算法:WEIGHT
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_round.type=ROUND_ROBIN
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_random.type=RANDOM
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_weight.type=WEIGHT
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_weight.props.slave1=1
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_weight.props.slave2=2
# 打印SQl
spring.shardingsphere.props.sql-show=true
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
# 2.2. 测试
# 读写分离测试
@SpringBootTest
class ReadwriteTest {
@Autowired
private UserMapper userMapper;
/**
* 写入数据的测试
*/
@Test
public void testInsert(){
User user = new User();
user.setUname("张三丰");
userMapper.insert(user);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 事务测试 😈
为了保证主从库间的事务一致性,避免跨服务的分布式事务,ShardingSphere-JDBC的主从模型中,事务中的数据读写均用主库
。
- 不添加@Transactional:insert对主库操作,select对从库操作
/**
* 事务测试
*/
@Test
public void testTrans(){
User user = new User();
user.setUname("铁锤");
userMapper.insert(user);
List<User> users = userMapper.selectList(null);
}
2
3
4
5
6
7
8
9
10
11
12
- 添加@Transactional:则insert和select均对主库操作
/**
* 事务测试
*/
@Transactional//开启事务
@Test
public void testTrans(){
User user = new User();
user.setUname("铁锤");
userMapper.insert(user);
List<User> users = userMapper.selectList(null);
}
2
3
4
5
6
7
8
9
10
11
12
13
注意:在JUnit环境下的@Transactional注解,默认情况下就会对事务进行回滚(即使在没加注解@Rollback,也会对事务回滚)
# 负载均衡-轮询算法测试
配置文件配置的负载均衡是:轮询算法
/**
* 读数据测试
*/
@Test
public void testSelectAll(){
List<User> users1 = userMapper.selectList(null);
List<User> users2 = userMapper.selectList(null);//执行第二次测试负载均衡
List<User> users3 = userMapper.selectList(null);//执行第三次测试负载均衡
List<User> users4 = userMapper.selectList(null);//执行第四次测试负载均衡
}
2
3
4
5
6
7
8
9
10
也可以在web请求中测试负载均衡
@RestController
@RequestMapping("/userController")
public class UserController {
@Autowired
private UserMapper userMapper;
/**
* 测试负载均衡策略
*/
@GetMapping("selectAll")
public void selectAll(){
List<User> users1 = userMapper.selectList(null);
List<User> users2 = userMapper.selectList(null);//执行第二次测试负载均衡
List<User> users3 = userMapper.selectList(null);//执行第三次测试负载均衡
List<User> users4 = userMapper.selectList(null);//执行第四次测试负载均衡
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
访问:http://localhost:8888/userController/selectAll
# 负载均衡-随机访问算法
注意:修改配置文件修改到随机访问算法
访问:http://localhost:8888/userController/selectAll
# 负载均衡-权重访问算法
注意:修改配置文件修改到权重访问算法
访问:http://localhost:8888/userController/selectAll