ShardingSphere5？ShardingSphere5 多库写

第01章 高性能架构模式

自从互联网业务兴起以来，由于用户数量庞大、数据量巨大的特点，单一的数据库服务器已经不能满足业务需求，不得不考虑数据库集群来提高性能。高性能数据库集群的第一个方法是“读/写分离”，第二个是“数据库分片”。

1、读写分离架构

读写分离原理：读写分离的基本原理是将数据库读写操作分布到不同的节点上。下面是它的基本架构图。

读写分离的基本实现：

主数据库负责处理事务的增、删、改操作，从数据库负责处理查询操作。这样有效避免了数据更新带来的行锁，显着提升了系统整体查询性能。读写分离基于SQL语义分析，将读写操作分别路由到主数据库和从数据库。单主多从配置允许查询请求均匀分布在数据的多个副本上，进一步提高系统的处理能力。使用多主多从不仅可以提高系统吞吐量，而且即使数据库宕机或者磁盘物理损坏也能保证系统正常运行。它对系统没有影响。
下图展示了根据业务需求将用户表的读写操作路由到不同数据库的解决方案。

CAP理论：

CAP定理又称布鲁尔定理，是加州大学伯克利分校计算机科学家埃里克·布鲁尔于2000年在ACM PODC上提出的猜想。 CAP 是架构师设计分布式系统的基本理论。

在分布式系统中，读写操作只能保证三者中的两项：一致性、可用性、分区容错性，必须牺牲其中一项。

C 一致性：对于给定的客户端，读操作保证返回最近的写操作的结果。 A 可用性：无故障节点返回适当的响应（不是错误或超时响应）。 P 分区容错（Partition Tolerance）：当网络分区发生时。 （可能出现数据包丢失、连接中断或拥塞），系统可以继续“完成其工作”。
CAP的特点：

在实际设计过程中，每个系统不可能只处理一种类型的数据，而是包含多种类型的数据，因此分布式系统应选择CA架构。

CP：如下图所示，为了保证一致性，当发生分区时，节点N1上的数据更新为y，但由于N1和N2之间的复制通道中断，导致数据y无法同步。到节点N2和N2的数据仍然是x。此时，当客户端C访问N2时，N2必须向客户端C返回一条错误消息，指出“系统当前存在错误”。但是，这种处理方法只能在可用性要求的情况下进行。三个CAP。 CP也很满意。
AP：如下图所示，为了保证可用性，当发生分区时，N1节点上的数据更新到y，但是由于N1和N2之间的复制通道中断，所以数据y无法更新。无法同步到N2，但N2节点上的数据无法同步到N2。数据仍然是x。现在，当客户端C访问N2时，N2将其当前拥有的数据x返回给客户端C。事实上，只有三个满足CAP AP，因为最新数据已经是y，不满足一致性要求。注意：虽然这里N2节点返回x，但这并不是一个“正确”的结果，而是一个“合理”的结果。这是因为x 是旧数据，不是不规则值，而且根本就不是最新的。

CAP理论的C在实际的数据复制过程中并不能完全实现。节点N1和N2上的数据不一致（强一致）。即使强一致性不可能实现，应用程序仍然可以通过适当的方式实现最终一致性。它具有以下特点：

基本可用性：如果分布式系统发生故障，则允许部分可用性丧失。这意味着核心可用性得到保证。软状态：允许系统存在于中间状态，而不影响整个系统的可用性。这里的中间状态就是CAP理论中的数据不一致。最终一致性：系统中的所有数据副本在一定时间后最终达到一致状态。

2、数据库分片架构

读/写分离问题：

分离读写可以平衡数据库读写操作的负载，但不会平衡存储的负载。为了满足业务数据存储需求，存储必须分布在多个数据库服务器上。

数据分片：

将存储在单个数据库中的数据分布到多个数据库或表中，以改善性能瓶颈和可用性。 数据分片的一种有效方法是将关系数据库分为数据库和表。数据分片分为垂直分片和水平分片。

2.1、垂直分片

垂直子库：

业务划分的方法称为垂直分片，也称为垂直拆分。其核心概念致力于专有数据库。 在分区之前，数据库由多个数据表组成，每个数据表服务于不同的业务。分区后，表根据业务进行分类，分布到不同的数据库中，从而将负载分散到不同的数据库上。

下图展示了根据业务需求将用户表和订单表垂直分片到不同数据库的解决方案。

垂直分区可以缓解数据量和访问带来的问题，但并不能解决问题。如果垂直拆分后表中的数据量仍超过单个节点可容纳的阈值，则需要水平分片进行进一步处理。

立式工作台：

垂直表拆分是拆分表中一些很少使用或占用大量空间的列的好方法。

假设这是一个约会网站。用户在过滤其他用户时，主要使用年龄和性别字段进行查询，而昵称和描述字段主要用于显示，通常不会在业务查询中使用。由于描述本身比较长，您可以将这两个字段拆分到单独的表中。这提高了查询年龄和性别时的性能。

