【MySQL集群架构与实践5】使用Docker实现水平分片

[一. 在Docker中安装ShardingSphere](#一. 在Docker中安装ShardingSphere)

[二. 实践：水平分片](#二. 实践：水平分片)

[2.1 应用场景](#2.1 应用场景)

[2.2 架构图](#2.2 架构图)

[2.3 服务器规划](#2.3 服务器规划)

[2.4 创建server-user容器](#2.4 创建server-user容器)

[2.5 创建server-order0和server-order1容器](#2.5 创建server-order0和server-order1容器)

2.6.日志配置

[2.7 数据节点配置](#2.7 数据节点配置)

2.8.测试数据节点

2.8.1.测试server_order0.t_order0节点

2.8.2.测试server_order0.t_order1节点

2.8.3.测试server_order1.t_order0节点

2.8.4.测试server_order1.t_order1节点

2.8.5.完整配置

[2.6 水平分库配置](#2.6 水平分库配置)

2.6.1.行表达式分片算法

2.6.2.取模分片算法

[2.7 水平分表配置](#2.7 水平分表配置)

2.7.1.配置分表策略

[2.7.2 HASH取模分片算法](#2.7.2 HASH取模分片算法)

2.7.3.测试

[2.8 分布式序列算法](#2.8 分布式序列算法)

2.8.1.分布式环境下主键的自动生成存在的问题

[2.8.2 UUID](#2.8.2 UUID)

[2.8.3 雪花算法](#2.8.3 雪花算法)

[2.9 多表关联查询](#2.9 多表关联查询)

[2.9.1 配置策略](#2.9.1 配置策略)

2.9.2.测试

[2.9.3. 绑定表](#2.9.3. 绑定表)

[2.11 广播表](#2.11 广播表)

2.11.1.什么是广播表

[2.11.2 配置广播表](#2.11.2 配置广播表)

一. 在Docker中安装ShardingSphere

接下来我将讲解ShardingSphere在Docker里面的安装

创建Docker容器所需的映射目录

我们必须提前进行创建

复制代码

mkdir -p /bit/shardingsphere/proxy/conf
mkdir -p /bit/shardingsphere/proxy/ext-lib
mkdir -p /bit/shardingsphere/proxy/logs

创建Docker容器

这个 docker run 命令是用来安装并启动一个 ShardingSphere-Proxy 容器的。ShardingSphere-Proxy 是一个透明的数据库代理，它允许你像连接普通 MySQL 服务器一样连接它，但它背后可以管理多个数据库实例，实现分库分表、读写分离等高级功能。

复制代码

docker run -d \
  -p 3307:3307 \
  -v /bit/shardingsphere/proxy/conf:/opt/shardingsphere-proxy/conf \
  -v /bit/shardingsphere/proxy/ext-lib:/opt/shardingsphere-proxy/ext-lib \
  -v /bit/shardingsphere/proxy/logs:/opt/shardingsphere-proxy/logs \
  -e JVM_OPTS="-Xms256m -Xmx256m -Xmn128m" \
  --name ss-proxy \
  apache/shardingsphere-proxy:5.3.2

这些参数啥意思呢？我们看看

复制代码

docker run -d \

docker run：Docker 命令，用于创建并启动一个新的容器。
-d：表示以后台（detached）模式运行容器。容器启动后，命令行会立即返回，不会阻塞。

-p 3307:3307 \
-p：用于映射端口。
3307:3307 ：将宿主机（Host）的 3307 端口映射到容器（Container）内部的 3307 端口。这意味着，外部应用程序（如你的应用代码、MySQL 客户端工具）需要连接宿主机的 3307 端口来访问 ShardingSphere-Proxy 服务。

-v /bit/shardingsphere/proxy/conf:/opt/shardingsphere-proxy/conf \
-v：用于创建数据卷（Volume），实现宿主机目录与容器目录的绑定（挂载）。
/bit/shardingsphere/proxy/conf:/opt/shardingsphere-proxy/conf ：将宿主机上的 /bit/shardingsphere/proxy/conf 目录挂载到容器内的 /opt/shardingsphere-proxy/conf 目录。这个目录通常存放 ShardingSphere-Proxy 的核心配置文件，如 server.yaml（服务配置）和 config-xxx.yaml（数据分片/读写分离规则配置）。通过挂载，你可以在宿主机上直接修改配置文件，而无需进入容器内部，修改后重启容器即可生效。

-v /bit/shardingsphere/proxy/ext-lib:/opt/shardingsphere-proxy/ext-lib \
/bit/shardingsphere/proxy/ext-lib:/opt/shardingsphere-proxy/ext-lib ：将宿主机上的 /bit/shardingsphere/proxy/ext-lib 目录挂载到容器内的 /opt/shardingsphere-proxy/ext-lib 目录。这个目录用于存放用户自定义的 JAR 包，例如：
- 数据库驱动（如果官方镜像里没有你需要的数据库驱动，如 Oracle）。
- 自定义的分片算法类。
- 自定义的加密算法类。
- 自定义的分布式序列生成器。
  
  -v /bit/shardingsphere/proxy/logs:/opt/shardingsphere-proxy/logs \
/bit/shardingsphere/proxy/logs:/opt/shardingsphere-proxy/logs ：将宿主机上的 /bit/shardingsphere/proxy/logs 目录挂载到容器内的 /opt/shardingsphere-proxy/logs 目录。ShardingSphere-Proxy 的运行日志（如 shardingsphere.log）会输出到这个目录。挂载后，你可以在宿主机上方便地查看和管理日志文件，即使容器被删除，日志也保留在宿主机上。

-e JVM_OPTS="-Xms256m -Xmx256m -Xmn128m" \
-e：用于设置环境变量（Environment Variable）。
JVM_OPTS="-Xms256m -Xmx256m -Xmn128m" ：将环境变量 JVM_OPTS 的值设置为指定的 JVM 内存参数。当 ShardingSphere-Proxy 启动时，会读取这个环境变量，并将其作为 JVM 的启动参数，从而控制其内存使用。

--name ss-proxy \
--name：为启动的容器指定一个名称。
ss-proxy ：这个容器的名称被设置为 ss-proxy。之后你可以使用 docker stop ss-proxy, docker start ss-proxy, docker logs ss-proxy 等命令来管理这个容器，比使用容器的 ID 更方便。

apache/shardingsphere-proxy:5.3.2
apache/shardingsphere-proxy:5.3.2 ：这是要运行的 Docker 镜像的名称和标签。
- apache/shardingsphere-proxy 是镜像的名称。
- 5.3.2 是镜像的版本标签（Tag）。Docker 会首先检查本地是否有这个镜像，如果没有，会自动从 Docker Hub（或其他配置的镜像仓库）拉取这个版本的镜像，然后使用它来创建并启动容器。

废话不多说，我们直接执行就OK。

然后我们来看看有没有启动成功啊

复制代码

# 查看是否启动成功
docker ps -a

我们发现没有启动成功，这个是因为docker容器没有进行配置

修改配置文件

首先我们需要来到这个配置文件对应的宿主机映射目录里面，也就是**/bit/shardingsphere/proxy/conf**

复制代码

cd  /bit/shardingsphere/proxy/conf

我们就在这个目录里面创建一个配置文件server.yaml

复制代码

vim server.yaml

然后把下面这个粘贴进去即可

复制代码

# 运行模式配置
mode:
  type: Standalone  # 单机模式（非集群部署）

# 用户权限配置
authority:
  users:
    - user: root@%          # 用户名格式：用户名@访问主机（%表示允许任意主机访问）
      password: 123456      # 用户密码
  privilege:
    type: ALL_PERMITTED     # 权限类型：授予该用户所有操作权限

# 系统属性配置
props:
  sql-show: true  # 是否在日志中显示执行的SQL语句（true=显示，false=隐藏）
  proxy-mysql-default-version: 8.0.42  # 代理对外暴露的MySQL默认版本号

我们保存退出。

上传MySQL驱动

连接MySQL数据库时，需要把MySQL驱动包放入宿主机映射扩展目录/bit/shardingsphere/proxy/ext-lib中

复制代码

cd /bit/shardingsphere/proxy/ext-lib

现在我们可以上一小节下载的 MySQL驱动驱动直接复制到这里即可。

当然，大家执行下面这个命令也是可以的

复制代码

wget https://repo1.maven.org/maven2/com/mysql/mysql-connector-j/8.0.33/mysql-connector-j-8.0.33.jar

启动

启动Docker容器，运行ShardingSphere

复制代码

# 重新启动容器
docker start ss-proxy
# 查看状态，启动成功
docker ps

没有一点问题

测试连接

通过客户端工具连接

复制代码

# 指定主机和端口号进行连接，成功
mysql -uroot -p -h127.0.0.1 -P3307

进入Docker容器

复制代码

# 进入容器
docker exec -it ss-proxy env LANG=C.UTF-8 /bin/bash

如果我们想要远程登陆这个服务器的话，需要去云服务器里面的防火墙和安全组里面开放这个3307端口。

二. 实践：水平分片

2.1 应用场景

随着系统持续运行，各业务模块积累的数据量不断攀升。在垂直分库架构下，虽然不同业务的表分散在不同数据库中，但单个数据表内的记录仍持续增长。 当表数据量超过数千万行时，底层存储引擎使用的B+树索引层级会逐渐加深。树高每增加一层，数据查询就需要多一次磁盘I/O操作，导致查询延迟显著上升。此时，垂直分库已无法解决单表数据膨胀带来的性能衰减。

为突破这一瓶颈，需要引入水平分片机制。其核心思路是将单张逻辑表的数据，按预设规则（如用户ID哈希、时间范围等）横向拆分到多个结构相同的物理分片表中。每个分片表只保存原表的部分数据子集，从而将海量数据分散存储。

这种拆分带来两个关键优势：首先，单个分片表的数据规模大幅缩减，有效控制了B+树的高度。当树高稳定在3层以内时，查询操作通常只需1-3次磁盘I/O，响应时间保持在毫秒级。其次，不同分片表可部署在不同物理节点上，查询负载被天然分散。用户请求会根据分片规则自动路由到特定分片，避免单一节点过载。

更重要的是，水平分片使系统获得弹性扩展能力。当数据持续增长时，只需增加新的分片节点即可线性提升存储容量和吞吐量，无需重构整体架构。这种设计既保障了海量数据场景下的稳定性能，也为后续业务扩展预留了技术空间。

2.2 架构图

在前面垂直分库的时候，我们是采用下面这个架构图

server-user服务器中存储t_user表中的数据
server-order服务器中存储t_order表中的数据

然而随着业务的发展，server-order 节点中 t_order 表的存储压力不断增大，这时就需要对 t_order 表进行横向拆分，也就是水平分片。我们先采用水平分库，将t_order表里面的数据拆分成torder0和t_order1两部分，分别存放到server_order0和server_order1两台机器上

然而server-order 节点中 t_order 表的存储压力成指数级增长，上图的水平分库已经不能满足需求了，我们需要在水平分库的基础之上再将torder0和t_order1进行水平分片。

分库策略：为了让请求正确路由到指定的数据库中

分表策略：为了让请求在正确的分片表中操作数据

2.3 服务器规划

由原来的一台服务器中的一张表，变成两台服务器中的四张表，分担数据存储压力

订单服务器：容器名 server-order0，端口号：63310
订单服务器：容器名 server-order1，端口号：63311

2.4 创建server-user容器

创建Docker容器

复制代码

docker run -d \
  -p 53310:3306 \
  -v /bit/mysql/user/conf:/etc/mysql/conf.d \
  -v /bit/mysql/user/mysql:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=123456 \
  --name server-user \
  mysql:8.0.42

关键参数解释：

-d：后台运行容器（detached 模式）。
-p 53310:3306：将主机的 53310 端口映射到容器的 3306 端口（MySQL 默认端口），外部通过 主机IP:53310 访问数据库。
-v /bit/mysql/user/conf:/etc/mysql/conf.d：挂载本地配置目录到容器，用于自定义 MySQL 配置（如 my.cnf）。
-v /bit/mysql/user/mysql:/var/lib/mysql：挂载本地数据目录到容器，实现数据持久化（防止容器删除后数据丢失）。
-e MYSQL_ROOT_PASSWORD=123456：设置 MySQL 的 root 用户密码。
--name server-user：为容器指定名称（便于后续管理）。
mysql:8.0.42：使用的 MySQL 镜像版本。

复制代码

# 查看容器状态
docker ps

CONTAINER ID   IMAGE                               COMMAND                  CREATED         STATUS          PORTS                                                      NAMES
b5051d4517c4   mysql:8.0.42                        "docker-entrypoint.s..."   4 seconds ago   Up 3 seconds    33060/tcp, 0.0.0.0:53310->3306/tcp, [::]:53310->3306/tcp   server-user

进入Docker容器

复制代码

# 进入Docker容器，env LANG=C.UTF-8避免中文乱码问题
docker exec -it server-user env LANG=C.UTF-8 /bin/bash

# 运行Mysql客户端
mysql -uroot -p

sql 复制代码

# 修改root用户密码
SET PASSWORD = '123456';

创建数据库

使用客户端登录数据库并执行SQL

sql 复制代码

-- 创建数据库
CREATE DATABASE IF NOT EXISTS user_db 
  CHARACTER SET utf8mb4 
  COLLATE utf8mb4_0900_ai_ci;

-- 使用 user_db 数据库作为当前操作上下文
USE user_db;

CREATE TABLE IF NOT EXISTS t_user (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(20)
);

测试远程登陆

接下来我们将测试一下远程登陆

注意：如果你的宿主机是云服务器的话，请记得去云服务器官网开放防火墙端口和设置安全组

sql 复制代码

mysql -h150.158.139.86 -P53310 -uroot -p

2.5 创建server-order0和server-order1容器

创建Docker容器

创建两台Docker，容器名端口号分别为 server-order0:63310 和 server-order1:63311

复制代码

# 创建server-order0，注意修改相应的容器名、端口号和映射路径

docker run -d \
-p 63310:3306 \
-v /bit/mysql/order0/conf:/etc/mysql/conf.d \
-v /bit/mysql/order0/mysql:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-order0 \
--restart always \
mysql:8.0.42

# 创建server-order1，注意修改相应的容器名、端口号和映射路径
docker run -d \
-p 63311:3306 \
-v /bit/mysql/order1/conf:/etc/mysql/conf.d \
-v /bit/mysql/order1/mysql:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-order1 \
--restart always \
mysql:8.0.42

查看是否启动成功

复制代码

docker ps

root@VM-16-14-ubuntu:/bit/shardingsphere/proxy/conf# docker ps
CONTAINER ID   IMAGE                               COMMAND                  CREATED         STATUS         PORTS                                                      NAMES
d9e2e351fb8a   mysql:8.0.42                        "docker-entrypoint.s..."   2 seconds ago   Up 1 second    33060/tcp, 0.0.0.0:63311->3306/tcp, [::]:63311->3306/tcp   server-order1
d2d5c33d7ca2   mysql:8.0.42                        "docker-entrypoint.s..."   3 minutes ago   Up 3 second   33060/tcp, 0.0.0.0:63310->3306/tcp, [::]:63310->3306/tcp   server-order0

接下来我们将使用客户端分别登录 server-order0 和 server-order1 并创建数据库

水平分片后由于数据分布在不同的数据节点，所以主键值不能依赖自增值，生成策略由业务层实现，插入记录时指定一个主键值。

进入Docker容器 server-order0，创建t_order1和

复制代码

# 进入Docker容器，env LANG=C.UTF-8避免中文乱码问题
docker exec -it server-order0 env LANG=C.UTF-8 /bin/bash

# 运行Mysql客户端
mysql -uroot -p

# 修改root用户密码
SET PASSWORD = '123456';

然后我们需要创建torder0和torder1的表的结构

sql 复制代码

-- 创建订单数据库（使用UTF8字符集和现代排序规则）
CREATE DATABASE IF NOT EXISTS order_db 
  CHARACTER SET utf8mb4 
  COLLATE utf8mb4_0900_ai_ci;

-- 切换到订单数据库
USE order_db;

-- 创建分片表0（用于存储用户ID为偶数的订单）
CREATE TABLE IF NOT EXISTS t_order0 (
  id BIGINT PRIMARY KEY,            -- 主键ID
  order_no VARCHAR(30) COMMENT '订单号',  -- 订单唯一编号
  amount DECIMAL(12, 2) COMMENT '订单金额', -- 订单金额（最大999亿）
  user_id BIGINT COMMENT '用户编号'       -- 关联用户ID
);

-- 创建分片表1（用于存储用户ID为奇数的订单）
CREATE TABLE IF NOT EXISTS t_order1 (
  id BIGINT PRIMARY KEY,            -- 主键ID
  order_no VARCHAR(30) COMMENT '订单号',  -- 订单唯一编号
  amount DECIMAL(12, 2) COMMENT '订单金额', -- 订单金额（最大999亿）
  user_id BIGINT COMMENT '用户编号'       -- 关联用户ID
);

进入Docker容器 server-order1，创建对应的表

复制代码

# 进入Docker容器，env LANG=C.UTF-8避免中文乱码问题
docker exec -it server-order1 env LANG=C.UTF-8 /bin/bash

# 运行Mysql客户端
mysql -uroot -p

# 修改root用户密码
SET PASSWORD = '123456';

然后我们需要创建torder0和torder1的表的结构

sql 复制代码

-- 创建订单数据库（使用UTF8字符集和现代排序规则）
CREATE DATABASE IF NOT EXISTS order_db 
  CHARACTER SET utf8mb4 
  COLLATE utf8mb4_0900_ai_ci;

-- 切换到订单数据库
USE order_db;

-- 创建分片表0（用于存储用户ID为偶数的订单）
CREATE TABLE IF NOT EXISTS t_order0 (
  id BIGINT PRIMARY KEY,            -- 主键ID
  order_no VARCHAR(30) COMMENT '订单号',  -- 订单唯一编号
  amount DECIMAL(12, 2) COMMENT '订单金额', -- 订单金额（最大999亿）
  user_id BIGINT COMMENT '用户编号'       -- 关联用户ID
);

-- 创建分片表1（用于存储用户ID为奇数的订单）
CREATE TABLE IF NOT EXISTS t_order1 (
  id BIGINT PRIMARY KEY,            -- 主键ID
  order_no VARCHAR(30) COMMENT '订单号',  -- 订单唯一编号
  amount DECIMAL(12, 2) COMMENT '订单金额', -- 订单金额（最大999亿）
  user_id BIGINT COMMENT '用户编号'       -- 关联用户ID
);

测试远程连接

接下来我们将测试一下远程连接

注意：如果你的宿主机是云服务器的话，那么就一定要记得去云服务器官网开放防火墙端口号并且去开放安全组端口号

bash 复制代码

mysql -h150.158.139.86 -P63310 -uroot -p

复制代码

mysql -h150.158.139.86 -P63311 -uroot -p

2.6.日志配置

首先我们需要来到这个配置文件对应的宿主机映射目录里面，也就是**/bit/shardingsphere/proxy/conf**

复制代码

cd /bit/shardingsphere/proxy/conf

接下来我们将创建一个文件

复制代码

vim logback.xml

并编写以下内容

复制代码

<?xml version="1.0"?>
<configuration>
    <!-- 日志输入到文件 -->
    <appender name="SHARDING_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 日志路径 -->
        <file>./logs/shardingsphere.log</file>
        <encoder>
            <!-- 日志输入的样式 -->
            <pattern>[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>shardingsphere.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
    </appender>
 
    <root level="INFO">
        <appender-ref ref="SHARDING_FILE" />
    </root>
 
</configuration>

我们保存退出一下。

2.7 数据节点配置

数据节点指的是某个数据源下的某张具体的分片表

数据节点配置与可以称为标准分片表配置

数据分片需要配置的文件是: conf/config-sharding.yaml，对应我们宿主机的目录就是/bit/shardingsphere/proxy/conf/config-sharding.yaml。

首先我们先来到我们的**/bit/shardingsphere/proxy/conf/，然后创建一个叫config-sharding.yaml的文件**

bash 复制代码

cd /bit/shardingsphere/proxy/conf/
vim config-sharding.yaml

配置数据源

配置 server_user、server_order0、server_order1 三个数据源

bash 复制代码

databaseName: bit_sharding_db

dataSources:
  server_user:
    url: jdbc:mysql://150.158.139.86:53310/user_db?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: 123456
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
    minPoolSize: 1
  server_order0:
    url: jdbc:mysql://150.158.139.86:63310/order_db?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: 123456
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
    minPoolSize: 1
  server_order1:
    url: jdbc:mysql://150.158.139.86:63311/order_db?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: 123456
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
    minPoolSize: 1

配置数据节点

每个 t_order 表都是一个数据节点，当前 t_order 表分布如下：

server_order0.t_order0
server_order0.t_order1
server_order1.t_order0
server_order1.t_order1

bash 复制代码

rules:
- !SHARDING
  tables:
    t_user:  # 逻辑表名
      actualDataNodes: server_user.t_user  # 由数据源名 + 表名组成
    t_order: # 逻辑表名
      actualDataNodes: server_order0.t_order0,server_order0.t_order1,server_order1.t_order0,server_order1.t_order1

我们在想：server_order0.t_order0,server_order0.t_order1,server_order1.t_order0,server_order1.t_order1能不能再简化一下，我们可以去ShardingSphere官网看看核心概念 :: ShardingSphere

我们现在就去修改rules节点，使用行表达式对 t_order 表进行水平分库配置

bash 复制代码

rules:
- !SHARDING
  tables:
    t_user:  # 逻辑表名
      actualDataNodes: server_user.t_user  # 由数据源名 + 表名组成
    t_order: # 逻辑表名
      actualDataNodes: server_order${0..1}.t_order${0..1}

所有对逻辑表 t_user 的操作直接路由到 server_user 数据源（即 user_db 数据库）

所有对逻辑表t_order的操作路由到下面四个节点

server_order0.t_order0
server_order0.t_order1
server_order1.t_order0
server_order1.t_order1

完整配置文件内容

bash 复制代码

databaseName: bit_sharding_db

dataSources:
  server_user:
    url: jdbc:mysql://150.158.139.86:53310/user_db?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: 123456
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
    minPoolSize: 1
  server_order0:
    url: jdbc:mysql://150.158.139.86:63310/order_db?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: 123456
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
    minPoolSize: 1
  server_order1:
    url: jdbc:mysql://150.158.139.86:63311/order_db?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: 123456
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
    minPoolSize: 1

rules:
- !SHARDING
  tables:
    t_user:  # 逻辑表名
      actualDataNodes: server_user.t_user  # 由数据源名 + 表名组成
    t_order: # 逻辑表名
      actualDataNodes: server_order${0..1}.t_order${0..1}

我们把这个内容写入**/bit/shardingsphere/proxy/conf/config-sharding.yaml**.

保存退出

2.8.测试数据节点

我们在上面的配置文件里面写了

bash 复制代码

rules:
- !SHARDING
  tables:
    t_user:  # 逻辑表名
      actualDataNodes: server_user.t_user  # 由数据源名 + 表名组成
    t_order: # 逻辑表名
      actualDataNodes: server_order${0..1}.t_order${0..1}

每个 t_order 表都是一个数据节点，当前 t_order 表分布如下：

server_order0.t_order0
server_order0.t_order1
server_order1.t_order0
server_order1.t_order1

事实上呢？

我们一般是不会直接像上面2.7里面的配置文件那样子直接写actualDataNodes: server_order ${0..1}.t_order$ {0..1}的，我们得先一个一个数据节点进行测试，等每个数据节点都测试成功了，我们再写actualDataNodes: server_order ${0..1}.t_order0$ {0..1}的

2.8.1.测试server_order0.t_order0节点

首先我们先来到我们的**/bit/shardingsphere/proxy/conf/，然后创建一个叫config-sharding.yaml的文件**

bash 复制代码

cd /bit/shardingsphere/proxy/conf/
vim config-sharding.yaml

我们把我们把config-sharding.yaml里面的一部分内容修改成下面这样子

bash 复制代码

......
rules:
- !SHARDING
  tables:
    t_user:  # 逻辑表名
      actualDataNodes: server_user.t_user  # 由数据源名 + 表名组成
    t_order: # 逻辑表名
      actualDataNodes: server_order0.t_order0

然后保存退出，我们重启Docker容器

bash 复制代码

docker restart ss-proxy
docker ps

运行结果如下

bash 复制代码

root@VM-16-14-ubuntu:/bit/shardingsphere/proxy/conf# docker restart ss-proxy
ss-proxy
root@VM-16-14-ubuntu:/bit/shardingsphere/proxy/conf# docker ps
CONTAINER ID   IMAGE                               COMMAND                  CREATED        STATUS         PORTS                                                      NAMES
d9e2e351fb8a   mysql:8.0.42                        "docker-entrypoint.s..."   15 hours ago   Up 15 hours    33060/tcp, 0.0.0.0:63311->3306/tcp, [::]:63311->3306/tcp   server-order1
d2d5c33d7ca2   mysql:8.0.42                        "docker-entrypoint.s..."   16 hours ago   Up 16 hours    33060/tcp, 0.0.0.0:63310->3306/tcp, [::]:63310->3306/tcp   server-order0
b5051d4517c4   mysql:8.0.42                        "docker-entrypoint.s..."   22 hours ago   Up 2 hours     33060/tcp, 0.0.0.0:53310->3306/tcp, [::]:53310->3306/tcp   server-user
efc3b3c7dabc   apache/shardingsphere-proxy:5.3.2   "/bin/sh -c '${LOCAL..."   41 hours ago   Up 6 seconds   0.0.0.0:3307->3307/tcp, [::]:3307->3307/tcp                ss-proxy

接着我们打开实时日志

sql 复制代码

tail -f /bit/shardingsphere/proxy/logs/shardingsphere.log

然后我们去登陆

bash 复制代码

mysql -h127.0.0.1 -P3307 -uroot -p

我们接着执行下面这个

注意：如果显示的是下面这个情况，不要太慌张，这个是ShardingSphere-Proxy5.3.2的bug，不影响我们的！！

然后我们执行下面这个语句

bash 复制代码

-- 插入记录并在server_order0.t_order0节点中查看是否插入成功
insert into t_order (id, order_no, user_id, amount) values (1, 'BIT001', 1, 20.00);

我们看看日志中的结果