ShardingSphere-JDBC使用笔记

一. mysql的主从同步配置

1.一主多从配置

1.1 配置主服务器

在docker中创建并启动mysql主服务器端口 3306
- 创建数据库服务
- ```
docker run -d \
-p 3306:3306 \
-v /atuser/mysql/master/conf:/etc/mysql/conf.d \
-v /atuser/mysql/master/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name atuser-mysql-master \
mysql:8.0.29
```
- 创建mysql主服务器配置文件：
  
  默认情况下mysql的binlog日志是自动开启的，可以通过如下配置定义一些可选配置
```
vim /atuser/mysql/master/con/my.cof
```
  配置内容如下
```
[mysqld]
#服务器的唯一id,默认值为1
server-id=1
#设置日志格式，默认值ROW
binlog_format=STATEMENT
#二进制日志名，默认复制全部数据库
#binlog-do-db=mytestdb
#设置不需要复制的数据库
#binlog-ignore-db=mysql
#binlog-ignore-db=infomation_schema
```
  重启mysql容器
```
dock er restert atuser-mysql-master
```
  binlog格式说明
  - binlog_format=STATEMENT:日志记录的是主机数据库的写命令，性能高，但now()之类的函数以及获取系统参数的操作会出现主从数据不同步的问题，
  - binlog_format=ROW（默认）：日志记录的是主机数据库写后的数据，批量操作时性能较差，解决now()或者user()或者@@hostname等操作在主从机器上不一致的问题。
  - Binlog_format=MIXED:是以上两种level的混合使用，有函数的用ROW，没有函数的用STATEMENT,但是无法识别系统变量

主机中创建slave用户

创建slave用户
```
CREATE USER 'atuser_slave'@'%';
```
设置密码

ALTER USER ‘root’@'%' IDENTIFIED WITH mysql_native_password BY 'abc123456'

赋予复制权限

CGRANT REPLICATION SLAVE ON *.* TO 'atuser_slave'@'%';

刷新权限
```
FLUSH PRIVILEGES;
```

主机中查询master状态

执行完此步骤后不要再操作主服务器mysql，防止服务器状态值变化
```
SHOW MASTER STATUS;
```
记下File和Position的值

1.2 准备从服务器

创建从数据库

docker run -d \
-p 3307:3306 \
-v /atuser/mysql/slave1/conf:/etc/mysql/conf.d \
-v /atuser/mysql/slave1/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name atuser-mysql-slave1 \
mysql:8.0.29

创建从服务器配置文件

vim /atuser/mysql/master/con/my.cof

配置如下内容

[mysqld]
#服务器的唯一id,每台服务器的id必须不同，如果配置其他从服务器，注意修改id
server-id=2
#中继日志名，默认XXXXXXXXXXX-relay-bin
#relay-log=relay-bin

重启mysql容器
```
docker restart atuser-mysql-slave1
```

使用命令行登录mysql从服务器

#进入容器
docker exec -it atuser-mysql-slave1 env LANG=C.UTF-8 /bin/bash
进入容器内的mysql命令行
mysql -uroot -p
#修改默认的密码校验方式
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY 'abc123456';

在从机上配置主从关系

在从机上执行一下sql操作

CHANGE MASTER TO MASTER_HOST='192.168.100.201',
MASTER_USER='atuser_slave',MASTER_PASSWORD='123456',MASTER_PORT=3306,
MASTER_LOG_FILE='binlog.000003',MASTER_LOG_POS=1357;

1.3 启动主从同步

启动从机的复制功能，执行sql:

START SLAVE
-- 查看状态(不需要分号)
SHOW SLAVE STATUS\G

检查两个关键进程：如果参数都是Yes,说明主从配置成功

Slave_IO_Running:Yes
SLave_SQL_Running:Yes

1.4 停止和重置

需要的时候，可以使用如下sql语句

-- 在主机上执行，功能说明，停止IO县城和sql线程的操作
stop Slave;
-- 在从机上执行，功能说明，用于删除slave数据库和relayLog日志文件，并重新启用新的RelayLog文件
reset Slave;
-- 在主机上执行，功能说明，删除所有的binlog日志文件，并将日志索引文件清空，重新开始所有的新的日志文件
-- 用于第一次进行搭建主从库时，进行主库binlog初始化工作；
reser master;

2. 常见问题

典型的错误1：

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

启动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

二. ShardingSphere-JDBC项目的读写分离配置