垂直分表带来的复杂性主要体现在表操作数量的增加。例如，以前您可以在一个查询中获取姓名、年龄、性别、昵称和描述，而现在您需要两个查询：一个查询获取姓名、年龄和性别，另一个查询获取昵称和描述。还需要一个查询来执行此操作。
步骤1：Master将数据变化记录在二进制日志中。步骤2：在slave上运行slave start命令后，slave创建一个IO线程连接master，请求master中的二进制日志。步骤3：当slave连接到master时，master创建一个日志转储线程并发送二进制日志内容。在读取binlog内容的操作过程中，主节点上的binlog会被锁定，一旦读取完成并发送到从服务器上就会解锁。步骤4：IO线程接收到主节点binlog dump进程的更新后，将其保存到中继日志中。步骤5：从SQL线程读取中继日志并解析为具体操作。这提供了一致的主/从操作和最终的数据一致性。

2.2、水平分片

服务器规划：使用docker创建。主从服务器IP一致，端口号不匹配。

主服务器：容器名称atguigu-mysql-master，端口3306 从服务器：容器名称atguigu-mysql-slave1，端口3307 从服务器：容器名称atguigu-mysql-slave2，端口3308
注意：如果此时您的防火墙已打开，请先将其关闭，然后重新启动docker。否则，后续MySQL安装将无法启动。

#关闭泊坞窗
systemctl 停止docker
#关闭防火墙
systemctl 停止防火墙
#启动码头工人
systemctl启动docker复制错误复制到剪贴板

3、读写分离和数据分片架构

步骤1：在Docker中创建并启动MySQL主服务器：端口3306
docker 运行-d \\
-p 3306:3306 \\
-v /atguigu/mysql/master/conf:/etc/mysql/conf.d \\
-v /atguigu/mysql/master/data:/var/lib/mysql \\
-e MYSQL_ROOT_PASSWORD=123456 \\
–name atguigu-mysql-master \\
mysql:8.0.29复制错误复制到剪贴板
步骤2：创建MySQL主服务器配置文件。
默认情况下，MySQL 二进制日志记录是自动启用的。您可以通过以下设置来定义一些可选设置：

vim /atguigu/mysql/master/conf/my.cnf 复制错误复制到剪贴板
设置以下内容

[mysqld]
# 服务器唯一ID，默认值1
服务器ID=1
#设置日志格式。默认值为行。
binlog_format=语句
# 二进制日志名称，默认二进制日志
# log-bin=binlog
# 设置需要复制的数据库。默认情况下，复制所有数据库。
#binlog-do-db=mytestdb
# 设置不需要复制的数据库
#binlog-ignore-db=mysql
#binlog-ignore-db=infomation_schema 复制错误已复制到剪贴板
重启MySQL容器

docker restart atguigu-mysql-master 复制错误复制到剪贴板
Binlog格式说明：

binlog_format=STATMENT：日志记录主机数据库写入指令，性能较高，但now()、系统参数获取等函数会导致主从数据不同步。 binlog_format=ROW（默认）：日志记录写入主机数据库的数据。这解决了master 上的now()、user() 或@@hostname 等操作之间的不匹配问题。还有一台奴隶机。 binlog_format=MIXED：混合使用上述两个级别。有些函数使用ROW，但没有使用STATEMENT。但是，系统变量不被识别。
binlog-ignore-db 和binlog-do-db 的优先级问题：

步骤3：使用命令行登录MySQL主服务器。
#进入容器，避免容器内部显示乱码：env LANG=C.UTF-8
docker exec -it atguigu-mysql-master env LANG=C.UTF-8 /bin/bash
# 在容器中输入mysql命令行
mysql-uroot-p
#更改默认的密码验证方式
ALTER USER \’root\’@\’%\’ IDENTIFIED WITH mysql_native_password BY \’123456\’;复制到剪贴板错误已复制
第四步：在主机上创建从用户。
–创建从属用户
创建用户\’atguigu_slave\’@\’%\’。
– 请设置密码
更改用户\’atguigu_slave\’@\’%\’ 通过mysql_native_password 识别为\’123456\’；
–授予复制权限
允许*.* 的从属复制到“atguigu_slave”@“%”。
— 更新权限
Flash 权限；复制到剪贴板错误
第五步：查询主机上的master状态。
为防止主服务器状态值发生变化，执行此步骤后请勿再次与主服务器MYSQL进行交互。

显示主状态；复制错误已复制到剪贴板
记下文件和位置值。为防止主服务器状态值发生变化，执行此步骤后请勿再次与主服务器MYSQL进行交互。

4、实现方式

可以设置多台从机slave1,slave2.这里我们以slave1为例。

步骤1：在Docker中创建并启动MySQL从服务器：端口3307
docker 运行-d \\
-p 3307:3306 \\
-v /atguigu/mysql/slave1/conf:/etc/mysql/conf.d \\
-v /atguigu/mysql/slave1/data:/var/lib/mysql \\
-e MYSQL_ROOT_PASSWORD=123456 \\
–name atguigu-mysql-slave1 \\
mysql:8.0.29复制错误复制到剪贴板
步骤2：创建MySQL从服务器配置文件。
vim /atguigu/mysql/slave1/conf/my.cnf 复制错误复制到剪贴板
设置以下内容：

[mysqld]
# 服务器的唯一ID。如果配置其他从服务器，请更改每个服务器的ID。
服务器ID=2
# 中继日志名称，默认xxxxx

phere</groupId>
<artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
<version>5.1.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.3.1</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>Copy to clipboardErrorCopied

1.3、创建实体类

