数据库中间件ShardingSphere5

傲祥Ax2025-06-21 12:23

一、高性能架构模式

数据库集群，第一种方式"读写分离"，第二种方式"数据库分片"。

1.1 读写分离架构

读写分离原理：将数据库读写操作分散到不同的节点上。

读写分离的基本实现：

  • 主库负责处理事务性的增删改操作，从库负责处理查询操作。
  • 读写分离是根据SQL语义的分析，将读写操作分别路由至主库和从库。
  • 通过一主多从的配置方式，可以将查询请求均匀的分散到多个数据副本，进一步提升系统处理能力。
  • 使用多主多从，提升系统的吞吐量，可用性，任何一个数据库宕机或者磁盘损坏，不影响系统正常运行。
  • 根据业务需要，将用户表读写操作路由到不同的数据库

CAP理论：

在一个分布式系统中，涉及读写操作时，保证一致性（Consistence）、可用性（Availability）、分区容错性（Partition Tolerance），只能做到CP，AP。

CP：为保证一致性，发生分区现象后，N1节点数据更新到y，当N1与N2之间的通道中断后，N2为同步数据，客户端访问N2时返回Error。

AP：为保证可用性，客户端访问N2将数据返回给C。

CAP理论C实践中不能完美实现，无法做到强一致性。可以采用适合的方式达到最终一致性。

  1. 基本可用（Basically Available）：分布式系统在出现故障时，允许损失部分可用性，即保证核心可用。
  2. 软状态（Soft State）：允许系统存在中间状态，而该中间状态不会影响系统整体可用性。这里的中间状态就是 CAP 理论中的数据不一致。
  3. 最终一致性（Eventual Consistency）：系统中的所有数据副本经过一定时间后，最终能够达到一致的状态。

1.2 数据库分片架构

  • 读写分离问题：

分散数据库读写操作压力，没有分散存储压力，需要将存储分散到多台数据库服务器上。

  • 数据分片：

将存放在单一数据库中的数据分散地存放到多个数据库或表，数据分片的有效手段是对关系型是对关系型数据库进行分库和分表。数据分片的拆分方式又分为垂直分片和水平分片。

1.2.1 垂直分片

垂直分库：

按照业务拆分的方式称为垂直分片，又称为纵向拆分，它的核心理念是专库专用。 在拆分之前，一个数据库由多个数据表构成，每个表对应着不同的业务。而拆分之后，则是按照业务将表进行归类，分布到不同的数据库中，从而将压力分散至不同的数据库。

将用户表和订单表垂直分片到不同的数据库的方案：

垂直拆分可以缓解数据量和访问量带来的问题，但无法根治。如果垂直拆分之后，表中的数据量依然超过单节点所能承载的阈值，则需要水平分片来进一步处理。

垂直分表：

垂直分表适合将表中某些不常用的列，或者是占了大量空间的列拆分出去。

1.2.2 水平分片

水平分片又称为横向拆分。 相对于垂直分片，它不再将数据根据业务逻辑分类，而是通过某个字段（或某几个字段），根据某种规则将数据分散至多个库或表中，每个分片仅包含数据的一部分。 例如：根据主键分片，偶数主键的记录放入 0 库（或表），奇数主键的记录放入 1 库（或表），如下图所示。

单表进行切分后，是否将多个表分散在不同的数据库服务器中，可以根据实际的切分效果来确定。

  • **水平分表：**单表切分为多表后，新的表即使在同一个数据库服务器中，也可能带来可观的性能提升，如果性能能够满足业务要求，可以不拆分到多台数据库服务器，毕竟业务分库也会引入很多复杂性；

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

阿里巴巴Java开发手册：

【推荐】单表行数超过 500 万行或者单表容量超过 2GB，才推荐进行分库分表。

说明：如果预计三年后的数据量根本达不到这个级别，请不要在创建表时就分库分表。

第2章 解决方案

读写分离和数据分片具体的实现方式一般有两种： 程序代码封装和中间件封装。

2.1 程序代码封装

程序代码封装指在代码中抽象一个数据访问层（或中间层封装），实现读写操作分离和数据库服务器连接的管理。

**其基本架构是：**以读写分离为例

2.2 中间件封装

中间件封装指的是独立一套系统出来，实现读写操作分离和数据库服务器连接的管理。对于业务服务器来说，访问中间件和访问数据库没有区别，在业务服务器看来，中间件就是一个数据库服务器。