1. 引入pom文件

<dependency><groupId>org.apache.shardingsphere</groupId><artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId><version>5.1.1</version>
</dependency>

2. 添加配置文件

spring.shardingsphere.mode.type=Memory #内存模式 保存的是元数据信息

shardingSphere的运行模式有三种：内存模式、单机模式、集群模式;

数据源配置:

#配置真实数据源
spring.shardingsphere.datasource.names=master,slave1,slave2# 主数据源
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://localhost:3306/db_user
spring.shardingsphere.datasource.master.username=root
spring.shardingsphere.datasource.master.password=123456# 从数据源1
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://localhost:3307/db_user
spring.shardingsphere.datasource.slave1.username=root
spring.shardingsphere.datasource.slave1.password=123456# 从数据源2
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://localhost:3308/db_user
spring.shardingsphere.datasource.slave2.username=root
spring.shardingsphere.datasource.slave2.password=123456# 读写分离类型 static静态 Dynamic动态
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.type=static
# 写数据源名称
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.propes.write-data-source-name=master
# 读数据源名称,多个数据源用逗号分隔
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.propes.read-data-source-name=slave1,slave2
# 负载均衡算法名称
spring.shardingsphere.rules.readwrite-splitting.data.sources.myds.load-balancer-name=alg_round
# 负载均衡算法配置
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_round.type=RUUND_ROBIN
# 负载均衡算法类型配置
#spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_round.props.xxx=
# 打印sql
spring.shardingsphere.props.sql-show=true

为了保证主从库间的事物一致性，避免跨服务的分布式事务，shardingsphere-jdbc的主从模型中，事务中的数据读写均用主库
在junit环境下的@Transactional注解，默认情况下就会对事务进行回滚(即使在没加注解@Rollback，也会对事务进行回滚)

三. ShardingSphere-JDBC 垂直分片

1. 创建server-user数据库

1.1 创建容器

docker run -d \
-p 3301:3306 \
-v /atuser/mysql/user/conf:/etc/mysql/conf.d \
-v /atuser/mysql/user/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-user \
mysql:8.0.29

1.2 连接数据库

#进入容器
docker exec -it server-user env LANG=C.UTF-8 /bin/bash
进入容器内的mysql命令行
mysql -uroot -p
#修改默认的密码校验方式
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';

1.3 创建数据库

CREATE DATABASE db_user;
USE db_user;
CREATE TABLE t_user(id BIGINT AUTO_INCREMENT,uname VARCHAR(30),PRIMARY KEY(id)
);

2.创建server-order数据库

2.1创建容器

docker run -d \
-p 3302:3306 \
-v /atuser/mysql/order/conf:/etc/mysql/conf.d \
-v /atuser/mysql/order/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-order \
mysql:8.0.29

2.2 连接数据库

#进入容器
docker exec -it server-user env LANG=C.UTF-8 /bin/bash
进入容器内的mysql命令行
mysql -uroot -p
#修改默认的密码校验方式
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';

2.3 创建数据库

CREATE DATABASE db_order;
USE db_order;
CREATE TABLE t_user(id BIGINT AUTO_INCREMENT,order_no VARCHAR(30),user_id BIGINT,amount DECIMAL(10,2),PRIMARY KEY(id)
);

3 项目配置

application.properties文件配置如下

#配置真实数据源
spring.shardingsphere.datasource.names=server-order,server-user# 主数据源
spring.shardingsphere.datasource.server-order.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-order.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-order.jdbc-url=jdbc:mysql://localhost:3306/db_user
spring.shardingsphere.datasource.server-order.username=root
spring.shardingsphere.datasource.server-order.password=123456# 从数据源1
spring.shardingsphere.datasource.server-user.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-user.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-user.jdbc-url=jdbc:mysql://localhost:3307/db_order
spring.shardingsphere.datasource.server-user.username=root
spring.shardingsphere.datasource.server-user.password=123456# 标准分片配置
#由数据源名+表名组成，以小数点分隔，多个表以逗号分隔
spring.shardingsphere.rules.sharding.tables.t_user.actual-data-nodes=server-user.t_user
spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=server-order.t_order# 打印sql
spring.shardingsphere.props.sql-show=true

四. ShardingSphere-JDBC 水平分片

1. 准备服务器

服务器：容器名：server-order0, 端口：3310
服务器：容器名：server-order1, 端口：3311