package com.atguigu.shardingjdbcdemo.entity;
@TableName(\”t_user\”)
@Data
public class User {
@TableId(type = IdType.AUTO)
private Long id;
private String uname;
}Copy to clipboardErrorCopied

1.4、创建Mapper

package com.atguigu.shardingjdbcdemo.mapper;
@Mapper
public interface UserMapper extends BaseMapper<User> {
}Copy to clipboardErrorCopied

1.5、配置读写分离

application.properties：

# 应用名称
spring.application.name=sharging-jdbc-demo
# 开发环境设置
spring.profiles.active=dev
# 内存模式
spring.shardingsphere.mode.type=Memory
# 配置真实数据源
spring.shardingsphere.datasource.names=master,slave1,slave2
# 配置第 1 个数据源
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://192.168.100.201:3306/db_user
spring.shardingsphere.datasource.master.username=root
spring.shardingsphere.datasource.master.password=123456
# 配置第 2 个数据源
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://192.168.100.201:3307/db_user
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://192.168.100.201:3308/db_user
spring.shardingsphere.datasource.slave2.username=root
spring.shardingsphere.datasource.slave2.password=123456
# 读写分离类型，如: Static，Dynamic
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.type=Static
# 写数据源名称
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.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=alg_round
# 负载均衡算法配置
# 负载均衡算法类型
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_round.type=ROUND_ROBIN
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_random.type=RANDOM
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_weight.type=WEIGHT
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_weight.props.slave1=1
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_weight.props.slave2=2
# 打印SQl
spring.shardingsphere.props.sql-show=trueCopy to clipboardErrorCopied

2、测试

2.1、读写分离测试

package com.atguigu.shardingjdbcdemo;
@SpringBootTest
class ReadwriteTest {
@Autowired
private UserMapper userMapper;
/**
* 写入数据的测试
*/
@Test
public void testInsert(){
User user = new User();
user.setUname(\”张三丰\”);
userMapper.insert(user);
}
}Copy to clipboardErrorCopied

2.2、事务测试

为了保证主从库间的事务一致性，避免跨服务的分布式事务，ShardingSphere-JDBC的主从模型中，事务中的数据读写均用主库。

不添加@Transactional：insert对主库操作，select对从库操作添加@Transactional：则insert和select均对主库操作注意：在JUnit环境下的@Transactional注解，默认情况下就会对事务进行回滚（即使在没加注解@Rollback，也会对事务回滚）
/**
* 事务测试
*/
@Transactional//开启事务
@Test
public void testTrans(){
User user = new User();
user.setUname(\”铁锤\”);
userMapper.insert(user);
List<User> users = userMapper.selectList(null);
}Copy to clipboardErrorCopied

2.3、负载均衡测试

/**
* 读数据测试
*/
@Test
public void testSelectAll(){
List<User> users = userMapper.selectList(null);
List<User> users = userMapper.selectList(null);//执行第二次测试负载均衡
users.forEach(System.out::println);
}
Copy to clipboardErrorCopied
也可以在web请求中测试负载均衡

package com.atguigu.shardingjdbcdemo.controller;
@RestController
@RequestMapping(\”/userController\”)
public class UserController {
@Autowired
private UserMapper userMapper;
/**
* 测试负载均衡策略
*/
@GetMapping(\”selectAll\”)
public void selectAll(){
List<User> users = userMapper.selectList(null);
users.forEach(System.out::println);
}
}Copy to clipboardErrorCopied

第05章 ShardingSphere-JDBC垂直分片

1、准备服务器

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

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

1.1、创建server-user容器

step1：创建容器：
docker run -d \\
-p 3301:3306 \\
-v /atguigu/server/user/conf:/etc/mysql/conf.d \\
-v /atguigu/server/user/data:/var/lib/mysql \\
-e MYSQL_ROOT_PASSWORD=123456 \\
–name server-user \\
mysql:8.0.29Copy to clipboardErrorCopied
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\’;Copy to clipboardErrorCopied
step3：创建数据库：
CREATE DATABASE db_user;
USE db_user;
CREATE TABLE t_user (
id BIGINT AUTO_INCREMENT,
uname VARCHAR(30),
PRIMARY KEY (id)
);Copy to clipboardErrorCopied

1.2、创建server-order容器

step1：创建容器：
docker run -d \\
-p 3302:3306 \\
-v /atguigu/server/order/conf:/etc/mysql/conf.d \\
-v /atguigu/server/order/data:/var/lib/mysql \\
-e MYSQL_ROOT_PASSWORD=123456 \\
–name server-order \\
mysql:8.0.29Copy to clipboardErrorCopied
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\’;Copy to clipboardErrorCopied
step3：创建数据库：
CREATE DATABASE db_order;
USE db_order;
CREATE TABLE t_order (
id BIGINT AUTO_INCREMENT,
order_no VARCHAR(30),
user_id BIGINT,
amount DECIMAL(10,2),
PRIMARY KEY(id)
);Copy to clipboardErrorCopied

2、程序实现

2.1、创建实体类

package com.atguigu.shardingjdbcdemo.entity;
@TableName(\”t_order\”)
@Data
public class Order {
@TableId(type = IdType.AUTO)
private Long id;
private String orderNo;
private Long userId;
private BigDecimal amount;
}Copy to clipboardErrorCopied

2.2、创建Mapper

