ShardingSphere（分库分表）

ShardingSphere

高性能架构模式

读写分离架构：

基本原理是将数据库读写操作分散到不同的节点上，主库负责处理事务性的增删改操作，从库负责处理查询操作。避免由数据更新导致的行锁，来提升性能。

一主一从：可以将查询请求均匀的分散到多个数据副本，提交性能。

多主多从：提升系统的吞吐量，还提升系统的可用性，当一台数据库宕机，备机启动，业务也正常执行。

CAP 理论：

在一个分布式系统中，当涉及读写操作时，只能保证一致性（Consistence）、可用性（Availability）、分区容错性（Partition Tolerance）三者中的两个，另外一个必须被牺牲。

• AP：保证一致性，当N1 节点上的数据已经更新到 y，由 N1 和 N2 之间的通断中断，N2 节点上的数据还是 x，这时客户端访问N2节点，客户端提示发生了错误，这种处理方式，就违背了可用性。
• CP：保证可用性，当N1 节点上的数据已经更新到 y，由 N1 和 N2 之间的通断中断，N2 节点上的数据还是 x，这时客户端访问N2节点，会返回 x，虽然不是一个“正确”的结果，但是一个“合理”的结果，因为 x 是旧的数据，并不是一个错乱的值。

数据库分片

• 读写分离：读写分离分散了数据库读写操作的压力，但没有分散存储压力。
• 数据分片：将存放在单一数据库中的数据分散地存放至多个数据库或表中，数据分片的拆分方式又分为：垂直分片和水平分盘。

垂直分片

当我们单表行数，如果超过500万或者超过2GB，建议分库分表操作。

垂直分库：按照业务拆分的方式称为垂直分片，又称为（纵向拆分），一个数据库由多个数据表构成，每个表对应着不同的业务。而拆分之后，则是按照业务将表进行归类，分布到不同的数据库中。

例子：
-- 用户表、订单表...放在同一个数据库中。
select * from 用户表;
select * from 订单表;-- 用户表、放一个数据库中。 select * from 用户表;
-- 订单表、放一个数据库中。 select * from 订单表;

垂直拆分可以缓解数据量和访问量带来的问题，但不能解决存储压力。

垂直分表：