1.1 创建server-order0 容器

。。。。。。。。。。。。

创建数据库

注意：水平分片的id需要在业务层实现，不能依赖数据库的主键子增

CREATE DATABASE db_order;
USE db_order;
CREATE TABLE t_order0(id BIGINT,order_no VARCHAR(30),user_id BIGINT,amount DECIMAL(10,2),PRIMARY KEY(id)
);
CREATE TABLE t_order0(id BIGINT,order_no VARCHAR(30),user_id BIGINT,amount DECIMAL(10,2),PRIMARY KEY(id)
);

1.2创建server-order1容器

。。。。。。。。。。。。

创建数据库

注意：水平分片的id需要在业务层实现，不能依赖数据库的主键子增

CREATE DATABASE db_order;
USE db_order;
CREATE TABLE t_order0(id BIGINT,order_no VARCHAR(30),user_id BIGINT,amount DECIMAL(10,2),PRIMARY KEY(id)
);
CREATE TABLE t_order0(id BIGINT,order_no VARCHAR(30),user_id BIGINT,amount DECIMAL(10,2),PRIMARY KEY(id)
);

2. 水平切片的项目配置

配置application.properties文件

#配置真实数据源
spring.shardingsphere.datasource.names=server-user,server-order0,server-user1# 主数据源
spring.shardingsphere.datasource.server-user.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-user.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-user.jdbc-url=jdbc:mysql://localhost:3301/db_user
spring.shardingsphere.datasource.server-user.username=root
spring.shardingsphere.datasource.server-user.password=123456# 从数据源1
spring.shardingsphere.datasource.server-order0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-order0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-order0.jdbc-url=jdbc:mysql://localhost:3310/db_order
spring.shardingsphere.datasource.server-order0.username=root
spring.shardingsphere.datasource.server-order0.password=123456# 从数据源1
spring.shardingsphere.datasource.server-order1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-order1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-order1.jdbc-url=jdbc:mysql://localhost:3311/db_order
spring.shardingsphere.datasource.server-order1.username=root
spring.shardingsphere.datasource.server-order1.password=123456# 标准分片配置
#由数据源名+表名组成，以小数点分隔，多个表以逗号分隔,支持inLine表达式
spring.shardingsphere.rules.sharding.tables.t_user.actual-data-nodes=server-user.t_user
# spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=server-order0.t_order0,server-order0.t_order1,server-order1.t_order0,server-order1 .t_order1
# 行表达式写法如下：
# 连续的编号：server-order$->{0..1}
# 指定的编号：server-order$->{[0,1]}
spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=server-order$->{0..1},server-order$->{[0,1]}# 打印sql
spring.shardingsphere.props.sql-show=true

3. 分片算法配置

3.1 分库策略

# 定义分片算法配置
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-column=user_id  #分片列名称
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-algorithm-name= alg_inline_userId #分片算法名称# 行表达式分片算法
# 分片算法类型
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_inline_userId.type=INLINE
# 分片算法属性配置
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_inline_userId.propes.algorithm-expression=server-order0$->{user_id % 2}

3.2 分表策略

# 定义分片算法配置
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-column=user_id  #分片列名称
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-algorithm-name= alg_mod #分片算法名称
# 定义分片算法配置
# 取模分片算法
# 取模分片算法类型
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_mod.type=MOD
# 分片算法属性配置
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_mod.props.sharding-count=2================
# 定义分片算法配置
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-column=user_id  #分片列名称
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-algorithm-name= alg_mod #分片算法名称
# 哈希取模分片算法
# 哈希取模分片算法类型
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_hashmod.type=HASH_MOD
# 分片算法属性配置
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_hash_mod.props.sharding-count=2

3.3 配置雪花算法生成id

# 分布式序列策略配置
# 分布式序列列名称
spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.column=id
# 分布式序列算法名称
spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.key-generator-name=alg_snowflake
# 分布式序列算法配置
# 分布式序列算法类型
spring.shardingsphere.rules.sharding.key-generators.alg_snowflake.type=SNOWFLAKE
# 分片算法属性配置
# spring.shardingsphere.rules.sharding.key-generators.alg_SNOWFLAKE.props.XXXXX=

4. 多表关联

4.1 创建关联表

在server-order0,server-order1服务器中分别创建两张订单详情表 t_order_item0,t_order_item1