package com.atguigu.shardingjdbcdemo.mapper;
@Mapper
public interface OrderMapper extends BaseMapper<Order> {
}Copy to clipboardErrorCopied

2.3、配置垂直分片

# 应用名称
spring.application.name=sharding-jdbc-demo
# 环境设置
spring.profiles.active=dev
# 配置真实数据源
spring.shardingsphere.datasource.names=server-user,server-order
# 配置第 1 个数据源
spring.shardingsphere.datasource.server-user.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-user.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-user.jdbc-url=jdbc:mysql://192.168.100.201:3301/db_user
spring.shardingsphere.datasource.server-user.username=root
spring.shardingsphere.datasource.server-user.password=123456
# 配置第 2 个数据源
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://192.168.100.201:3302/db_order
spring.shardingsphere.datasource.server-order.username=root
spring.shardingsphere.datasource.server-order.password=123456
# 标准分片表配置（数据节点）
# spring.shardingsphere.rules.sharding.tables.<table-name>.actual-data-nodes=值
# 值由数据源名 + 表名组成，以小数点分隔。
# <table-name>：逻辑表名
spring.shardingsphere.rules.sharding.tables.t_user.actual-data-nodes=server-user.t_user
spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=server-order.t_order
# 打印SQL
spring.shardingsphere.props.sql-show=true
Copy to clipboardErrorCopied

3、测试垂直分片

package com.atguigu.shardingjdbcdemo;
@SpringBootTest
public class ShardingTest {
@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(\”ATGUIGU001\”);
order.setUserId(user.getId());
order.setAmount(new BigDecimal(100));
orderMapper.insert(order);
}
/**
* 垂直分片：查询数据测试
*/
@Test
public void testSelectFromOrderAndUser(){
User user = userMapper.selectById(1L);
Order order = orderMapper.selectById(1L);
}
}Copy to clipboardErrorCopied

常见错误

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

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

ALTER USER \’root\’@\’%\’ IDENTIFIED WITH mysql_native_password BY \’123456\’;Copy to clipboardErrorCopied

第06章 ShardingSphere-JDBC水平分片

1、准备服务器

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

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

1.1、创建server-order0容器

step1：创建容器：
docker run -d \\
-p 3310:3306 \\
-v /atguigu/server/order0/conf:/etc/mysql/conf.d \\
-v /atguigu/server/order0/data:/var/lib/mysql \\
-e MYSQL_ROOT_PASSWORD=123456 \\
–name server-order0 \\
mysql:8.0.29Copy to clipboardErrorCopied
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\’;Copy to clipboardErrorCopied
step3：创建数据库：
注意：水平分片的id需要在业务层实现，不能依赖数据库的主键自增

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

1.2、创建server-order1容器

step1：创建容器：
docker run -d \\
-p 3311:3306 \\
-v /atguigu/server/order1/conf:/etc/mysql/conf.d \\
-v /atguigu/server/order1/data:/var/lib/mysql \\
-e MYSQL_ROOT_PASSWORD=123456 \\
–name server-order1 \\
mysql:8.0.29Copy to clipboardErrorCopied
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\’;Copy to clipboardErrorCopied
step3：创建数据库：和server-order0相同
注意：水平分片的id需要在业务层实现，不能依赖数据库的主键自增

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

2、基本水平分片

2.1、基本配置

#========================基本配置
# 应用名称
spring.application.name=sharging-jdbc-demo
# 开发环境设置
spring.profiles.active=dev
# 内存模式
spring.shardingsphere.mode.type=Memory
# 打印SQl
spring.shardingsphere.props.sql-show=trueCopy to clipboardErrorCopied

2.2、数据源配置

#========================数据源配置
# 配置真实数据源
spring.shardingsphere.datasource.names=server-user,server-order0,server-order1
# 配置第 1 个数据源
spring.shardingsphere.datasource.server-user.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-user.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-user.jdbc-url=jdbc:mysql://192.168.100.201:3301/db_user
spring.shardingsphere.datasource.server-user.username=root
spring.shardingsphere.datasource.server-user.password=123456
# 配置第 2 个数据源
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://192.168.100.201:3310/db_order
spring.shardingsphere.datasource.server-order.username=root
spring.shardingsphere.datasource.server-order.password=123456
# 配置第 3 个数据源
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://192.168.100.201:3311/db_order
spring.shardingsphere.datasource.server-order.username=root
spring.shardingsphere.datasource.server-order.password=123456Copy to clipboardErrorCopied

2.3、标椎分片表配置

#========================标准分片表配置（数据节点配置）
# spring.shardingsphere.rules.sharding.tables.<table-name>.actual-data-nodes=值
# 值由数据源名 + 表名组成，以小数点分隔。多个表以逗号分隔，支持 inline 表达式。
# <table-name>：逻辑表名
spring.shardingsphere.rules.sharding.tables.t_user.actual-data-nodes=server-user.t_user
spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=server-order0.t_order0,server-order0.t_order1,server-order1.t_order0,server-order1.t_order1Copy to clipboardErrorCopied
修改Order实体类的主键策略：

//@TableId(type = IdType.AUTO)//依赖数据库的主键自增策略
@TableId(type = IdType.ASSIGN_ID)//分布式idCopy to clipboardErrorCopied
测试：保留上面配置中的一个分片表节点分别进行测试，检查每个分片节点是否可用