**基本架构是：**以读写分离为例

2.3 常用解决方案

  • Apache ShardingSphere

  • 程序代码封装：ShardingSphere-JDBC

  • 中间件封装：ShardingSphere-Proxy

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

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

  • MyCat：数据库中间件

三、MySQL主从同步

3.1 MySQL主从同步原理

  • 基本原理：
  1. slave会从master读取binlog来进行数据同步
  2. 具体步骤：
  3. master将数据改变记录到二进制日志中。
  4. 当slave上执行start slave命令之后，salve会创建一个IO线程用来连接master，请求master中的binlog.
  5. 当slave连接上master时，master会创建一个log dump线程，用于发送binlog的内容。在读取binlog的内容。在读取binlog的内容的操作中，会对主节点上的binlog加锁，当读取完成并发送给从服务器后解锁。
  6. IO线程接收主节点binlog dump 进程发来的更新之后，保存到中继日志（relay log）中。
  7. slave的SQL线程，读取 relay log 日志，并解析成具体操作，实现主从操作一直，最终数据一致。

3.2 一主多从配置

docker方式创建，主从服务器IP一致，端口号不一致。

  • 主服务器：容器名mysql-master，端口3307

  • 从服务器：容器名mysql-slave1，端口3308

  • 从服务器：容器名mysql-slave2，端口3309

注意： 如果此时防火墙是开启的，则先关闭防火墙，并重启docker，否则后续安装的MySQL无法启动

复制代码 
#关闭docker
systemctl stop docker
#关闭防火墙
systemctl stop firewalld
#启动docker
systemctl start docker

3.2.1 准备主服务器

  • step1：在docker中创建并启动MySQL主服务器： 端口3307
复制代码 
docker run -d \
-p 3307:3306 \
-v /mysql/master/conf:/etc/mysql/conf.d \
-v /mysql/master/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name mysql-master \
mysql:8.0.30
  • step2：创建MySQL主服务器配置文件：

默认情况下MySQL的binlog日志是自动开启的，可以通过如下配置定义一些可选配置

复制代码 
vim mysql/master/conf/my.cnf

配置如下内容

复制代码 
[mysqld]
# 服务器唯一id，默认值1
server-id=1
# 设置日志格式，默认值ROW
binlog_format=STATEMENT
# 二进制日志名，默认binlog
# log-bin=binlog
# 设置需要复制的数据库，默认复制全部数据库
#binlog-do-db=mytestdb1
#binlog-do-db=mytestdb2
# 设置不需要复制的数据库
#binlog-ignore-db=mytestdb3
#binlog-ignore-db=mytestdb4

重启MySQL容器

复制代码 
docker restart 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 mysql-master env LANG=C.UTF-8 /bin/bash
#进入容器内的mysql命令行
mysql -uroot -p
#修改默认密码校验方式
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
  • step4：主机中创建slave用户：//帮助授权从机访问二进制文件权限
复制代码 
-- 创建slave用户
CREATE USER 'slave'@'%';
-- 设置密码
ALTER USER 'slave'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
-- 授予复制权限
GRANT REPLICATION SLAVE ON *.* TO 'slave'@'%';
-- 刷新权限
FLUSH PRIVILEGES;
  • step5：主机中查询master状态：

执行完此步骤后不要再操作主服务器MYSQL，防止主服务器状态值变化

复制代码 
SHOW MASTER STATUS;

记下File和Position的值。执行完此步骤后不要再操作主服务器MYSQL，防止主服务器状态值变化。

reset master

3.2.2 准备从服务器1

可以配置多台从机slave1、slave2...，这里以配置slave1为例，请参考slave1独立完成slave2的配置

  • step1：在docker中创建并启动MySQL从服务器： 端口3308
复制代码 
docker run -d \
-p 3308:3306 \
-v mysql/slave1/conf:/etc/mysql/conf.d \
-v mysql/slave1/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name mysql-slave1 \
mysql:8.0.29

  • step2：创建MySQL从服务器配置文件：

复制代码 
vim /mysql/slave1/conf/my.cnf

配置如下内容：

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

重启MySQL容器

复制代码 
docker restart mysql-slave1
  • step3：使用命令行登录MySQL从服务器：
复制代码 
#进入容器：
docker exec -it mysql-slave1 env LANG=C.UTF-8 /bin/bash
#进入容器内的mysql命令行
mysql -uroot -p
#修改默认密码校验方式
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
  • step4：在从机上配置主从关系：