例子：
-- 一个用户表，拆分用户详情表，它们的关系是一对一的关系，就是垂直分表。
-- 当我们表很大的时候，需要垂直分表。
-- 水平分表适合表行数特别大的表，水平分表属于水平分片`

水平分片

水平分片又称为横向拆分，当单表超过500万条，需要考虑水平分片，分为水平分表和水平分库；不再将数据根据业务逻辑分类，而是根据某个字段，根据某种规则将数据分散至多个库或表中。

• **水平分表：**单表切分为多表后，新的表在同一个数据库服务器中。

• **水平分库：**如果单表拆分为多表后，单台服务器依然无法满足性能要求，需要将多个表分散在不同的数据库服务器中。

例子：
-- 水平分表。
select * from 用户表 where id = 1;  
-- id % 2 = 1 存一个表，  （同一个数据库）
-- id % 2 = 0 存另一个表，（同一个数据库）-- 水平分库。
select * from 用户表 where id = 1;
-- id % 2 = 1 存一个表，  （不同一个数据库）
-- id % 2 = 0 存另一个表，（不同一个数据库）

常用解决方案：

• Apache ShardingSphere（程序级别和中间件级别）

• MyCat（数据库中间件） - 中间件封装指的是独立一套系统出来

ShardingSphere

官网：https://shardingsphere.apache.org/index_zh.html

文档：https://shardingsphere.apache.org/document/5.1.1/cn/overview/

• ShardingSphere-JDBC：代码封装，在JDBC层提供的框架，客户端直连接数据库，以jar包形式提供服务。
• ShardingSphere-Proxy：中间件封装，目前提供 MySQL 和 PostgreSQL版本。

前提要求

一. 数据库配置

需要准备3台Mysql数据库，完成一主多的配置；

配置文档：https://blog.csdn.net/yanshengren520/article/details/136771432

• 主服务器：容器名mysql-master，端口3306
• 从服务器：容器名mysql-slave1，端口3307
• 从服务器：容器名mysql-slave2，端口3308

二. 创建项目

创建个SpringBoot项目

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

完成基本的SpringBoot项目配置（Mapper和实体的创建）

三. 配置读写分离

对应的文档配置说明：https://shardingsphere.apache.org/document/5.1.1/cn/user-manual/shardingsphere-jdbc/

配置文件：

#----------------------第一部分：模式配置 ---------------------
# 这里使用：内存模式
spring.shardingsphere.mode.type=Memory
# 以内存的模式进行配置，内存模式，该配置文件存的是（源数据信息）信息，
# 在集群模式下，该配置文件（源数据信息）会被持久化，在多个服务之间共享数据。内存模式就是将该配置文件加载到内存中。
# 打印SQl
spring.shardingsphere.props.sql-show=true#----------------------第二部分：数据源配置 ---------------------
# 配置真实数据源  (这里只是分别起名)
# master代表主库，slave1，slave2是从库（完成一主多从的配置）
spring.shardingsphere.datasource.names=master,slave1,slave2# 配置第 1 个数据源
# 这里的 master与上面的master第一个名字对应
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://xxxIP地址:3306/db
spring.shardingsphere.datasource.master.username=root
spring.shardingsphere.datasource.master.password=123456# 配置第 2 个数据源
# 同上，需要注意：slave1与上面名字保持一致
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://xxxIP地址:3307/db
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://xxxIP地址:3308/db
spring.shardingsphere.datasource.slave2.username=root
spring.shardingsphere.datasource.slave2.password=123456#----------------------第三部分：规则配置 ---------------------
# 【规则配置】 - 读写分离的配置
# 读写分离类型，如: Static （上面的数据源配置是写死，不是动态获取的，写Static），Dynamic
# 读写分离的数据源名字 ，
#    例子：spring.shardingsphere.rules.readwrite-splitting.data-sources.<这里可起该数据源的名字>.type=Static
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.type=Static
# 写数据源名称有哪些：（master代表）
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
# 负载均衡算法名称 (可以自己起名字，然后根据下面的算法配置，选择要使用的算法)
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.load-balancer-name=yan_random# 负载均衡算法配置：算法有：ROUND_ROBIN 轮询算法 、RANDOM 随机访问算法、WEIGHT 权重访问算法。
#   例子：spring.shardingsphere.rules.readwrite-splitting.load-balancers.<这里写上面起的算法名字>.type=ROUND_ROBIN
# 轮询算法配置
spring.shardingsphere.rules.readwrite-splitting.load-balancers.yan_robin.type=ROUND_ROBIN
# 随机访问算法配置
spring.shardingsphere.rules.readwrite-splitting.load-balancers.yan_random.type=RANDOM
# 权重访问算法配置
spring.shardingsphere.rules.readwrite-splitting.load-balancers.yan_weight.type=WEIGHT
spring.shardingsphere.rules.readwrite-splitting.load-balancers.yan_weight.props.slave1=1
spring.shardingsphere.rules.readwrite-splitting.load-balancers.yan_weight.props.slave2=2

四. 配置垂直分片

#----------------------第一部分：模式配置 ---------------------
# 这里使用：内存模式
spring.shardingsphere.mode.type=Memory
# 打印SQl
spring.shardingsphere.props.sql-show=true#----------------------第二部分：数据源配置 ---------------------
# 配置真实数据源  (这里只是分别起名) （代表不同的数据库）
spring.shardingsphere.datasource.names=server-order,server-user
# 配置第 1 个数据源
# 这里的 master与上面的master第一个名字对应
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://xxxIP地址:3306/db
spring.shardingsphere.datasource.server-order.username=root
spring.shardingsphere.datasource.server-order.password=123456
# 配置第 2 个数据源
# 同上，需要注意：slave1与上面名字保持一致
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://xxxIP地址:3306/db
spring.shardingsphere.datasource.server-user.username=yan
spring.shardingsphere.datasource.server-user.password=123456#----------------------第三部分：规则配置 ---------------------
#【规则配置】 - 垂直分片的配置
# 标准分片表配置
# 值由：数据源名 + 表名组成，以小数点分隔。 <table-name>：逻辑表名由：在实体类的@TableName注解，就是逻辑表
# 支持 inline 表达式。在水平分片里，有配置
# 例子：spring.shardingsphere.rules.sharding.tables.<逻辑表名>.actual-data-nodes=数据源.真实的表
spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=server-order.t_order
spring.shardingsphere.rules.sharding.tables.t_user.actual-data-nodes=server-user.t_user# 垂直分片：相当于一个服务，多各数据源

五. 配置水平分片

水平分库的配置

#----------------------第一部分：模式配置 ---------------------
# 这里使用：内存模式
spring.shardingsphere.mode.type=Memory
# 打印SQl
spring.shardingsphere.props.sql-show=true
#----------------------第二部分：数据源配置 ---------------------
# 配置真实数据源  (这里只是分别起名)
# （代表不同的数据库）
spring.shardingsphere.datasource.names=server-user,server-order1,server-order2
# 配置第 1 个数据源
# 这里的 master与上面的master第一个名字对应
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://xxxIP地址:3306/db
spring.shardingsphere.datasource.server-order1.username=root
spring.shardingsphere.datasource.server-order1.password=123456
# 配置第 2 个数据源
# 同上，需要注意：slave1与上面名字保持一致
spring.shardingsphere.datasource.server-order2.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-order2.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-order2.jdbc-url=jdbc:mysql://xxxIP地址:3306/db
spring.shardingsphere.datasource.server-order2.username=yan
spring.shardingsphere.datasource.server-order2.password=123456
# 配置第 3 个数据源
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://xxxIP地址:3306/db
spring.shardingsphere.datasource.server-user.username=root
spring.shardingsphere.datasource.server-user.password=123456#----------------------第三部分：规则配置 ---------------------
# 【规则配置】 - 水平分片的配置
# 标准分片表配置
# 值由：数据源名 + 表名组成，以小数点分隔。 <table-name>：逻辑表名由：在实体类的@TableName注解，就是逻辑表
# 例子：spring.shardingsphere.rules.sharding.tables.<逻辑表名>.actual-data-nodes=数据源.真实的表
#spring.shardingsphere.rules.sharding.tables.t_user.actual-data-nodes=server-user.t_user# 准备：server-order1数据源中有2个表（t_order1 和 t_order2）和 server-order2数据源中有2个表（t_order1 和 t_order2）# 测试 - server-order1的数据源是否ok
#spring.shardingsphere.rules.sharding.tables.t_c_order.actual-data-nodes=server-order1.t_order1# 测试 - server-order2的数据源是否ok
#spring.shardingsphere.rules.sharding.tables.t_c_order.actual-data-nodes=server-order2.t_order1# 测试 - 全部配置
#spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=server-order1.t_order1,server-order1.t_order2,server-order2.t_order1,server-order2.t_order2

行表达式的inline 表达式配置

规则地址：https://shardingsphere.apache.org/document/5.1.1/cn/features/sharding/concept/inline-expression/

取模分片

# 测试 水平分库的配置
# 第一部分和第二部分，同上
#----------------------第三部分：规则配置 ---------------------
# 【规则配置】 - 水平分片的配置
# 测试 - 该配置支持 inline 表达式。注意：t_c_order是逻辑表
# 测试 - 解析数据节点是:server-order1和server-order2,他们分别有t_order1的表
spring.shardingsphere.rules.sharding.tables.t_c_order.actual-data-nodes=server-order$->{1..2}.t_order1
# 测试 - 水平分库：
# 分片规则：表中`user_id`为偶数时，数据插入`server-order1数据源`，`user_id`为奇数时，数据插入`server-order2数据源`
# 分库策略 - 取模分片算法
# 分片列名称，以什么字段
spring.shardingsphere.rules.sharding.tables.t_c_order.database-strategy.standard.sharding-column=user_id# 分库策略：
# 分片列名称，以什么字段
spring.shardingsphere.rules.sharding.tables.t_c_order.database-strategy.standard.sharding-column=user_id
# 分片算法名称 (可以自己起名字，然后根据下面的算法配置，选择要使用的算法)
spring.shardingsphere.rules.sharding.tables.t_c_order.database-strategy.standard.sharding-algorithm-name=alg_mod
#
# 分片算法类型 （alg_inline_userid）名字与上面的（分片算法名称）保持一致
# 算法1： - 行表达式分片算法: INLINE
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_inline.type=INLINE
# 分片算法属性配置 ，值：是表达式，规则是：数据源.某个字段进行（取模分片算法），因为server-order数据源从1开始，需要+1操作
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_inline.props.algorithm-expression=server-order$->{user_id % 2 +1}
#
# 算法2： - 取模分片算法: MOD
# 分片算法类型
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_mod.type=MOD
# 分片算法属性配置。这个配置，需要数据源从0开始
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_mod.props.sharding-count=2

哈希取模分片

# 测试 水平分库+分表的配置
# 第一部分和第二部分，同上
#----------------------第三部分：规则配置 ---------------------
# 【规则配置】 - 水平分片的配置
# 测试 - 该配置支持 inline 表达式。注意：t_c_order是逻辑表
spring.shardingsphere.rules.sharding.tables.t_c_order.actual-data-nodes=server-order$->{1..2}.t_order$->{0..1}
# 测试 - 水平分库：分片规则：表中`user_id`为偶数时，数据插入`server-order1数据源`，
#                           `user_id`为奇数时，数据插入`server-order2数据源`
#     - 水平分表：分片规则：表中`order_no`是字符串，进行哈希取模，
#                        哈希值为偶数时，插入到t_order0中，
#                               奇数插入到t_order1表中。
# --------- 分库策略：
# 分片列名称，以什么字段（进行分库）.逻辑表.database-xxx
spring.shardingsphere.rules.sharding.tables.t_c_order.database-strategy.standard.sharding-column=user_id
# 分片算法名称 (可以自己起名字，然后根据下面的算法配置，选择要使用的算法)
spring.shardingsphere.rules.sharding.tables.t_c_order.database-strategy.standard.sharding-algorithm-name=alg_inline
#
# 分片算法类型 （alg_inline_userid）名字与上面的（分片算法名称）保持一致
# 算法1： - 行表达式分片算法: INLINE
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_inline.type=INLINE
# 分片算法属性配置 ，值：是表达式，规则是：数据源.某个字段进行（取模分片算法），因为server-order数据源从1开始，需要+1操作
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_inline.props.algorithm-expression=server-order$->{user_id % 2 +1}
#
# --------- 分表策略：
# 分片列名称，以什么字段（进行分表）.逻辑表.table-xxx
spring.shardingsphere.rules.sharding.tables.t_c_order.table-strategy.standard.sharding-column=order_no
## 分片算法名称
spring.shardingsphere.rules.sharding.tables.t_c_order.table-strategy.standard.sharding-algorithm-name=alg_hash_mod
#
## 算法：哈希取模分片算法: HASH_MOD
## 分表策略，以哈希取模分片算法（与上面的算法名称保持一致）
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_hash_mod.type=HASH_MOD
## 分片算法属性配置，有2个，配置2个分片数量
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_hash_mod.props.sharding-count=2

分片算法

分片算法有很多，官网地址：https://shardingsphere.apache.org/document/5.1.1/cn/user-manual/shardingsphere-jdbc/builtin-algorithm/sharding/#%E8%A1%8C%E8%A1%A8%E8%BE%BE%E5%BC%8F%E5%88%86%E7%89%87%E7%AE%97%E6%B3%95

有：取模分片算法、哈希取模分片算法、基于分片容量的范围分片算法、基于分片边界的范围分片算法、自动时间段分片算法、标准分片算法、时间范围分片算法、复合分片算法、Hint 分片算法、自定义类分片算法

六 分布式主键

雪花算法：

方式1：基于MyBatisPlus的id策略，在实体注解，添加该注解

@TableId(type = IdType.ASSIGN_ID)
private Long id;

方式2：ShardingSphere-JDBC的全局序列配置

# 在配置文件中配置：
# --------- 分布式主键配置 ---- 需要在实体配置对应注解 @TableId(type = IdType.AUTO)
# 分布式序列列名称（逻辑表）中的主键是：
spring.shardingsphere.rules.sharding.tables.t_c_order.key-generate-strategy.column=id
# 分布式序列算法名称
spring.shardingsphere.rules.sharding.tables.t_c_order.key-generate-strategy.key-generator-name=alg_snowflake
# 分布式序列算法类型（alg_snowflake）的名字，于上面一致
spring.shardingsphere.rules.sharding.key-generators.alg_snowflake.type=SNOWFLAKE

七 多表关联

# 测试 水平分库+分表的配置
# 第一部分和第二部分，同上
#----------------------第三部分：规则配置 ---------------------
# 标准分片表配置（数据节点配置）
spring.shardingsphere.rules.sharding.tables.t_c_order.actual-data-nodes=server-order$->{1..2}.t_order$->{0..1}
spring.shardingsphere.rules.sharding.tables.t_order_item.actual-data-nodes=server-order$->{1..2}.t_order_item$->{0..1}
#
# --------- 分库策略：
# 分片列名称
spring.shardingsphere.rules.sharding.tables.t_c_order.database-strategy.standard.sharding-column=user_id
spring.shardingsphere.rules.sharding.tables.t_c_order.database-strategy.standard.sharding-algorithm-name=alg_mod
# 配置t_order_item的逻辑表的 分库策略，（与t_c_order一致）
spring.shardingsphere.rules.sharding.tables.t_order_item.database-strategy.standard.sharding-column=user_id
spring.shardingsphere.rules.sharding.tables.t_order_item.database-strategy.standard.sharding-algorithm-name=alg_mod
#
# --------- 分表策略：
# 分片列名称
spring.shardingsphere.rules.sharding.tables.t_c_order.table-strategy.standard.sharding-column=order_no
# 分片算法名称
spring.shardingsphere.rules.sharding.tables.t_c_order.table-strategy.standard.sharding-algorithm-name=alg_hash_mod
# 配置t_order_item的逻辑表的 分表策略，（与t_c_order一致）
spring.shardingsphere.rules.sharding.tables.t_order_item.table-strategy.standard.sharding-column=order_no
spring.shardingsphere.rules.sharding.tables.t_order_item.table-strategy.standard.sharding-algorithm-name=alg_hash_mod
#
# --------- 分布式主键配置：
# 分布式序列列名称
spring.shardingsphere.rules.sharding.tables.t_c_order.key-generate-strategy.column=id
# 分布式序列算法名称
spring.shardingsphere.rules.sharding.tables.t_c_order.key-generate-strategy.key-generator-name=alg_snowflake
# 配置t_order_item的逻辑表的 主键策略，（与t_c_order一致）
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.binding-tables[0]=t_order,t_order_item

如果不配置绑定表，查询是有多少数据库，每张表查询不同的表，配置绑定表，查询根据配置规则去查询，从而效率提升。

九 广播表

所有的分片数据源中都存在的表，表结构及其数据在每个数据库中均完全一致。

# 测试 水平分库+分表的配置
# 第一部分和第二部分，同上，字典表 - t_dict
#----------------------第三部分：规则配置 ---------------------
# --------- 配置广播表 （每个数据源，都要添加，去掉相同的数据源）
spring.shardingsphere.rules.sharding.tables.t_dict.actual-data-nodes=server-order$->{1..2}.t_dict
# 广播表配置
spring.shardingsphere.rules.sharding.broadcast-tables[0]=t_dict
# 这样保证，添加数据，每个库都有该表，同样的数据; 查询数据，随机负载均衡规则，只从一个节点获取数据

ShardingSphere-Proxy

获取方式：

• 二进制发布包

  地址：https://shardingsphere.apache.org/document/5.1.1/cn/downloads/

• Docker

• Helm

使用二进制发布包安装

步骤1：下载解压包

该apache-shardingsphere-5.1.1-shardingsphere-proxy-bin.tar.gz可以Linux系统运行，又可以在windows系统运行。

Linux：将文件上传至/opt目录，并解压

tar -zxvf apache-shardingsphere-5.1.1-shardingsphere-proxy-bin.tar.gz

windows：使用解压软件解压文件，就可以

步骤2：添加MySQL驱动

解压文件后，在bin的同目录下，创建ext-lib目录，放Mysql的驱动包

mysql-connector-java-8.0.22.jar

步骤3：修改配置文件

该配置文件：conf/server.yaml

# 放开这里，AUTHORITY是用户认证相关配置
# root@%:root 用户名和密码，%代表任何服务器都可以访问
# provider 下的 ALL_PRIVILEGES_PERMITTED 代表所有的访问权限
rules:- !AUTHORITYusers:- root@%:root
#      - sharding@:shardingprovider:type: ALL_PRIVILEGES_PERMITTED
# ...
# 开启这个，sql-show: true 打印SQL语句
props:
#  max-connections-size-per-query: 1
# ...sql-show: false

步骤4：进行启动

Linux 操作系统请运行 bin/start.sh
Windows 操作系统请运行 bin/start.bat
指定端口号和配置文件目录：bin/start.bat ${proxy_port} ${proxy_conf_directory}

# windows里启动方式，双击，关闭就关闭窗口就可以 --- start.bat
# Linux里启动方式，-- start.sh
# Linux里关闭服务  -- stop.sh
# --------------
# 在bin目录进行cmd运行windows启动，默认端口是3307
start.bat

启动成功

进行访问，就像登录mysql数据库一样

mysql -h127.0.0.1 -P3307 -uroot -p 
# 输入密码

使用Docker安装

步骤1：启动容器

docker run -d \
-v /xxx/server/proxy-a/conf:/opt/shardingsphere-proxy/conf \
-v /xxx/server/proxy-a/ext-lib:/opt/shardingsphere-proxy/ext-lib \
-e ES_JAVA_OPTS="-Xmx256m -Xms256m -Xmn128m" \
-p 3321:3307 \
--name server-proxy-a \
apache/shardingsphere-proxy:5.1.1
# 宿主机映射，conf是配置文件目录，ext-lib是添加MySQL驱动的目录
# -e 是由于需要大量的内存，调试阶段，可以把内存设置小点
# server-proxy-a 是该容器的名字
# 3321 映射的端口号，对外连接的端口号

步骤2：配置MySQL驱动

将MySQl驱动包上传到/xxx/server/proxy-a/ext-lib目录下。

步骤3：修改配置文件

该配置文件：conf/server.yaml，该配置文件上传到/xxx/server/proxy-a/conf目录下。

# 放开这里，AUTHORITY是用户认证相关配置
# root@%:root 用户名和密码，%代表任何服务器都可以访问
# provider 下的 ALL_PRIVILEGES_PERMITTED 代表所有的访问权限
rules:- !AUTHORITYusers:- root@%:root
#      - sharding@:shardingprovider:type: ALL_PRIVILEGES_PERMITTED
# ...
# 开启这个，sql-show: true 打印SQL语句
props:
#  max-connections-size-per-query: 1
# ...sql-show: false

步骤4：重启容器

docker restart server-proxy-a

步骤5：远程连接

mysql -h对应的IP地址 -P3321 -uroot -p

常见问题

容器可以成功的创建并启动，但是无法远程连接，排除防火墙和网络等问题后，可能是容器可分配内存不足导致。

# 进入容器
docker exec -it server-proxy-a env LANG=C.UTF-8 /bin/bash
# 查看日志，如果有`cannot allocate memory`代表容器内存不足
cd /opt/shardingsphere-proxy/logs
# 查看日志
tail stdout.log 

配置读写分离

修改配置：config-readwrite-splitting.yaml

# 虚拟中间件的表
schemaName: readwrite_splitting_dbdataSources:write_ds:url: jdbc:mysql://xxxIP地址:3306/db?serverTimezone=UTC&useSSL=falseusername: rootpassword: yanshengrenconnectionTimeoutMilliseconds: 30000idleTimeoutMilliseconds: 60000maxLifetimeMilliseconds: 1800000maxPoolSize: 50minPoolSize: 1read_ds_0:url: jdbc:mysql://xxxIP地址:3307/db?serverTimezone=UTC&useSSL=falseusername: rootpassword: 123456connectionTimeoutMilliseconds: 30000idleTimeoutMilliseconds: 60000maxLifetimeMilliseconds: 1800000maxPoolSize: 50minPoolSize: 1read_ds_1:url: jdbc:mysql://xxxIP地址:3308/db?serverTimezone=UTC&useSSL=falseusername: rootpassword: 123456connectionTimeoutMilliseconds: 30000idleTimeoutMilliseconds: 60000maxLifetimeMilliseconds: 1800000maxPoolSize: 50minPoolSize: 1rules:
- !READWRITE_SPLITTINGdataSources:readwrite_ds:type: Staticprops:write-data-source-name: write_dsread-data-source-names: read_ds_0,read_ds_1

实时查看日志

# 默认的日志文件，可以查看具体sql语句
tail -f /xxx/shardingsphere-proxy/logs/stdout.log 

应用程序访问Proxy

跟其他服务访问mysql一样

# 对应的配置文件
# 应用名称
spring.application.name=sharding-proxy-xxx
# 开发环境设置
spring.profiles.active=dev#mysql数据库连接（proxy）
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# 虚拟中间件的表，跟上面的配置一样 - readwrite_splitting_db
spring.datasource.url=jdbc:mysql://127.0.0.1:3307/readwrite_splitting_db?serverTimezone=GMT%2B8&useSSL=false
spring.datasource.username=root
spring.datasource.password=root#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

垂直分片

修改配置config-sharding.yaml

schemaName: sharding_dbdataSources:ds_0:url: jdbc:mysql://xxxIP地址:3301/db?serverTimezone=UTC&useSSL=falseusername: rootpassword: 123456connectionTimeoutMilliseconds: 30000idleTimeoutMilliseconds: 60000maxLifetimeMilliseconds: 1800000maxPoolSize: 50minPoolSize: 1ds_1:url: jdbc:mysql://xxxIP地址:3302/db?serverTimezone=UTC&useSSL=falseusername: rootpassword: 123456connectionTimeoutMilliseconds: 30000idleTimeoutMilliseconds: 60000maxLifetimeMilliseconds: 1800000maxPoolSize: 50minPoolSize: 1rules:
- !SHARDINGtables:t_user:actualDataNodes: ds_0.t_usert_order:actualDataNodes: ds_1.t_order

水平分片

修改配置config-sharding.yaml

schemaName: sharding_dbdataSources:ds_user:url: jdbc:mysql://xxxIP地址:3301/db?serverTimezone=UTC&useSSL=falseusername: rootpassword: 123456connectionTimeoutMilliseconds: 30000idleTimeoutMilliseconds: 60000maxLifetimeMilliseconds: 1800000maxPoolSize: 50minPoolSize: 1ds_order0:url: jdbc:mysql://xxxIP地址:3310/db?serverTimezone=UTC&useSSL=falseusername: rootpassword: 123456connectionTimeoutMilliseconds: 30000idleTimeoutMilliseconds: 60000maxLifetimeMilliseconds: 1800000maxPoolSize: 50minPoolSize: 1ds_order1:url: jdbc:mysql://xxxIP地址:3311/db?serverTimezone=UTC&useSSL=falseusername: rootpassword: 123456connectionTimeoutMilliseconds: 30000idleTimeoutMilliseconds: 60000maxLifetimeMilliseconds: 1800000maxPoolSize: 50minPoolSize: 1# 具体配置，跟ShardingSphere一样
rules:
- !SHARDINGtables:t_user:actualDataNodes: ds_user.t_usert_order:actualDataNodes: ds_order${0..1}.t_order${0..1}databaseStrategy:standard:shardingColumn: user_idshardingAlgorithmName: alg_modtableStrategy:standard:shardingColumn: order_noshardingAlgorithmName: alg_hash_modkeyGenerateStrategy:column: idkeyGeneratorName: snowflaket_order_item:actualDataNodes: ds_order${0..1}.t_order_item${0..1}databaseStrategy:standard:shardingColumn: user_idshardingAlgorithmName: alg_modtableStrategy:standard:shardingColumn: order_noshardingAlgorithmName: alg_hash_modkeyGenerateStrategy:column: idkeyGeneratorName: snowflakebindingTables:- t_order,t_order_itembroadcastTables:- t_dictshardingAlgorithms:alg_inline_userid:type: INLINEprops:algorithm-expression: server-order$->{user_id % 2}alg_mod:type: MODprops:sharding-count: 2alg_hash_mod:type: HASH_MODprops:sharding-count: 2keyGenerators:snowflake:type: SNOWFLAKE