/**
* 水平分片：插入数据测试
*/
@Test
public void testInsertOrder(){
Order order = new Order();
order.setOrderNo(\”ATGUIGU001\”);
order.setUserId(1L);
order.setAmount(new BigDecimal(100));
orderMapper.insert(order);
}Copy to clipboardErrorCopied

2.4、行表达式

优化上一步的分片表配置

行表达式 :: ShardingSphere

#========================标准分片表配置（数据节点配置）
# spring.shardingsphere.rules.sharding.tables.<table-name>.actual-data-nodes=值
# 值由数据源名 + 表名组成，以小数点分隔。多个表以逗号分隔，支持 inline 表达式。
# <table-name>：逻辑表名
spring.shardingsphere.rules.sharding.tables.t_user.actual-data-nodes=server-user.t_user
spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=server-order$->{0..1}.t_order$->{0..1}Copy to clipboardErrorCopied

2.5、分片算法配置

水平分库：

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

#————————分库策略
# 分片列名称
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-column=user_id
# 分片算法名称
spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-algorithm-name=alg_inline_userid
#————————分片算法配置
# 行表达式分片算法
# 分片算法类型
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_inline_userid.type=INLINE
# 分片算法属性配置
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_inline_userid.props.algorithm-expression=server-order$->{user_id % 2}
# 取模分片算法
# 分片算法类型
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_mod.type=MOD
# 分片算法属性配置
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_mod.props.sharding-count=2Copy to clipboardErrorCopied
为了方便测试，先设置只在 t_order0表上进行测试

xxx.actual-data-nodes=server-order$->{0..1}.t_order0Copy to clipboardErrorCopied
测试：可以分别测试行表达式分片算法和取模分片算法

/**
* 水平分片：分库插入数据测试
*/
@Test
public void testInsertOrderDatabaseStrategy(){
for (long i = 0; i < 4; i++) {
Order order = new Order();
order.setOrderNo(\”ATGUIGU001\”);
order.setUserId(i + 1);
order.setAmount(new BigDecimal(100));
orderMapper.insert(order);
}
}Copy to clipboardErrorCopied
水平分表：

分片规则：order表中order_no的哈希值为偶数时，数据插入对应服务器的t_order0表，order_no的哈希值为奇数时，数据插入对应服务器的t_order1表。因为order_no是字符串形式，因此不能直接取模。

#————————分表策略
# 分片列名称
spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-column=order_no
# 分片算法名称
spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-algorithm-name=alg_hash_mod
#————————分片算法配置
# 哈希取模分片算法
# 分片算法类型
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_hash_mod.type=HASH_MOD
# 分片算法属性配置
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_hash_mod.props.sharding-count=2
Copy to clipboardErrorCopied
测试前不要忘记将如下节点改回原来的状态

xxx.actual-data-nodes=server-order$->{0..1}.t_order$->{0..1}Copy to clipboardErrorCopied
测试：

/**
* 水平分片：分表插入数据测试
*/
@Test
public void testInsertOrderTableStrategy(){
for (long i = 1; i < 5; i++) {
Order order = new Order();
order.setOrderNo(\”ATGUIGU\” + i);
order.setUserId(1L);
order.setAmount(new BigDecimal(100));
orderMapper.insert(order);
}
for (long i = 5; i < 9; i++) {
Order order = new Order();
order.setOrderNo(\”ATGUIGU\” + i);
order.setUserId(2L);
order.setAmount(new BigDecimal(100));
orderMapper.insert(order);
}
}
/**
* 测试哈希取模
*/
@Test
public void testHash(){
//注意hash取模的结果是整个字符串hash后再取模，和数值后缀是奇数还是偶数无关
System.out.println(\”ATGUIGU001\”.hashCode() % 2);
System.out.println(\”ATGUIGU0011\”.hashCode() % 2);
}Copy to clipboardErrorCopied
查询测试：

/**
* 水平分片：查询所有记录
* 查询了两个数据源，每个数据源中使用UNION ALL连接两个表
*/
@Test
public void testShardingSelectAll(){
List<Order> orders = orderMapper.selectList(null);
orders.forEach(System.out::println);
}
/**
* 水平分片：根据user_id查询记录
* 查询了一个数据源，每个数据源中使用UNION ALL连接两个表
*/
@Test
public void testShardingSelectByUserId(){
QueryWrapper<Order> orderQueryWrapper = new QueryWrapper<>();
orderQueryWrapper.eq(\”user_id\”, 1L);
List<Order> orders = orderMapper.selectList(orderQueryWrapper);
orders.forEach(System.out::println);
}Copy to clipboardErrorCopied

2.6、分布式序列算法

雪花算法：

分布式主键 :: ShardingSphere

水平分片需要关注全局序列，因为不能简单的使用基于数据库的主键自增。

这里有两种方案：一种是基于MyBatisPlus的id策略；一种是ShardingSphere-JDBC的全局序列配置。

基于MyBatisPlus的id策略：将Order类的id设置成如下形式

@TableId(type = IdType.ASSIGN_ID)
private Long id;Copy to clipboardErrorCopied
基于ShardingSphere-JDBC的全局序列配置：和前面的MyBatisPlus的策略二选一