在从机上执行以下SQL操作

复制代码 
CHANGE MASTER TO MASTER_HOST='192.168.200.130', 
MASTER_USER='slave',MASTER_PASSWORD='123456', MASTER_PORT=3306,
MASTER_LOG_FILE='binlog.000003',MASTER_LOG_POS=1357;

3.2.3 准备从服务器2

参考3.2.2

3.2.4 启动主从同步

分别在两台从机上启动从机的复制功能，执行SQL：

复制代码 
START SLAVE;
-- 查看状态（不需要分号）
SHOW SLAVE STATUS\G;

**两个关键进程：**下面两个参数都是Yes，则说明主从配置成功！

3.2.5 测试主从同步

在主机中执行以下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);

3.2.6 常见问题

启动主从同步后，常见错误是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
-- 在从机上执行。功能说明：停止I/O 线程和SQL线程的操作。
stop slave; 
​
-- 在从机上执行。功能说明：用于删除SLAVE数据库的relaylog日志文件，并重新启用新的relaylog文件。
reset slave;
​
-- 在主机上执行。功能说明：删除所有的binlog日志文件，并将日志索引文件清空，重新开始所有新的日志文件。
-- 用于第一次进行搭建主从库时，进行主库binlog初始化工作；
reset master;
​
-- 还原主服务器之前的操作
​
-- 在主机查看mater状态
SHOW MASTER STATUS;
-- 在主机刷新日志
FLUSH LOGS;
-- 再次在主机查看mater状态（会发现File和Position发生了变化）
SHOW MASTER STATUS;
-- 修改从机连接主机的SQL，并重新连接即可

第4章 ShardingSphere-JDBC读写分离

4.1 创建SpringBoot程序

4.1.1 创建项目

项目类型：Spring Initializr

SpringBoot脚手架：http://start.aliyun.com

项目名：sharding-jdbc-demo

SpringBoot版本：3.0.5

4.1.2 添加依赖

复制代码 
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
​
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
​
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>shardingsphere-jdbc-core</artifactId>
        <version>5.4.0</version>
    </dependency>
​
    <!--兼容jdk17和spring boot3-->
    <dependency>
        <groupId>org.yaml</groupId>
        <artifactId>snakeyaml</artifactId>
        <version>1.33</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
        <version>2.3.8</version>
    </dependency>
​
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.30</version>
    </dependency>
​
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.3.1</version>
    </dependency>
​
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

4.1.3 创建实体类

复制代码 
@TableName("t_user")
@Data
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String uname;
}

4.1.4 创建Mapper

复制代码 
​
@Mapper public interface UserMapper extends BaseMapper<User> { }

4.1.5 配置 Spring Boot

application.properties：

复制代码 
# 配置 DataSource Driver
spring.datasource.driver-class-name=org.apache.shardingsphere.driver.ShardingSphereDriver
# 指定 YAML 配置文件
spring.datasource.url=jdbc:shardingsphere:classpath:shardingsphere.yaml

4.1.6 配置shardingsphere

shardingsphere.yaml

模式配置：

复制代码 
mode:
  type: Standalone
  repository:
    type: JDBC
  • 数据源配置：
复制代码 
dataSources:
  write_ds:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    jdbcUrl: jdbc:mysql://192.168.200.130:3307/db_user
    username: root
    password: 123456
  read_ds_0:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    jdbcUrl: jdbc:mysql://192.168.200.130:3308/db_user
    username: root
    password: 123456
  read_ds_1:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    jdbcUrl: jdbc:mysql://192.168.200.130:3309/db_user
    username: root
    password: 123456

读写分离配置：

复制代码 
rules:
  - !READWRITE_SPLITTING#读写
    dataSources:
      readwrite_ds:
        writeDataSourceName: write_ds#数据源指向
        readDataSourceNames:#数据源指向
          - read_ds_0
          - read_ds_1
        transactionalReadQueryStrategy: PRIMARY # 事务内读请求的路由策略，可选值：PRIMARY（路由至主库）、FIXED（同一事务内路由至固定数据源）、DYNAMIC（同一事务内路由至非固定数据源）。默认值：DYNAMIC
        loadBalancerName: random#负载均衡随机
    loadBalancers:
      random:
        type: RANDOM

输出sql：

复制代码 
props:
  sql-show: true

4.2 测试

