❌

阅读视图

发现新文章，点击刷新页面。
🔲 ☆

周刊第二期

✇胡涂说
本文为周刊第二期，上一期: [周刊开刊](/weekly-1)。 文摘 由于 The New York Times 每日推送消息太多，我已经将它从 Pocket 源中删除。 1. [RECONSIDER](https://medium.com/@dhh/reconsider-41adf356857f) [Ruby on...
🔲 ☆

周刊开刊

✇胡涂说
[阮一峰](http://www.ruanyifeng.com/blog/)在两年前开始做周刊，记录每周值得分享的科技内容，目前已经做到[99期](http://www.ruanyifeng.com/blog/2020/03/weekly-issue-99.html)了。受他的启发，我也尝试写写周刊，一是总结自己的一周...
🔲 ☆

多机多盘 minio 集群不同纠删码配置在 IPoIB 下的性能测试

✇陈少文的博客
微信公众号
前面测试的发现瓶颈在网卡，本篇在 IPoIB 下进行补充测试。 1. minio 集群环境 1.1 创建 minio 集群 1 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 export CONTAINER_CLI=nerdctl export IMAGE=minio/minio:RELEASE.2025-04-22T22-12-26Z export ROOT_USER=minioadmin export ROOT_PASSWORD=minioadmin export MINIO_ERASURE_SET_DRIVE_COUNT=16 export MINIO_STORAGE_CLASS_STANDARD=EC:4 export POOL_0="http://minioib{1...4}/mnt/data{0...3}" $CONTAINER_CLI run -d \ --net host \ --ulimit memlock=-1 \ --ulimit stack=67108864 \ --ulimit nofile=1048576:1048576 \ --memory-swappiness=0 \ --name minio \ -v /mnt/data0:/mnt/data0 \ -v /mnt/data1:/mnt/data1 \ -v /mnt/data2:/mnt/data2 \ -v /mnt/data3:/mnt/data3 \ -e "MINIO_ROOT_USER=$ROOT_USER" \ -e "MINIO_ROOT_PASSWORD=$ROOT_PASSWORD" \ -e "MINIO_ERASURE_SET_DRIVE_COUNT=$MINIO_ERASURE_SET_DRIVE_COUNT" \
🔲 ☆

MinIO 多节点多盘部署与运维

✇陈少文的博客
微信公众号
1. 环境准备 1.1 数据盘准备 查看数据盘 1 lsblk -d -o NAME,SIZE,TYPE | grep nvme 1 2 3 4 nvme0n1 745.2G disk nvme1n1 745.2G disk nvme2n1 745.2G disk nvme3n1 745.2G disk 准备存储目录 1 2 3 for i in {0..3}; do mkdir -p /mnt/data${i} done 格式化数据盘 1 2 3 for i in {0..3}; do mkfs.xfs -f /dev/nvme${i}n1 done 挂载数据盘 1 2 3 for i in {0..3}; do mount /dev/nvme${i}n1 /mnt/data${i} done 清空数据盘 1 2 3 4 for i in {0..3}; do rm -rf /mnt/data${i}/* rm -rf /mnt/data${i}/.minio.sys done 查看挂载情况
🔲 ☆

分布式 | 如何解决重复消费 | 小记

✇yiyun's Blog
yiyun

𠄗𠳵

𡎱𯊐𡢉𭇥𬷿𤸳𪯰𧂿（𨝶𤒪𥎉𧟭𬓃𬓃𨥋𤜾𥶝𬱆、𥎉𭵰𣝡𭝉𣏅𤜾𥶝𬱆、𫎉𧟭𭖙𭝉𧟭）𣲐，𨴧𬘭𠀐𥠔𪱌𥟽、𯇫𮜅𮽃𦦕𣤵、𤟴𣢚𮽃𦦕𧼠𭅢𢅜𦻰𫉙𬚑，𭇥𬷿𦦕𨕱𪳒𭔾𮃇𦌅𭅺𪶴。
𬚑𠫎，𣿽𨘍𦤳𢽮𩎄𭶽𪶴𪌎𡐽𤸘𠜂𫿲𡎱“𤗘”，𤀿𡎱“𡸘”，𤄨𡎱𭇥𡎭𮽃𮍀幂𭅢𭀁𠶈𮈋。

𯚚𬂪幂𭅢𭀁，𪳒𧆋𢽮𮾻𣍴𨟕𣇓𢅜𮾻𦦕𨕱𣍴𨟕𤶙𤷍𮡈𣿦𡒉𪶴𤋑𭭝𪳒𢽮𫹉𪶴。𮯱𨏍𢋄𠴃𪇅𬻡𢽮𦉋𩏄𧜖𪶴𤒪𧹘𬱆𦒚𤒪𥓖𠼜𮜛𮈋𣿽：

  • 幂𭅢𣤸𢫋：

    1
    UPDATE order_table SET counter = 10 WHERE id = 1;

    𭔾𨿇𬰭𧙹𢅜𩣡𮾻，counter𤒪𪶴𣝥𬍘𡗀𭩔𪳒𤒪𡆐𦢏。

  • 𫻒幂𭅢𣤸𢫋：

    1
    UPDATE order_table SET counter = counter + 1 WHERE id = 1;

    𩆿𮾻𬰭𧙹𭩔𩊼𩓴𬂭𬲮𮡟。𨝶𮡟𭇥𬷿𦦕𨕱𣔵𫹉庰𣖴𨹤𢵗𬰭𧙹𢅜𮾻，counter𤒪𪶴𣝥𮎩𩊼𠱾𫃑𮜑𩐥𮿕𢅜𮾻。

𣿽𨘍𦦕𨕱𭇥𡎭𪶴𪅎𣦋，𮎩𪳒𬻗𦤳𦻰𫻒幂𭅢𪶴𠽐𣢚𣤸𢫋𭒟𩴖𫽡幂𭅢𣤸𢫋。𩫵𠰒𪶴𣿽𨘍𤸘𠜂𤔭𡊧𨯶𪹠𦻰。

🔲 ☆

分布式计算框架 Ray

✇陈少文的博客
微信公众号
1. 什么是 Ray 2016 年，UC Berkeley 的 RISELab 发布了一个新的分布式计算框架 Ray。 2017 年，发布 Ray 相关论文之后，受到业内的广泛关注，国内主要是蚂蚁集团采用并贡献了 Ray。 2020 年，Ray 发布了 1.0 版本，引入 Placement Group 特性，增加了用户自定义任务编排的灵活性，为后续的 Ray AI Libraries 和 vLLM 等
🔲 ☆

MPI 通信原语及 Python 编程使用

✇陈少文的博客
微信公众号
1. 什么是 MPI MPI，Message Passing Interface 消息传递接口，是一种用于并行计算的通信协议。 MPI 提供了一组标准化的接口，用于在不同的计算节点之间传输数据，广泛应用于科学计算、机器学习、深度学习等领域。 MPI 有多个实现，常用实现有 MPICH 和 OpenMPI。MPICH
🔲 ☆

关于多写入点数据库集群的一些想法

✇idea's blog
ideawu

在分布式数据库系统领域, 多主(多写入点, Leader-less)是一个非常诱人的特性, 因为客户端可以随机请求任何一个节点. 这种可随机选择访问点(写入点)的特性, 使得系统的高可用唾手可得, 因为当客户端发现某个节点出故障时, 更换另一个节点重试就可以了, 只要系统没有完全宕机, 几次重试之后一定成功, 也就可以达到百分之百高可用.

传统的 Basic Paxos 常常被误认为是 Leader-less 的, 也即多主, 但 Basic Paxos 只能用于确定一个实例的共识, 真正落地还需要结合日志复制状态机, 如果复制组(多节点)不指定 Leader 的话, 那么就会出现争取同一个位置的日志的情况, 也就是在尝试达成这个位置的日志的共识时出现活锁. 这种多节点争取同一个位置的情况, 在实践上将导致系统不可用, 因为, 通常自称采用 Paxos 的多副本数据库系统, 依然要显式指定 Leader, 并不是真正 Leader-less 的.

借鉴 vector 时钟和多复制组的思路(如 Multi Raft Group), 是可以避免多主冲突的, 因为, 不同的节点作为各自组的 Leader, 分别写入不同的日志序列, 也就完全没有争取同一个位置的日志而导致冲突了.

以一个3节点的集群来举例, 通过预先配置强制指定各为其主, 结构为:

主 从 从
G1 A B C
G2 B A C
G3 C B A

有复制组 G1, 成员节点是 {A, B, C}, 其中节点 A 是主. 类似的, 复制组 G2 和 G3 的主是 B, C. 当客户端请求不同节点时, 将日志写入不同复制组的日志序列, 因此不会产生冲突.

某一时刻, 所有节点的状态是:

G1 G2 G3
A 6 1 2
B 6 1 2
C 6 1 2

这个状态表明, 复制组 G1 累计有 6 条日志, 复制组 G2 是 1 条, 复制组 G3 是 2 条.

到目前为此, 似乎一切顺利, 写入没有冲突, 还能通过复制组形成多副本. 但是, 现实不是这样的, 一个只能写入的数据库几乎没有任何用处, 数据库必须支持读取, 所以, 日志复制状态机架构必须有状态机, 也即这 3 条日志序列必须在所有节点 Apply 到各节点的状态机实例中.

最简单的方法是在各个节点上把 3 条日志序列合并成(Merge)一条日志序列, 通过某种算法保证所有节点上的合并结果一定是相同的, 例如按时间戳排序, 这样才能保证状态机一致(相同).

但是, 节点不能只依赖自己本地的 3 条日志序列合并, 在每一次合并时, 它需要获取其它复制组的最新信息, 判断自己本地的日志序列是不是足够新. 自己作为 Leader 的那一条序列, 当然自己能确定, 但其它两条不能, 需要询问其它节点, 不能定死询问 Leader, 因为需要容忍某个复制组的 Leader 宕机的情况.

所以, 针对其它复制组, 采取 Read Index 逻辑, 可以判断是否最新. 并且在其它组 Leader 宕机的情况下, 将对应的日志序列从其它 Follower 那里补齐.

日志序列中可能包含非幂等的指令, 通过加入时间戳之后, 非幂等的指令可以变成幂等的.(需要文章论证). 以一个 key 为例, 状态机中的 key-value 带有初始化时间戳和最新更新时间戳 {reset_time, modify_time}. 当收到一条 incr 指令时, 指令中带有时间戳, 与 key-value 中的 meta 信息比对之后, 就能知道 Apply 算法.

if key.reset_time < op.time {
	value += 1
} else {
	// 忽略在初始化之前的指令
}

例如, 在 A 节点上针对 key 执行了 set 操作, 便会复位其 reset_time, 之后, 再收到其它节点的更早的 incr 指令时, 这个 incr 指令就不能修改状态机了, 因为这个指令发生在复位之前.

各个节点的系统时钟不同步没关系, 因为一致性与系统时钟没有必然联系(需要文章论证). 只要确保所有节点最终的结果是一致的(相同)的就行. 不要让 A 节点先执行 set 再执行 incr, 而 B 节点先执行 incr 再执行 set 这种情况出现. 在这个例子中, 从上帝视角知道 incr 在 set 之前, 所以, A 节点先执行 set, 然后遇到 incr 指令时会忽略.

上面的时间戳比较要求不同的节点产生的时间戳不能相同, 可以把节点ID当作时间戳的最低位, 避免两个时间戳相同.

对于 incr 操作, 初始化比较简单, 但是, 对于 pop 这种非幂等性的操作, 并不是初始化, 很难解决. 本质上, 是一种回滚操作, 能实现, 但成本太大, 要讨论起来真是够多的.

不同的节点收到不是自己负责的日志序列的延迟不一定, 但是, 我们又不能等确保全部日志序列都收到之后再 Apply, 虽然等全部日志序列都到齐之后再 Apply 可以不需要回滚操作, 但等待行为不能容忍宕机(CAP 理论).

总结起来, 就是没有银弹. vector 时钟看起来很美好, 但日志序列之间的相互依赖问题, 要么通过停止等待来解决, 要么通过回滚操作来解决, 否则无法保证多副本一致(相同). 但是, 某些操作的回滚成本太大.

注: 有一种技术叫 CRDT, 思想类似, 但是上面讨论的问题依然存在.

考虑过这个问题:

C 宕机, 但是它上面有一条日志还没有复制到其它节点.

A 和 B 各自合并日志序列之后 Apply 了, 两者的状态机一致, 没问题.

这时, C 恢复, 那条日志得以复制出去, 这时, A 和 B 需要回滚, 然后重新合并, 再 Apply.

如果 C 在恢复之后, 给那条日志赋予新的时间戳, 那么也会有一种场景(C 宕机前日志已经复制出去了, 但它还没知道结果), 同样需要回滚, 因为别的节点可能已经 Apply 过那条日志了.

Related posts:

  1. Paxos和Raft读优化 – Quorum Read 和 Read Index
  2. 什么是 Paxos 的日志空洞?
  3. Paxos 算法实现和工程落地: 选主与复制状态机
  4. 为什么极少有开源的Paxos库?
  5. 为什么 Leader Based 的分布式协议 Raft 是更好的
🔲 ☆

ShardingSphere-JDBC介绍

✇御坂研究所
Raymond

ShardingSphere-JDBC是一款可以将JDBC操作进行封装，然后实现数据分片、分布式事务、读写分离、高可用、数据加密和数据脱敏等功能的模块。它的原理是实现JDBC的接口，随后将收到的JDBC操作进行改写和处理，再将操作命中到真正的数据库之上。因为它实现了JDBC接口，因此现有的Java项目都可以100%兼容使用，只需要依赖ShardingSphere-JDBC并提供相关的配置即可。

JDBC数据分片的简单使用

我们看一个简单的JDBC数据分片的例子，首先我们需要添加相关的maven依赖

1
2
3
4
5
6
7
8
9
10
 <dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>shardingsphere-jdbc-core</artifactId>
    <version>5.3.2</version>
</dependency>
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.0.33</version>
</dependency>

如上添加了shardingsphere-jdbc和mysql的依赖，shardingsphere-jdbc是项目的核心依赖，而mysql则是jdbc操作需要用到的依赖。添加了maven依赖之后我们可以先创建相关的数据库和表，创建数据库和表的sql如下

1
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET NAMES utf8 */;
/*!50503 SET NAMES utf8mb4 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+08:00' */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

-- 导出 ds_0 的数据库结构
DROP DATABASE IF EXISTS `ds_0`;
CREATE DATABASE IF NOT EXISTS `ds_0` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_0`;

-- 导出  表 ds_0.t_order 结构
DROP TABLE IF EXISTS `t_order`;
CREATE TABLE IF NOT EXISTS `t_order` (
  `id` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户id',
  `order_id` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '订单id'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出 ds_1 的数据库结构
DROP DATABASE IF EXISTS `ds_1`;
CREATE DATABASE IF NOT EXISTS `ds_1` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_1`;

-- 导出  表 ds_1.t_order 结构
DROP TABLE IF EXISTS `t_order`;
CREATE TABLE IF NOT EXISTS `t_order` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户id',
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '订单id'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出 ds_2 的数据库结构
DROP DATABASE IF EXISTS `ds_2`;
CREATE DATABASE IF NOT EXISTS `ds_2` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_2`;

-- 导出  表 ds_2.t_order 结构
DROP TABLE IF EXISTS `t_order`;
CREATE TABLE IF NOT EXISTS `t_order` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户id',
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '订单id'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出 ds_3 的数据库结构
DROP DATABASE IF EXISTS `ds_3`;
CREATE DATABASE IF NOT EXISTS `ds_3` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_3`;

-- 导出  表 ds_3.t_order 结构
DROP TABLE IF EXISTS `t_order`;
CREATE TABLE IF NOT EXISTS `t_order` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户id',
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '订单id'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出 ds_4 的数据库结构
DROP DATABASE IF EXISTS `ds_4`;
CREATE DATABASE IF NOT EXISTS `ds_4` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_4`;

-- 导出  表 ds_4.t_order 结构
DROP TABLE IF EXISTS `t_order`;
CREATE TABLE IF NOT EXISTS `t_order` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户id',
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '订单id'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出 ds_5 的数据库结构
DROP DATABASE IF EXISTS `ds_5`;
CREATE DATABASE IF NOT EXISTS `ds_5` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_5`;

-- 导出  表 ds_5.t_order 结构
DROP TABLE IF EXISTS `t_order`;
CREATE TABLE IF NOT EXISTS `t_order` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户id',
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '订单id'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

/*!40103 SET TIME_ZONE=IFNULL(@OLD_TIME_ZONE, 'system') */;
/*!40101 SET SQL_MODE=IFNULL(@OLD_SQL_MODE, '') */;
/*!40014 SET FOREIGN_KEY_CHECKS=IFNULL(@OLD_FOREIGN_KEY_CHECKS, 1) */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40111 SET SQL_NOTES=IFNULL(@OLD_SQL_NOTES, 1) */;

我们会创建6个数据库，分别为ds_0到ds_5，并且会在每个数据库里面创建一个名叫t_order的表。

为了使用shardingsphere-jdbc，我们需要创建相应的jdbc连接和配置，因为shardingsphere-jdbc实现了jdbc的接口，所以我们可以像使用普通的jdbc一样使用shardingsphere-jdbc。创建shardingsphere-jdbc连接的代码如下

1
2
Class.forName("org.apache.shardingsphere.driver.ShardingSphereDriver");
Connection conn = DriverManager.getConnection("jdbc:shardingsphere:classpath:shardingsphere-config.yaml");

如上我们创建了一个shardingsphere-jdbc的连接，可以看到就是一个创建JDBC的过程。其中使用的SPI类是org.apache.shardingsphere.driver.ShardingSphereDriver，而具体的jdbcUrl则是一个文件地址shardingsphere-config.yaml，shardingsphere-jdbc的配置就保存在这个文件中。根据shardingsphere-jdbc的官方文档，其配置包含五大类：

  1. JDBC逻辑数据库名称
  2. 运行模式配置
  3. 数据源集合配置
  4. 规则集合配置
  5. 属性配置

shardingsphere-jdbc的配置支持Java代码和yaml文件，这里我们只介绍yaml文件，下面是一个简单的例子shardingsphere-config.yaml

1
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
58
59
dataSources:
  ds_0:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://127.0.0.1:3306/ds_0
    username: root
    password: 1234
  ds_1:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://localhost:3306/ds_1
    username: root
    password: 1234
  ds_2:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://127.0.0.1:3306/ds_2
    username: root
    password: 1234
  ds_3:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://localhost:3306/ds_3
    username: root
    password: 1234
  ds_4:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://127.0.0.1:3306/ds_4
    username: root
    password: 1234
  ds_5:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://localhost:3306/ds_5
    username: root
    password: 1234
rules:
  - !SHARDING
    tables:
      t_order:
        actualDataNodes: ds_$->{0..5}.t_order
        databaseStrategy:
          standard:
            shardingColumn: id
            shardingAlgorithmName: testInline
        keyGenerateStrategy:
          column: id
          keyGeneratorName: snowflake
    shardingAlgorithms:
      testInline:
        type: INLINE
        props:
          algorithm-expression: ds_$->{id % 6}
    keyGenerators:
      snowflake:
        type: SNOWFLAKE
props:
  sql-show: true

如上配置了6个数据源分别是数据库ds_0到ds_5，props设置了打印sql语句，rules包含了表、分片算法和主键生成算法的配置。表设置中创建了一个逻辑表t_order，对应的真正数据库表是ds_0.t_order到ds_5.t_order，数据库的使用策略是通过id进行分片，分片算法是testInline，表的id字段的生成算法为snowflake。分片算法中定义了算法testInline，它使用INLINE内置方式来对id取模并和ds_进行拼接，构成数据库名。字段生成算法中定义了类型为SNOWFLAKE的字段生成算法。

有了如上配置之后，我们就可以使用shardingsphere-jdbc了。以一个数据插入操作为例，在引入了maven依赖、创建了相关的数据库和表、定义了相关的shardingsphere-jdbc配置之后，我们就可以使用上面创建的conn字段实现数据插入了。

1
2
3
4
5
6
7
String sql = "INSERT INTO t_order (`user_id`, `order_id`) VALUES (?, ?)";
PreparedStatement ps = conn.prepareStatement(sql))
for (int i = 0; i < 20; i++) {
    ps.setString(1, "userId");
    ps.setString(2, "orderId");
    ps.executeUpdate();
}

如上代码会创建一条数据并且随机根据snowflake算法生成一个id字段，并根据id字段的取模结果将数据保存到真正的数据库中去。更多的增删改查操作可在如下代码中看到：https://github.com/RitterHou/test-shardingsphere/tree/basic/src/main/java/com/nosuchfield/shardingsphere/data

SpringBoot集成MyBatis使用shardingsphere-jdbc

根据官方issue，目前shardingsphere-jdbc已经不再使用spring-boot-starter，而是直接使用jdbc实现相关功能。这种方式可以完美兼容JDBC的相关接口，因此可以简化很多已有项目的使用。

在SpringBoot中使用ShardingSphere需要设置如下的pom配置，在这里我们使用MyBatis作为ORM框架。

1
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.0</version>
    </parent>

    <groupId>com.nosuchfield</groupId>
    <artifactId>test-shardingsphere</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <java.version>17</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.28</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>shardingsphere-jdbc-core</artifactId>
            <version>5.3.2</version>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>8.0.33</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.1.2</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

SpringBoot的application.yml配置如下，这里配置的数据源驱动为ShardingSphereDriver，而url就是我们配置ShardingSphere属性的地方。除此之外，我们还配置了mybatis的SQL语句所对应xml文件的路径信息。

1
2
3
4
5
6
7
8
9
10
11
spring:
  datasource:
    url: jdbc:shardingsphere:classpath:shardingsphere/config.yaml
    driver-class-name: org.apache.shardingsphere.driver.ShardingSphereDriver
  application:
    name: ShardingSphere

mybatis:
  mapper-locations: classpath:mybatis/mapper/*.xml
  configuration:
    map-underscore-to-camel-case: true

接着我们配置ShardingSphere的配置信息config.yaml，这里的配置和上面简单使用的配置差不多，不再赘述了

1
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
58
59
60
61
62
63
64
65
66
67
dataSources:
  ds_0:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://127.0.0.1:3306/ds_0
    username: root
    password: 1234
  ds_1:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://localhost:3306/ds_1
    username: root
    password: 1234
  ds_2:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://127.0.0.1:3306/ds_2
    username: root
    password: 1234
  ds_3:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://localhost:3306/ds_3
    username: root
    password: 1234
  ds_4:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://127.0.0.1:3306/ds_4
    username: root
    password: 1234
  ds_5:
    dataSourceClassName: com.zaxxer.hikari.HikariDataSource
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://localhost:3306/ds_5
    username: root
    password: 1234
rules:
  - !SHARDING
    tables:
      t_order:
        actualDataNodes: ds_$->{0..5}.t_order_$->{1..2}
        databaseStrategy:
          standard:
            shardingColumn: id
            shardingAlgorithmName: databaseInline
        tableStrategy:
          standard:
            shardingColumn: id
            shardingAlgorithmName: tableInline
        keyGenerateStrategy:
          column: id
          keyGeneratorName: snowflake
    shardingAlgorithms:
      databaseInline:
        type: INLINE
        props:
          algorithm-expression: ds_$->{id % 6}
      tableInline:
        type: INLINE
        props:
          algorithm-expression: t_order_$->{id % 2 + 1}
    keyGenerators:
      snowflake:
        type: SNOWFLAKE
props:
  sql-show: true

接着我们定义一个订单模型Order，订单包含了一些属性信息

1
2
3
4
5
6
7
8
public class Order {
    private String        id;
    private String        orderId;
    private Long          userId;
    private BigDecimal    totalPrice;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

我们根据这个模型可以定义个MyBatis的Mapper，它包含了插入、查询的操作

1
2
3
4
5
6
7
@Mapper
public interface OrderMapper {
    void insert(Order order);
    List<Order> selectListByIds(@Param("idList") List<Long> idList);
    @Select("SELECT * FROM t_order")
    List<Order> getAllOrders();
}

其中getAllOrders方法通过注解实现了SQL的定义，而另外两个方法的SQL则在xml文件中进行实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nosuchfield.shardingsphere.mapper.OrderMapper">
    <insert id="insert" parameterType="com.nosuchfield.shardingsphere.model.Order">
        INSERT INTO t_order(user_id, order_id, total_price, create_time, update_time)
        VALUES(#{userId}, #{orderId}, #{totalPrice}, #{createTime}, #{updateTime})
    </insert>
    <select id="selectListByIds" resultType="com.nosuchfield.shardingsphere.model.Order">
        SELECT order_id, user_id, total_price, state FROM t_order WHERE order_id IN
        <foreach collection="idList" item="id" open="(" separator="," close=")">
            #{id}
        </foreach>
    </select>
</mapper>

构建了如上的ShardingSphere和MyBatis的配置之后，我们可以创建相关的数据库和表

1
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET NAMES utf8 */;
/*!50503 SET NAMES utf8mb4 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+08:00' */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;


-- 导出 ds_0 的数据库结构
DROP DATABASE IF EXISTS `ds_0`;
CREATE DATABASE IF NOT EXISTS `ds_0` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_0`;

-- 导出  表 ds_0.t_order_1 结构
DROP TABLE IF EXISTS `t_order_1`;
CREATE TABLE IF NOT EXISTS `t_order_1` (
  `id` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出  表 ds_0.t_order_2 结构
DROP TABLE IF EXISTS `t_order_2`;
CREATE TABLE IF NOT EXISTS `t_order_2` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';


-- 导出 ds_1 的数据库结构
DROP DATABASE IF EXISTS `ds_1`;
CREATE DATABASE IF NOT EXISTS `ds_1` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_1`;

-- 导出  表 ds_1.t_order_1 结构
DROP TABLE IF EXISTS `t_order_1`;
CREATE TABLE IF NOT EXISTS `t_order_1` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出  表 ds_1.t_order_2 结构
DROP TABLE IF EXISTS `t_order_2`;
CREATE TABLE IF NOT EXISTS `t_order_2` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';


-- 导出 ds_2 的数据库结构
DROP DATABASE IF EXISTS `ds_2`;
CREATE DATABASE IF NOT EXISTS `ds_2` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_2`;

-- 导出  表 ds_2.t_order_1 结构
DROP TABLE IF EXISTS `t_order_1`;
CREATE TABLE IF NOT EXISTS `t_order_1` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出  表 ds_2.t_order_2 结构
DROP TABLE IF EXISTS `t_order_2`;
CREATE TABLE IF NOT EXISTS `t_order_2` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';


-- 导出 ds_3 的数据库结构
DROP DATABASE IF EXISTS `ds_3`;
CREATE DATABASE IF NOT EXISTS `ds_3` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_3`;

-- 导出  表 ds_3.t_order_1 结构
DROP TABLE IF EXISTS `t_order_1`;
CREATE TABLE IF NOT EXISTS `t_order_1` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出  表 ds_3.t_order_2 结构
DROP TABLE IF EXISTS `t_order_2`;
CREATE TABLE IF NOT EXISTS `t_order_2` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';


-- 导出 ds_4 的数据库结构
DROP DATABASE IF EXISTS `ds_4`;
CREATE DATABASE IF NOT EXISTS `ds_4` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_4`;

-- 导出  表 ds_4.t_order_1 结构
DROP TABLE IF EXISTS `t_order_1`;
CREATE TABLE IF NOT EXISTS `t_order_1` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出  表 ds_4.t_order_2 结构
DROP TABLE IF EXISTS `t_order_2`;
CREATE TABLE IF NOT EXISTS `t_order_2` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';


-- 导出 ds_5 的数据库结构
DROP DATABASE IF EXISTS `ds_5`;
CREATE DATABASE IF NOT EXISTS `ds_5` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
USE `ds_5`;

-- 导出  表 ds_5.t_order_1 结构
DROP TABLE IF EXISTS `t_order_1`;
CREATE TABLE IF NOT EXISTS `t_order_1` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

-- 导出  表 ds_5.t_order_2 结构
DROP TABLE IF EXISTS `t_order_2`;
CREATE TABLE IF NOT EXISTS `t_order_2` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `order_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `user_id` bigint DEFAULT NULL,
  `total_price` decimal(20,6) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_time` datetime DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='订单表';

/*!40103 SET TIME_ZONE=IFNULL(@OLD_TIME_ZONE, 'system') */;
/*!40101 SET SQL_MODE=IFNULL(@OLD_SQL_MODE, '') */;
/*!40014 SET FOREIGN_KEY_CHECKS=IFNULL(@OLD_FOREIGN_KEY_CHECKS, 1) */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40111 SET SQL_NOTES=IFNULL(@OLD_SQL_NOTES, 1) */;

有了上面的数据库和表之后，我们就可以测试ShardingSphere的数据插入和查询了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class OrderMapperTest {
    @Autowired
    private OrderMapper orderMapper;
    @Test
    public void testInsert() {
        for (int i = 0; i < 30; i++) {
            Order order = new Order();
            order.setOrderId("66666666666");
            order.setUserId(1L);
            order.setTotalPrice(new BigDecimal((i + 1) * 5));
            order.setCreateTime(LocalDateTime.now());
            order.setUpdateTime(order.getCreateTime());
            this.orderMapper.insert(order);
        }
    }
    @Test
    public void testQueryAll() {
        List<Order> orders = orderMapper.getAllOrders();
        orders.forEach(order -> log.info(order.toString()));
    }
}

读写分离和数据脱敏

上面我们测试了ShardingSphere的数据分片功能，下面我们了解一下它的读写分离和数据脱敏。我们先在ds_0、ds_1和ds_2数据库中创建表t_user

1
2
3
4
5
6
CREATE TABLE `t_user` (
  `id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `phone` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL,
  `address` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

之后我们在ShardingSphere的rules属性下添加如下配置

1
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
- !READWRITE_SPLITTING
  dataSources:
    readwrite_ds:
      staticStrategy:
        writeDataSourceName: ds_0
        readDataSourceNames:
          - ds_1
          - ds_2
      loadBalancerName: random
  loadBalancers:
    random:
      type: RANDOM
- !MASK
  tables:
    t_user:
      columns:
        id:
          maskAlgorithm: md5_mask
        phone:
          maskAlgorithm: keep_first_n_last_m_mask
  maskAlgorithms:
    md5_mask:
      type: MD5
    keep_first_n_last_m_mask:
      type: KEEP_FIRST_N_LAST_M
      props:
        first-n: 3
        last-m: 4
        replace-char: '*'

配置包含了写库ds_0和读库ds_1、ds_2的配置，读库的负载均衡策略为随机（这里需要先设置ds_1和ds_2自动同步ds_0的数据，详细过程可查看文章MySQL实现双服务器主从同步）。数据脱敏策略为对t_user的id字段进行md5脱敏，对phone字段保留前3位和后4位，剩下的部分用*替换。创建好了表和配置之后，我们设置User的model

1
2
3
4
5
6
public class User {
    private String id;
    private String name;
    private String phone;
    private String address;
}

以及mapper

1
2
3
4
5
6
7
@Mapper
public interface UserMapper {
    @Insert("INSERT INTO t_user(id, name, phone, address) VALUES (#{id}, #{name}, #{phone}, #{address})")
    void save(User user);
    @Select("SELECT * FROM t_user")
    List<User> query();
}

之后我们测试上面的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Slf4j
public class UserMapperTest extends BaseTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testInsert() {
        userMapper.save(User.builder()
                .id("888")
                .name("小明")
                .phone("13866688888")
                .address("江苏省南京市").build());
    }
    @Test
    public void testQuery() {
        List<User> users = userMapper.query();
        log.info(users.toString());
    }
}