#————————分布式序列策略配置
# 分布式序列列名称
spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.column=id
# 分布式序列算法名称
spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.key-generator-name=alg_snowflake
# 分布式序列算法配置
# 分布式序列算法类型
spring.shardingsphere.rules.sharding.key-generators.alg_snowflake.type=SNOWFLAKE
# 分布式序列算法属性配置
#spring.shardingsphere.rules.sharding.key-generators.alg_snowflake.props.xxx=Copy to clipboardErrorCopied
此时，需要将实体类中的id策略修改成以下形式：

//当配置了shardingsphere-jdbc的分布式序列时，自动使用shardingsphere-jdbc的分布式序列
//当没有配置shardingsphere-jdbc的分布式序列时，自动依赖数据库的主键自增策略
@TableId(type = IdType.AUTO)Copy to clipboardErrorCopied

3、多表关联

3.1、创建关联表

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

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

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

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

3.2、创建实体类

package com.atguigu.shardingjdbcdemo.entity;
@TableName(\”t_order_item\”)
@Data
public class OrderItem {
//当配置了shardingsphere-jdbc的分布式序列时，自动使用shardingsphere-jdbc的分布式序列
@TableId(type = IdType.AUTO)
private Long id;
private String orderNo;
private Long userId;
private BigDecimal price;
private Integer count;
}Copy to clipboardErrorCopied

3.3、创建Mapper

package com.atguigu.shargingjdbcdemo.mapper;
@Mapper
public interface OrderItemMapper extends BaseMapper<OrderItem> {
}Copy to clipboardErrorCopied

3.4、配置关联表

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

#————————标准分片表配置（数据节点配置）
spring.shardingsphere.rules.sharding.tables.t_order_item.actual-data-nodes=server-order$->{0..1}.t_order_item$->{0..1}
#————————分库策略
# 分片列名称
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_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_order_item.key-generate-strategy.column=id
# 分布式序列算法名称
spring.shardingsphere.rules.sharding.tables.t_order_item.key-generate-strategy.key-generator-name=alg_snowflakeCopy to clipboardErrorCopied

3.5、测试插入数据

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

/**
* 测试关联表插入
*/
@Test
public void testInsertOrderAndOrderItem(){
for (long i = 1; i < 3; i++) {
Order order = new Order();
order.setOrderNo(\”ATGUIGU\” + i);
order.setUserId(1L);
orderMapper.insert(order);
for (long j = 1; j < 3; j++) {
OrderItem orderItem = new OrderItem();
orderItem.setOrderNo(\”ATGUIGU\” + i);
orderItem.setUserId(1L);
orderItem.setPrice(new BigDecimal(10));
orderItem.setCount(2);
orderItemMapper.insert(orderItem);
}
}
for (long i = 5; i < 7; i++) {
Order order = new Order();
order.setOrderNo(\”ATGUIGU\” + i);
order.setUserId(2L);
orderMapper.insert(order);
for (long j = 1; j < 3; j++) {
OrderItem orderItem = new OrderItem();
orderItem.setOrderNo(\”ATGUIGU\” + i);
orderItem.setUserId(2L);
orderItem.setPrice(new BigDecimal(1));
orderItem.setCount(3);
orderItemMapper.insert(orderItem);
}
}
}Copy to clipboardErrorCopied

4、绑定表

需求：查询每个订单的订单号和总订单金额

4.1、创建VO对象

package com.atguigu.shardingjdbcdemo.entity;
@Data
public class OrderVo {
private String orderNo;
private BigDecimal amount;
}Copy to clipboardErrorCopied

4.2、添加Mapper方法

package com.atguigu.shardingjdbcdemo.mapper;
@Mapper
public interface OrderMapper extends BaseMapper<Order> {
@Select({\”SELECT o.order_no, SUM(i.price * i.count) AS amount\”,
\”FROM t_order o JOIN t_order_item i ON o.order_no = i.order_no\”,
\”GROUP BY o.order_no\”})
List<OrderVo> getOrderAmount();
}Copy to clipboardErrorCopied

4.3、测试关联查询

/**
* 测试关联表查询
*/
@Test
public void testGetOrderAmount(){
List<OrderVo> orderAmountList = orderMapper.getOrderAmount();
orderAmountList.forEach(System.out::println);
}Copy to clipboardErrorCopied

4.4、配置绑定表

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

#————————绑定表
spring.shardingsphere.rules.sharding.binding-tables[0]=t_order,t_order_itemCopy to clipboardErrorCopied
配置完绑定表后再次进行关联查询的测试：

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

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

5、广播表

4.1、什么是广播表

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

广播具有以下特性：

（1）插入、更新操作会实时在所有节点上执行，保持各个分片的数据一致性

（2）查询操作，只从一个节点获取

（3）可以跟任何一个表进行 JOIN 操作

4.2、创建广播表

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

CREATE TABLE t_dict(
id BIGINT,
dict_type VARCHAR(200),
PRIMARY KEY(id)
);Copy to clipboardErrorCopied

4.3、程序实现

4.3.1、创建实体类

package com.atguigu.shardingjdbcdemo.entity;
@TableName(\”t_dict\”)
@Data
public class Dict {
//可以使用MyBatisPlus的雪花算法
@TableId(type = IdType.ASSIGN_ID)
private Long id;
private String dictType;
}Copy to clipboardErrorCopied

4.3.2、创建Mapper