4.2.1 读写分离测试

复制代码 
​
@SpringBootTest
class ShardingJdbcDemoApplicationTests {
​
    @Autowired
    private UserMapper userMapper;
​
    /**
     * 写入数据的测试
     */
    @Test
    public void testInsert(){
​
        User user = new User();
        user.setUname("张三丰");
        userMapper.insert(user);
    }
​
}

4.2.2 负载均衡测试

复制代码 
/**
  * 负载均衡测试
  */
@Test
public void testSelect(){
​
    for (int i = 0; i < 100; i++) {
        User user1 = userMapper.selectById(1);
    }
}

负载均衡算法配置：

复制代码 
rules:
  - !READWRITE_SPLITTING
    loadBalancers:
      random:
        type: RANDOM
      round_robin:
        type: ROUND_ROBIN
      weight:
        type: WEIGHT
        props:
          read_ds_0: 1
          read_ds_1: 2#设置权重

4.2.3 事务测试

transactionalReadQueryStrategy: PRIMARY

事务内读请求的路由策略，可选值：

PRIMARY（路由至主库）

FIXED（同一事务内路由至固定数据源）

DYNAMIC（同一事务内路由至非固定数据源）。默认值：DYNAMIC

1、测试1

不添加@Transactional：insert对主库操作，select对从库操作

2、测试2

添加@Transactional：则insert和select按照transactionalReadQueryStrategy的配置执行

复制代码 
/**
     * 事务测试
     */
@Transactional//开启事务
@Test
public void testTrans(){
​
    User user = new User();
    user.setUname("铁锤");
    userMapper.insert(user);
​
    List<User> users = userMapper.selectList(null);
}

**注意：**在JUnit环境下的@Transactional注解，默认情况下就会对事务进行回滚（即使在没加注解@Rollback，也会对事务回滚）

3、常见错误

ShardingSphere-JDBC远程连接的方式默认的密码加密规则是：mysql_native_password

因此需要在服务器端修改服务器的密码加密规则，如下：

复制代码 
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';

第5章 ShardingSphere-JDBC垂直分片

5.1 准备服务器

服务器规划：使用docker方式创建如下容器

  • 服务器：容器名server-user，端口 3301

  • 服务器：容器名server-order，端口3302

5.1.1 创建server-user容器

  • step1：创建容器：
复制代码 
docker run -d \
-p 3301:3306 \
-v server/user/conf:/etc/mysql/conf.d \
-v server/user/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-user \
mysql:8.0.29
  • step2：登录MySQL服务器：
复制代码 
#进入容器：
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';
  • step3：创建数据库：
复制代码 
CREATE DATABASE db_user;
USE db_user;
CREATE TABLE t_user (
 id BIGINT AUTO_INCREMENT,
 uname VARCHAR(30),
 PRIMARY KEY (id)
);

5.1.2 创建server-order容器

  • step1：创建容器：
复制代码 
docker run -d \
-p 3302:3306 \
-v /server/order/conf:/etc/mysql/conf.d \
-v /server/order/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-order \
mysql:8.0.30
  • step2：登录MySQL服务器：
复制代码 
#进入容器：
docker exec -it server-order env LANG=C.UTF-8 /bin/bash
#进入容器内的mysql命令行
mysql -uroot -p
#修改默认密码插件
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
  • step3：创建数据库：
复制代码 
CREATE DATABASE db_order;
USE db_order;
CREATE TABLE t_order (
  id BIGINT AUTO_INCREMENT,
  order_no VARCHAR(30),
  user_id BIGINT,
  PRIMARY KEY(id) 
);

5.2 程序实现

5.2.1 创建实体类

复制代码 
@TableName("t_order")
@Data
public class Order {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String orderNo;
    private Long userId;
}

5.2.2 创建Mapper

复制代码 
​
@Mapper
public interface OrderMapper extends BaseMapper<Order> {
}

5.2.3 配置垂直分片

模式配置

复制代码 
mode:
  type: Standalone
  repository:
    type: JDBC

数据源配置：

复制代码 
dataSources:
  user_ds:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    jdbcUrl: jdbc:mysql://192.168.200.130:3301/db_user
    username: root
    password: 123456
  order_ds:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    jdbcUrl: jdbc:mysql://192.168.200.130:3302/db_order
    username: root
    password: 123456

垂直分片配置：