我们希望同一个用户的订单表和订单详情表中的数据都在一个数据源中，避免跨库关联，因此这两张表我们使用相同的分片策略

那么在t_order_item中我们也希瑶创建order_on和user_id两个分片键

CREATE TABLE t_order_item0(id BIGINT,order_on VARCHAR(30),user_id BIGINT,price DECIMAL(10,2),`count` INT,PRIMARY KEY(id)
);
CREATE TABLE t_order_item1(id BIGINT,order_on VARCHAR(30),user_id BIGINT,price DECIMAL(10,2),`count` INT,PRIMARY KEY(id)
);

4.2 Application.properties配置文件

---------------分库策略，雀圣表示使用默认的分库策略，以下的分片策略只能选择其一
# 订单表
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.sttandard.sharding-column=user_id
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.sttandard.sharding-algorithm-name=alg_mod# 订单详情表
spring.shardingsphere.rules.sharding.tables.t_order_item.database-strategy.sttandard.sharding-column=user_id
spring.shardingsphere.rules.sharding.tables.t_order_item.database-strategy.sttandard.sharding-algorithm-name=alg_mod---------------分表策略
# 订单表
spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.sttandard.sharding-column=order_no
spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.sttandard.sharding-algorithm-name=alg_hash_mod# 订单详情表
spring.shardingsphere.rules.sharding.tables.t_order_item.table-strategy.sttandard.sharding-column=order_no
spring.shardingsphere.rules.sharding.tables.t_order_item.table-strategy.sttandard.sharding-algorithm-name=alg_hash_mod# 分片算法类型
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_inline_userId.type=INLINE
# 分片算法属性配置
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_inline_userId.propes.algorithm-expression=server-order0$->{user_id % 2}
# 哈希取模分片算法
# 哈希取模分片算法类型
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_hashmod.type=HASH_MOD
# 分片算法属性配置
spring.shardingsphere.rules.sharding.sharding-algorithmn.alg_hash_mod.props.sharding-count=2
# 订单表id 配置雪花算法
# 分布式序列策略配置
# 分布式序列列名称
spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.column=id
# 分布式序列算法名称
spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.key-generator-name=alg_snowflake
# 订单详情表的id使用雪花算法
# 分布式序列策略配置
# 分布式序列列名称
spring.shardingsphere.rules.sharding.tables.t_order_item.key-generate-strategy.column=id
# 分布式序列算法名称
spring.shardingsphere.rules.sharding.tables.t_order_item.key-generate-strategy.key-generator-name=alg_snowflake# 分布式序列算法类型
spring.shardingsphere.rules.sharding.key-generators.alg_snowflake.type=SNOWFLAKE

5. 绑定表

5.1 创建vo对象

@Data
public class OrderVo{private String orderNo;private BigDeciimal amount;
}

5.2 配置绑定表

在原来水平分片配置的基础上添加如下配置：

# -----------绑定表
spring.shardingsphere.rules.sharding.binding-tablesp[0]=t_order.t_order_item

在配置完绑定表后再次进行关联查询的测试：

如果不配置绑定表，测试结果为8个sql。多表关键查询会出现笛卡尔积关联
如果配置绑定表：测试的结果为4个SQL。多表关联查询不会出现笛卡尔积关联，关联查询效率将大大提升。

绑定表：指分片规则一直的一组分片表。使用绑定表进行多表关联查询时，必须使用分片键进行关联，否则会出现笛卡尔积关联或者跨库关联，从而影响查询效率

6.广播表

6.1 什么是广播表

指所有的分片数据源中都存在的表，表结构以及其中的数据在每个数据库中都完全一致，适用于数据量不大且需要与海量数据的表进行关联查询的场景，例如：字典表；

广播表有以下特性

插入，更新操作会实时的在所有的节点上执行，保持各个分片的数据的一致性。
查询操作，只从一个节点获取。
可以跟任何一个表进行JOIN操作。

6.2 创建广播表

在server-order0、server-order1和server-user服务器中都分别创建t_dict表

CREATE TABLE t_dict(id,BIGINT,dict_type VARCHAR(200),PRIMARY kEY(id)
);

6.3 创建实体类

@Data
publi class Dict{@TableId(type= IdType.ASSIGN_ID)private Long id;private String dicType;
}

6.4 application.properties文件配置

spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=server-order$->{0..1}.t_dict,server-user.t_dict
spring.shardingsphere.rules.sharding.broadcast-tables[0]=t_dict