package com.atguigu.shardingjdbcdemo.mapper;
@Mapper
public interface DictMapper extends BaseMapper<Dict> {
}Copy to clipboardErrorCopied

4.3.3、配置广播表

#数据节点可不配置，默认情况下，向所有数据源广播
spring.shardingsphere.rules.sharding.tables.t_dict.actual-data-nodes=server-user.t_dict,server-order$->{0..1}.t_dict
# 广播表
spring.shardingsphere.rules.sharding.broadcast-tables[0]=t_dictCopy to clipboardErrorCopied

4.4、测试广播表

@Autowired
private DictMapper dictMapper;
/**
* 广播表：每个服务器中的t_dict同时添加了新数据
*/
@Test
public void testBroadcast(){
Dict dict = new Dict();
dict.setDictType(\”type1\”);
dictMapper.insert(dict);
}
/**
* 查询操作，只从一个节点获取数据
* 随机负载均衡规则
*/
@Test
public void testSelectBroadcast(){
List<Dict> dicts = dictMapper.selectList(null);
dicts.forEach(System.out::println);
}Copy to clipboardErrorCopied

第07章 启动ShardingSphere-Proxy

1、获取

目前 ShardingSphere-Proxy 提供了 3 种获取方式：

二进制发布包DockerHelm

2、使用二进制发布包安装

二进制包既可以Linux系统运行，又可以在windows系统运行

step1：解压二进制包

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

windows：使用解压软件解压文件

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

tar -zxvf apache-shardingsphere-5.1.1-shardingsphere-proxy-bin.tar.gzCopy to clipboardErrorCopied
step2：MySQL驱动

mysql-connector-java-8.0.22.jar

将MySQl驱动放至解压目录中的ext-lib目录

spte3：修改配置conf/server.yaml

rules:
– !AUTHORITY
users:
– root@%:root
provider:
type: ALL_PRIVILEGES_PERMITTED
props:
sql-show: trueCopy to clipboardErrorCopied
spte4：启动ShardingSphere-Proxy

Linux 操作系统请运行 bin/start.sh

Windows 操作系统请运行 bin/start.bat

指定端口号和配置文件目录：bin/start.bat ${proxy_port} ${proxy_conf_directory}

step5：远程连接ShardingSphere-Proxy

远程访问

mysql -h192.168.100.1 -P3307 -uroot -pCopy to clipboardErrorCopied
step6：访问测试

show databases;Copy to clipboardErrorCopied

3、使用Docker安装

step1：启动Docker容器

docker run -d \\
-v /atguigu/server/proxy-a/conf:/opt/shardingsphere-proxy/conf \\
-v /atguigu/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.1Copy to clipboardErrorCopied
step2：上传MySQL驱动

将MySQl驱动上传至/atguigu/server/proxy-a/ext-lib目录

spte3：修改配置server.yaml

rules:
– !AUTHORITY
users:
– root@%:root
provider:
type: ALL_PRIVILEGES_PERMITTED
props:
sql-show: trueCopy to clipboardErrorCopied
将配置文件上传至/atguigu/server/proxy-a/conf目录

spte4：重启容器

docker restart server-proxy-aCopy to clipboardErrorCopied
step5：远程连接ShardingSphere-Proxy

ShardingSphere-Proxy容器中默认情况下没有mysql命令行客户端的安装，因此需要远程访问

mysql -h192.168.100.201 -P3321 -uroot -pCopy to clipboardErrorCopied
step6：访问测试

show databases;Copy to clipboardErrorCopied

常见问题：docker容器无法远程连接

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

原因：容器可分配内存不足

查看办法：进入容器后查看ShardingSphere-Proxy的日志，如有有cannot allocate memory，则说明容器内存不足

docker exec -it server-proxy-a env LANG=C.UTF-8 /bin/bash
cd /opt/shardingsphere-proxy/logs
tail stdout.log Copy to clipboardErrorCopied

解决方案：创建容器的时候使用JVM参数

-e ES_JAVA_OPTS=\”-Xmx256m -Xms256m -Xmn128m\”Copy to clipboardErrorCopied

第08章 ShardingSphere-Proxy读写分离

1、修改配置文件

修改配置config-readwrite-splitting.yaml

schemaName: readwrite_splitting_db
dataSources:
write_ds:
url: jdbc:mysql://192.168.100.201:3306/db_user?serverTimezone=UTC&useSSL=false
username: root
password: 123456
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
read_ds_0:
url: jdbc:mysql://192.168.100.201:3307/db_user?serverTimezone=UTC&useSSL=false
username: root
password: 123456
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
read_ds_1:
url: jdbc:mysql://192.168.100.201:3308/db_user?serverTimezone=UTC&useSSL=false
username: root
password: 123456
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
rules:
– !READWRITE_SPLITTING
dataSources:
readwrite_ds:
type: Static
props:
write-data-source-name: write_ds
read-data-source-names: read_ds_0,read_ds_1Copy to clipboardErrorCopied
将配置文件上传至/atguigu/server/proxy-a/conf目录

重启容器

docker restart server-proxy-aCopy to clipboardErrorCopied

2、实时查看日志

可以通过这种方式查看服务器中输出的SQL语句

docker exec -it server-proxy-a env LANG=C.UTF-8 /bin/bash
tail -f /opt/shardingsphere-proxy/logs/stdout.log Copy to clipboardErrorCopied