复制代码 
rules:
  - !SHARDING
    tables:
      t_user:
        actualDataNodes: user_ds.t_user
      t_order:
        actualDataNodes: order_ds.t_order

输出sql：

复制代码 
props:
  sql-show: true

5.3 测试垂直分片

复制代码 
@Autowired
private UserMapper userMapper;
​
@Autowired
private OrderMapper orderMapper;
​
/**
  * 垂直分片：插入数据测试
  */
@Test
public void testInsertOrderAndUser(){
​
    User user = new User();
    user.setUname("强哥");
    userMapper.insert(user);
​
    Order order = new Order();
    order.setOrderNo("001");
    order.setUserId(user.getId());
    orderMapper.insert(order);
​
}
​
/**
  * 垂直分片：查询数据测试
  */
@Test
public void testSelectFromOrderAndUser(){
    User user = userMapper.selectById(1L);
    Order order = orderMapper.selectById(1L);
}

第6章 ShardingSphere-JDBC水平分片

6.1 准备服务器

服务器规划：使用docker方式创建如下容器

  • 服务器：容器名server-order0，端口3320

  • 服务器：容器名server-order1，端口3321

6.1.1 创建server-order0容器

  • step1：创建容器：
复制代码 
docker run -d \
-p 3320:3306 \
-v /server/order0/conf:/etc/mysql/conf.d \
-v /server/order0/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-order0 \
mysql:8.0.29
  • step2：登录MySQL服务器：
复制代码 
#进入容器：
docker exec -it server-order0 env LANG=C.UTF-8 /bin/bash
#进入容器内的mysql命令行
mysql -uroot -p
#修改默认密码插件
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
  • step3：创建数据库：

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

复制代码 
CREATE DATABASE db_order;
USE db_order;
CREATE TABLE t_order0 (
  id BIGINT,
  order_no VARCHAR(50),
  user_id BIGINT,
  PRIMARY KEY(id) 
);
CREATE TABLE t_order1 (
  id BIGINT,
  order_no VARCHAR(50),
  user_id BIGINT,
  PRIMARY KEY(id) 
);

6.1.2 创建server-order1容器

  • step1：创建容器：
复制代码 
docker run -d \
-p 3321:3306 \
-v /server/order1/conf:/etc/mysql/conf.d \
-v /server/order1/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-order1 \
mysql:8.0.29
  • step2：登录MySQL服务器：
复制代码 
#进入容器：
docker exec -it server-order1 env LANG=C.UTF-8 /bin/bash
#进入容器内的mysql命令行
mysql -uroot -p
#修改默认密码插件
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
  • **step3：创建数据库：**和server-order0相同

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

//数据库主键自增机制（如 MySQL 的 AUTO_INCREMENT）无法直接满足分布式环境下的全局唯一性需求，因此通常需要在业务层实现全局唯一 ID 生成策略

Snowflake 算法及其变种
  • 原理 ：生成 64 位长整型 ID，结构为：时间戳（41位）+ 机器ID（10位）+ 序列号（12位）。
复制代码 
CREATE DATABASE db_order;
USE db_order;
CREATE TABLE t_order0 (
  id BIGINT,
  order_no VARCHAR(30),
  user_id BIGINT,
  PRIMARY KEY(id) 
);
CREATE TABLE t_order1 (
  id BIGINT,
  order_no VARCHAR(30),
  user_id BIGINT,
  PRIMARY KEY(id) 
);

6.2 水平分片

6.2.1 配置一个分片节点

模式配置

复制代码 
mode:
  type: Standalone
  repository:
    type: JDBC

数据源配置：

复制代码 
dataSources:
  user_ds:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    jdbcUrl: jdbc:mysql://192.168.200.130:3301/db_user
    username: root
    password: 123456
  order_ds_0:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    jdbcUrl: jdbc:mysql://192.168.200.130:3320/db_order
    username: root
    password: 123456
  order_ds_1:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    jdbcUrl: jdbc:mysql://192.168.200.130:3321/db_order
    username: root
    password: 123456

配置一个order分片节点：

复制代码 
rules:
  - !SHARDING
    tables:
      t_user:
        actualDataNodes: user_ds.t_user
      t_order:
        actualDataNodes: order_ds_0.t_order0

输出sql：

复制代码 
props:
  sql-show: true

修改Order实体类的主键策略：

复制代码 
//@TableId(type = IdType.AUTO)//依赖数据库的主键自增策略
@TableId(type = IdType.ASSIGN_ID)//分布式id