我们先插入数据，随后到从库中查询数据，得到结果如下

ShardingSphere-SQL:73 Logic SQL: SELECT * FROM t_userShardingSphere-SQL:73 Actual SQL: ds_1 ::: SELECT * FROM t_usercom.nosuchfield.shardingsphere.UserMapperTest:30 [User(id=0a113ef6b61820daa5611c870ed8d5ee, name=小明, phone=138****8888, address=江苏省南京市)]

可以看到数据插入到了主库中，随后从从库ds_1中查询出了相关的数据，并且对id和phone字段的数据进行了脱敏操作，id字段被转化为了MD5的结果，而phone的中间4位被星号替代了。

数据加密

数据加密可以保证我们存到数据库中的数据都是经过加密的，和数据脱敏刚好反过来。首先我们创建表t_member

1
2
3
4
CREATE TABLE `t_member` (
  `name` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL,
  `password` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

随后我们配置ShardingSphere的数据加密配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
- !ENCRYPT
  tables:
    t_member:
      columns:
        name:
          cipherColumn: name
          encryptorName: name_encryptor
        password:
          cipherColumn: password
          encryptorName: pwd_encryptor
      queryWithCipherColumn: true
  encryptors:
    name_encryptor:
      type: AES
      props:
        aes-key-value: 123abc
    pwd_encryptor:
      type: MD5
      props:
        salt: nosuchfield

我们将表t_member的name字段使用name_encryptor的加密方式进行加密，加密之后的字段名仍然叫做name，name_encryptor的配置在encryptors中可以看到，使用了AES加密算法并设置key为123abc。类似的，password的加密方式为MD5，在计算MD5的时候加盐nosuchfield。

随后我们创建model

1
2
3
4
public class Member {
    private String name;
    private String password;
}

和mapper

1
2
3
4
5
6
7
@Mapper
public interface MemberMapper {
    @Insert("INSERT INTO t_member(name, password) VALUES (#{name}, #{password})")
    void save(Member member);
    @Select("SELECT * FROM t_member")
    List<Member> query();
}

并测试写入和读取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Slf4j
public class MemberMapperTest extends BaseTest {
    @Autowired
    private MemberMapper memberMapper;
    @Test
    public void testSave() {
        memberMapper.save(Member.builder()
                .name("张三")
                .password("123456").build());
    }
    @Test
    public void testQuery() {
        List<Member> members = memberMapper.query();
        log.info(members.toString());
    }
}

在插入了数据{"name": "张三", "password": "123456"}之后，可以到数据库中查看插入的数据如下

PS C:\Program Files\MySQL\MySQL Server 8.0\bin> ./mysql -u root -pmysql> select * from t_member;+--------------------------+----------------------------------+| name                     | password                         |+--------------------------+----------------------------------+| Fod6ouOanqNvHlTdBsx1Lw== | 47514eed77109a04ce4c9f9931d0c5ec |+--------------------------+----------------------------------+1 row in set (0.00 sec)

可以看到name和password在存储到数据库的时候都加密了。随后我们执行测试代码中的查询逻辑，可以看到结果如下，name又通过AES算法解密成功，而password因为使用的是MD5算法就无法解密了

com.nosuchfield.shardingsphere.MemberMapperTest:27 [Member(name=张三, password=47514eed77109a04ce4c9f9931d0c5ec)]

本节使用到的代码：https://github.com/RitterHou/test-shardingsphere

参考

官方文档

❌