3、远程访问测试

mysql> show databases;
mysql> use readwrite_splitting_db;
mysql> show tables;
mysql> select * from t_user;
mysql> select * from t_user;
mysql> insert into t_user(uname) values(\’wang5\’);Copy to clipboardErrorCopied

4、应用程序访问Proxy

4.1、创建项目

项目类型：Spring Initializr

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

项目名：sharding-proxy-demo

SpringBoot版本：2.3.7.RELEASE

4.2、添加依赖

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.3.1</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>Copy to clipboardErrorCopied

4.3、创建实体类

package com.atguigu.shardingproxydemo.entity;
@TableName(\”t_user\”)
@Data
public class User {
@TableId(type = IdType.AUTO)
private Long id;
private String uname;
}
Copy to clipboardErrorCopied

4.4、创建Mapper

package com.atguigu.shardingproxydemo.mapper;
@Mapper
public interface UserMapper extends BaseMapper<User> {
}Copy to clipboardErrorCopied

4.5、配置数据源

# 应用名称
spring.application.name=sharding-proxy-demo
# 开发环境设置
spring.profiles.active=dev
#mysql数据库连接（proxy）
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.100.201:3321/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.StdOutImplCopy to clipboardErrorCopied

4.6、测试

package com.atguigu.shardingproxydemo;
@SpringBootTest
class ShardingProxyDemoApplicationTests {
@Autowired
private UserMapper userMapper;
/**
* 读数据测试
*/
@Test
public void testSelectAll(){
List<User> users = userMapper.selectList(null);
users.forEach(System.out::println);
}
}Copy to clipboardErrorCopied

第09章 ShardingSphere-Proxy垂直分片

1、修改配置文件

修改配置config-sharding.yaml

schemaName: sharding_db
dataSources:
ds_0:
url: jdbc:mysql://192.168.100.201:3301/db_user?serverTimezone=UTC&useSSL=false
username: root
password: 123456
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
ds_1:
url: jdbc:mysql://192.168.100.201:3302/db_order?serverTimezone=UTC&useSSL=false
username: root
password: 123456
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
rules:
– !SHARDING
tables:
t_user:
actualDataNodes: ds_0.t_user
t_order:
actualDataNodes: ds_1.t_orderCopy to clipboardErrorCopied

2、实时查看日志

可以通过这种方式查看服务器中输出的SQL语句

docker exec -it server-proxy-a env LANG=C.UTF-8 /bin/bash
tail -f /opt/shardingsphere-proxy/logs/stdout.log Copy to clipboardErrorCopied

3、远程访问测试

mysql> show databases;
mysql> use sharding_db;
mysql> show tables;
mysql> select * from t_order;
mysql> select * from t_user;Copy to clipboardErrorCopied

第10章 ShardingSphere-Proxy水平分片

1、修改配置文件

修改配置config-sharding.yaml

schemaName: sharding_db
dataSources:
ds_user:
url: jdbc:mysql://192.168.100.201:3301/db_user?serverTimezone=UTC&useSSL=false
username: root
password: 123456
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
ds_order0:
url: jdbc:mysql://192.168.100.201:3310/db_order?serverTimezone=UTC&useSSL=false
username: root
password: 123456
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
ds_order1:
url: jdbc:mysql://192.168.100.201:3311/db_order?serverTimezone=UTC&useSSL=false
username: root
password: 123456
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
rules:
– !SHARDING
tables:
t_user:
actualDataNodes: ds_user.t_user
t_order:
actualDataNodes: ds_order${0..1}.t_order${0..1}
databaseStrategy:
standard:
shardingColumn: user_id
shardingAlgorithmName: alg_mod
tableStrategy:
standard:
shardingColumn: order_no
shardingAlgorithmName: alg_hash_mod
keyGenerateStrategy:
column: id
keyGeneratorName: snowflake
t_order_item:
actualDataNodes: ds_order${0..1}.t_order_item${0..1}
databaseStrategy:
standard:
shardingColumn: user_id
shardingAlgorithmName: alg_mod
tableStrategy:
standard:
shardingColumn: order_no
shardingAlgorithmName: alg_hash_mod
keyGenerateStrategy:
column: id
keyGeneratorName: snowflake
bindingTables:
– t_order,t_order_item
broadcastTables:
– t_dict
shardingAlgorithms:
alg_inline_userid:
type: INLINE
props:
algorithm-expression: server-order$->{user_id % 2}
alg_mod:
type: MOD
props:
sharding-count: 2
alg_hash_mod:
type: HASH_MOD
props:
sharding-count: 2

keyGenerators:
snowflake:
type: SNOWFLAKE
Copy to clipboardErrorCopied

2、实时查看日志

可以通过这种方式查看服务器中输出的SQL语句

docker exec -it server-proxy-a env LANG=C.UTF-8 /bin/bash
tail -f /opt/shardingsphere-proxy/logs/stdout.log Copy to clipboardErrorCopied

3、远程访问测试

mysql> show databases;
mysql> use sharding_db;
mysql> show tables;
mysql> select * from t_order; –测试水平分片
mysql> select * from t_dict; –测试广播表
#以上关于ShardingSphere5的相关内容来源网络仅供参考，相关信息请以官方公告为准！