测试代码：

复制代码 
/**
  * 水平分片：插入数据测试
  */
@Test
public void testInsertOrder(){
​
    Order order = new Order();
    order.setOrderNo("001");
    order.setUserId(1L);
    orderMapper.insert(order);
}

6.2.2 水平分库配置

使用行表达式： 核心概念 :: ShardingSphere (apache.org)

将数据 分片到order_ds_0和order_ds_1中

复制代码 
actualDataNodes: order_ds_${0..1}.t_order0

分片算法配置

分片规则：order表中user_id为偶数时，数据插入server-order0服务器，user_id为奇数时，数据插入server-order1服务器。这样分片的好处是，同一个用户的订单数据，一定会被插入到同一台服务器上，查询一个用户的订单时效率较高。

复制代码 
rules:
  - !SHARDING
    tables:#数据库分片和表分片
      t_user:
        actualDataNodes: user_ds.t_user
      t_order:
        actualDataNodes: order_ds_${0..1}.t_order0
        databaseStrategy:
#databaseStrategy：按 user_id 列使用名为 userid_inline 的算法进行分库。
#tableStrategy：按 id 列使用名为 orderid_inline 的算法进行分表。
          standard:
            shardingColumn: user_id
            shardingAlgorithmName: userid_inline
​
    shardingAlgorithms:
      userid_inline:
        type: INLINE
        props:
          algorithm-expression: order_ds_${user_id % 2}//分片的算法

测试：

复制代码 
/**
     * 水平分片：分库插入数据测试
     */
@Test
public void testInsertOrderDatabaseStrategy(){
​
    for (long i = 0; i < 4; i++) {
        Order order = new Order();
        order.setOrderNo(" + System.currentTimeMillis());
        order.setUserId(i + 1);
        orderMapper.insert(order);
    }
}

6.2.3 水平分表配置

将数据 分片到order_ds_0和order_ds_1的t_order0和t_order1中

复制代码 
actualDataNodes: order_ds_${0..1}.t_order${0..1}

分片算法配置

分片规则：order表中id为偶数时，数据插入t_order0数据库，id为奇数时，数据插入t_order1数据库。

复制代码 
rules:
  - !SHARDING
    tables:
      t_user:
        actualDataNodes: user_ds.t_user
      t_order:
        actualDataNodes: order_ds_${0..1}.t_order${0..1}
        databaseStrategy:
          standard:
            shardingColumn: user_id
            shardingAlgorithmName: userid_inline
        tableStrategy:
          standard:
            shardingColumn: id
            shardingAlgorithmName: orderid_inline
​
    shardingAlgorithms:
      userid_inline:
        type: INLINE
        props:
          algorithm-expression: order_ds_${user_id % 2}
      orderid_inline:
        type: INLINE
        props:
          algorithm-expression: t_order${id % 2}

测试：

复制代码 
/**
 * 水平分片：分表插入数据测试
 */
@Test
public void testInsertOrderTableStrategy(){
​
    for (long i = 0; i < 4; i++) {
        Order order = new Order();
        order.setOrderNo("" + System.currentTimeMillis());
        order.setUserId(1L);
        orderMapper.insert(order);
    }
​
    for (long i = 0; i < 4; i++) {
​
        Order order = new Order();
        order.setOrderNo(System.currentTimeMillis());
        order.setUserId(2L);
        orderMapper.insert(order);
    }
}

6.3 多表关联

6.3.1 创建关联表

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

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

那么在t_order_item中我们也需要创建order_id和user_id这两个分片键

复制代码 
CREATE TABLE t_order_item0(
    id BIGINT,
    user_id BIGINT,
    order_id BIGINT,
    price DECIMAL(10,2),
    `count` INT,
    PRIMARY KEY(id)
);
​
CREATE TABLE t_order_item1(
    id BIGINT,
    user_id BIGINT,
    order_id BIGINT,
    price DECIMAL(10,2),
    `count` INT,
    PRIMARY KEY(id)
);

6.3.2 创建实体类

复制代码 
​
@TableName("t_order_item")
@Data
public class OrderItem {
​
    @TableId(type = IdType.ASSIGN_ID) //分布式id
    private Long id;
    private Long userId;
    private Long orderId;
    private BigDecimal price;
    private Integer count;
}

6.3.3 创建Mapper

复制代码 
​
@Mapper
public interface OrderItemMapper extends BaseMapper<OrderItem> {
}

6.3.4 配置关联表

t_order_item的分片表、分片策略、分布式序列策略和t_order一致

复制代码 
rules:
  - !SHARDING
    tables:
      t_user:
        actualDataNodes: user_ds.t_user
      t_order:
        actualDataNodes: order_ds_${0..1}.t_order${0..1}
        databaseStrategy:
          standard:
            shardingColumn: user_id
            shardingAlgorithmName: userid_inline
        tableStrategy:
          standard:
            shardingColumn: id
            shardingAlgorithmName: orderid_inline
      t_order_item:
        actualDataNodes: order_ds_${0..1}.t_order_item${0..1}
        databaseStrategy:
          standard:
            shardingColumn: user_id
            shardingAlgorithmName: userid_inline
        tableStrategy:
          standard:
            shardingColumn: order_id
            shardingAlgorithmName: orderid_item_inline
​
    shardingAlgorithms:
      userid_inline:
        type: INLINE
        props:
          algorithm-expression: order_ds_${user_id % 2}
      orderid_inline:
        type: INLINE
        props:
          algorithm-expression: t_order${id % 2}
      orderid_item_inline:
        type: INLINE
        props:
          algorithm-expression: t_order_item${order_id % 2}

6.3.5 测试插入数据

同一个用户的订单表和订单详情表中的数据都在同一个数据源中，避免跨库关联

复制代码 
   /**
     * 测试关联表插入
     */
    @Test
    public void testInsertOrderAndOrderItem(){
​
​
        for (long i = 0; i < 2; i++) {
​
            Order order = new Order();
            order.setOrderNo("" + System.currentTimeMillis());
            order.setUserId(1L);
            orderMapper.insert(order);
​
            for (long j = 0; j < 2; j++) {
                OrderItem orderItem = new OrderItem();
                orderItem.setUserId(1L);
                orderItem.setOrderId(order.getId());
                orderItem.setPrice(new BigDecimal(10));
                orderItem.setCount(2);
                orderItemMapper.insert(orderItem);
            }
        }
​
        for (long i = 0; i < 2; i++) {
            Order order = new Order();
            order.setOrderNo("" + System.currentTimeMillis());
            order.setUserId(2L);
            orderMapper.insert(order);
            for (long j = 0; j < 2; j++) {
                OrderItem orderItem = new OrderItem();
                orderItem.setUserId(2L);
                orderItem.setOrderId(order.getId());
                orderItem.setPrice(new BigDecimal(5));
                orderItem.setCount(2);
                orderItemMapper.insert(orderItem);
            }
        }
    }
相关推荐
isNotNullX32 分钟前
据字典是什么？和数据库、数据仓库有什么关系？
大数据·数据库·数据仓库·oracle·数据治理
考虑考虑1 小时前
数据库唯一索引
数据库·后端·mysql
AA-代码批发V哥1 小时前
MySQL之事务深度解析
数据库·mysql
里探1 小时前
在Django中把Base64字符串保存为ImageField
数据库·django
全栈小52 小时前
【数据库】零门槛在线体验KingbaseES平台，SQL Server模式高阶玩法，动态创建数据体验函数、存储过程等功能
数据库·sql server·金仓·kingbasees平台
奈斯ing3 小时前
【MySQL篇】高效学习官方文档指南(基于MySQL8.0版本详解)
运维·数据库·学习·mysql
Brandon汐3 小时前
数据库part2---子查询
数据库·sql
Tapdata 钛铂数据4 小时前
信创 CDC 实战｜国产数据库的数据高速通道：OceanBase 实时入仓 StarRocks
数据库·oceanbase
liyongjie4 小时前
openGauss数据库DWR报告解读
数据库·oracle
楼台的春风4 小时前
【Linux驱动开发 ---- 4.1_sysfs 详解】
linux·运维·c语言·数据库·人工智能·驱动开发·嵌入式硬件
热门推荐
01扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解02Coze扣子平台完整体验和实践（附国内和国际版对比）03KGG转MP3工具|非KGM文件|解密音频04DeepSeek各版本说明与优缺点分析05零代码入门 | Coze——让大模型接入自己的数据库06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07AI Agent | Coze 插件使用指南：从功能解析到实操步骤08扣子空间的使用教程与大模型技术思考09YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】10坚果投影仪J10如何用苹果Siri开关机并和米家联动