JavaEE技术之MySql高级-ShardingSphere[旧版本,备用]（SpringBoot版本：2.3.7.RELEASE）

小丁学Java

于 2024-05-08 20:17:47 发布

阅读量784

点赞数 28

分类专栏： MySQL高级篇文章标签： ShardingSphere

本文链接：https://blog.csdn.net/m0_65152767/article/details/138584882

版权

MySQL高级篇专栏收录该内容

46 篇文章 0 订阅

订阅专栏

文章目录

1. ShardingSphere简介
- 1.1 ShardingSphere-JDBC
- 1.2 ShardingSphere-Proxy
2. ShardingSphere-JDBC读写分离
3. ShardingSphere-JDBC垂直分片
4. ShardingSphere-JDBC水平分片
5. ShardingSphere-JDBC绑定表
6. ShardingSphere-JDBC广播表

1. ShardingSphere简介

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

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

Apache ShardingSphere 由 JDBC、Proxy 和 Sidecar（规划中）这 3 款既能够独立部署，又支持混合部署配合使用的产品组成。

1.1 ShardingSphere-JDBC

程序代码封装

定位为轻量级 Java 框架，在 Java 的 JDBC 层提供的额外服务。它使用客户端直连数据库，以 jar 包形式提供服务，无需额外部署和依赖，可理解为增强版的 JDBC 驱动，完全兼容 JDBC 和各种 ORM 框架。

在这里插入图片描述

1.2 ShardingSphere-Proxy

中间件封装

定位为透明化的数据库代理端，提供封装了数据库二进制协议的服务端版本，用于完成对异构语言的支持。目前提供 MySQL 和 PostgreSQL版本，它可以使用任何兼容 MySQL/PostgreSQL 协议的访问客户端（如：MySQL Command Client, MySQL Workbench, Navicat 等）操作数据，对 DBA 更加友好。

在这里插入图片描述

2. ShardingSphere-JDBC读写分离

基于之前搭建的mysql主从读写分离使用ShardingSphere-JDBC实现读写分离

2.1 创建SpringBoot程序

2.1.1 创建springboot项目

项目名：sharding-jdbc-demo

SpringBoot版本：2.3.7.RELEASE

2.1.2 添加依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
        <version>5.1.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.25</version>
        <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>

2.1.3 创建实体类

package com.atguigu.shardingjdbcdemo.entity;

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

2.1.4 创建Mapper

package com.atguigu.shardingjdbcdemo.mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

2.1.5 配置读写分离

application.properties：

# 应用名称
spring.application.name=sharding-jdbc-demo
# 环境设置
spring.profiles.active=dev
# 配置真实数据源
spring.shardingsphere.datasource.names=master,slave1

# 配置第 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.url=jdbc:mysql://192.168.100.201:3316/mydb
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.url=jdbc:mysql://192.168.100.201:3326/mydb
spring.shardingsphere.datasource.slave1.username=root
spring.shardingsphere.datasource.slave1.password=123456


# 读写分离配置
# 读写分离类型，如: Static，Dynamic
# 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=master,slave1
# 负载均衡算法名称
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.load-balancer-name=alg_round
# 负载均衡算法配置
# 负载均衡算法类型：ROUND_ROBIN、RANDOM、WEIGHT
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_round.type=ROUND_ROBIN
# 负载均衡算法属性配置：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=1
# 打印SQL
spring.shardingsphere.props.sql-show=true

2.2 测试读写分离

package com.atguigu.shardingjdbcdemo;

@SpringBootTest
class ReadwriteTest {

    @Resource
    private UserMapper userMapper;

    /**
     * 写入数据
     */
    @Test
    public void testInsert(){
        User user = new User();
        user.setUname("taotao");
        userMapper.insert(user);
    }

    /**
     * 读数据:测试负载均衡
     */
    @Test
    public void testSelectAll(){
        List<User> users1 = userMapper.selectList(null);
        List<User> users2 = userMapper.selectList(null);//执行第二次测试负载均衡
        users1.forEach(System.out::println);
        users2.forEach(System.out::println);
    }

}

3. ShardingSphere-JDBC垂直分片

什么是数据分片？

简单来说，就是指通过某种特定的条件，将我们存放在同一个数据库中的数据分散存放到多个数据库（主机）上面，以达到分散单台设备负载的效果。

数据的切分（Sharding）根据其切分规则的类型，可以分为两种切分模式：

垂直（纵向）切分：是按照不同的表（或者 Schema）来切分到不同的数据库（主机）之上
水平（横向）切分：是根据表中的数据的逻辑关系，将同一个表中的数据按照某种条件拆分到多台数据库（主机）上面。

注意：分库分表必须是干净的库和表（不能有数据）

分片原则：

能不切分尽量不要切分。数据量不是很大的库或者表，尽量不要分片。
尽量按照功能模块分库，避免跨库join。

项目中可以使用ShardingSphere-JDBC加载不同库中的表进行操作

3.1 准备服务器

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

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

3.1.1 创建server-user容器

step1：创建容器：

docker run -d \
-p 3326:3306 \
-v /atguigu/mysql/user/conf:/etc/mysql/conf.d \
-v /atguigu/server/user/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name atguigu-master-user \
mysql:8.0.29

step2：登录MySQL服务器：

#进入容器：
docker exec -it atguigu-master-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)
);

3.1.2 创建server-order容器

step1：创建容器：

docker run -d \
-p 3318:3306 \
-v mysql-order-conf:/etc/mysql/conf.d \
-v mysql-order-data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-order \
mysql:8.0.29

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,
  amount DECIMAL(10,2),
  PRIMARY KEY(id) 
);

3.2 程序实现

3.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;
}

3.2.2 创建Mapper

package com.atguigu.shardingjdbcdemo.mapper;

@Mapper
public interface OrderMapper extends BaseMapper<Order> {
}

3.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.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.url=jdbc:mysql://192.168.100.201:3302/db_order
spring.shardingsphere.datasource.server-order.username=root
spring.shardingsphere.datasource.server-order.password=123456

# 标准分片表配置（数据节点）
# <table-name>逻辑表名：匹配 数据源名.真实表
#spring.shardingsphere.rules.sharding.tables.<table-name>.actual-data-nodes= # 由数据源名 + 表名组成，以小数点分隔。
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

3.3 测试垂直分片

package com.atguigu.shardingjdbcdemo;

@SpringBootTest
public class ShardingTest {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private OrderMapper orderMapper;

    /**
     * 垂直分片：
     * user数据自动写入server-user服务器的的t_user表
     * order数据自动写入server-order服务器的的t_order表
     */
    @Test
    public void testInsert1(){
        User user = new User();
        user.setUname("helen");
        userMapper.insert(user);

        Order order = new Order();
        order.setOrderNo("ATGUIGU");
        order.setAmount(new BigDecimal(100));
        order.setUserId(user.getId());
        orderMapper.insert(order);
    }
}

常见错误

在这里插入图片描述

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

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

ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';

4. ShardingSphere-JDBC水平分片

项目中可以使用ShardingSphere-JDBC将数据存到不同库的表中

4.1 准备服务器

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

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

4.1.1 创建server-order0容器

step1：创建容器：

docker run -d \
-p 3319:3306 \
-v mysql-order1-conf:/etc/mysql/conf.d \
-v mysql-order1-data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
--name server-order1 \
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(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) 
);

4.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.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需要在业务层实现，不能依赖数据库的主键自增

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) 
);

4.2 程序实现

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

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

4.2.1 修改实体类

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

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

4.2.2 配置全局序列

基于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

# 分布式序列算法配置：<key-generate-algorithm-name> 分布式序列算法名称
spring.shardingsphere.rules.sharding.key-generators.alg_snowflake.type=SNOWFLAKE

4.2.3 配置水平分片

分片规则：

order表中id为偶数时，数据插入对应服务器的t_order0，id为奇数时，数据插入对应服务器的t_order1
order表中user_id为偶数时，数据插入server-order0，user_id为奇数时，数据插入server-order1

这样分片的好处是，同一个用户的订单数据，一定会被插入到同一台服务器上，查询一个用户的订单时效率较高

# 应用名称
spring.application.name=sharding-jdbc-demo
# 环境设置
spring.profiles.active=dev

#=======================================数据源配置
# 配置真实数据源
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.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-order0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-order0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-order0.url=jdbc:mysql://192.168.100.201:3310/db_order
spring.shardingsphere.datasource.server-order0.username=root
spring.shardingsphere.datasource.server-order0.password=123456

# 配置第 3 个数据源
spring.shardingsphere.datasource.server-order1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.server-order1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.server-order1.url=jdbc:mysql://192.168.100.201:3311/db_order
spring.shardingsphere.datasource.server-order1.username=root
spring.shardingsphere.datasource.server-order1.password=123456


#=======================================数据节点配置
# 标准分片表配置（数据节点）
# <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}

#=======================================t_order表分片配置
#水平分片到同一数据库
# 分片列名称
spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-column=id
# 分片算法名称
spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-algorithm-name=alg_mod

#水平分片到不同数据库
# 分片列名称
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_mod


#=======================================分片策略配置
# 分片算法类型：<sharding-algorithm-name> 分片算法名称
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_mod.type=MOD
# 分片算法属性配置
spring.shardingsphere.rules.sharding.sharding-algorithms.alg_mod.props.sharding-count=2


#=======================================分布式序列策略配置
# 分布式序列策略配置：这里MyBatisPlus的分布式id和此处的设置二选一
# 分布式序列列名称
#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
# 分布式序列算法配置：<key-generate-algorithm-name> 分布式序列算法名称
#spring.shardingsphere.rules.sharding.key-generators.alg_snowflake.type=SNOWFLAKE

# 打印SQL
spring.shardingsphere.props.sql-show=true

4.3 测试水平分片和全局序列

/**
     * 水平分片：插入数据
     */
@Test
public void testInsert2(){

    //创建10个用户
    for (int i = 0; i < 10; i++) {
        User user = new User();
        user.setUname("用户" + i);
        userMapper.insert(user);

        //为每个用户生成1-5个订单
        int count = new Random().nextInt(5) + 1;
        System.out.println(" count = " + count);
        for (int j = 0; j < count; j++) {
            Order order = new Order();
            order.setOrderNo("ATGUIGU"+j);
            order.setAmount(new BigDecimal(100));
            order.setUserId(user.getId());
            orderMapper.insert(order);
        }

    }
}

/**
     * 水平分片：读所有订单数据
     */
@Test
public void testSelectAll(){
    List<Order> orders = orderMapper.selectList(null);
    orders.forEach(System.out::println);
}


/**
     * 水平分片：读某个用户的订单数据
     * 可以发现，统一用户的订单来源于同一数据库
     */
@Test
public void testSelectOrdersByUserId(){
    QueryWrapper<Order> orderQueryWrapper = new QueryWrapper<>();
    orderQueryWrapper.eq("user_id", 483L);
    List<Order> orders = orderMapper.selectList(orderQueryWrapper);
    orders.forEach(System.out::println);
}

5. ShardingSphere-JDBC绑定表

5.1 什么是绑定表

指分片规则一致的一组分片表。使用绑定表进行多表关联查询时，必须使用分片键进行关联，否则会出现笛卡尔积关联或跨库关联，从而影响查询效率。例如：t_order 表和 t_order_item 表，均按照 order_id 分片，并且使用 order_id 进行关联，则此两张表互为绑定表关系。

例如：查询订单和它的订单项

SELECT * FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);

在不配置绑定表关系时，假设分片键 order_id 将数值 10 路由至第 0 片，将数值 11 路由至第 1 片，那么路由后的 SQL 应该为 4 条，对于一台服务器上的查询来说，它们呈现为笛卡尔积：

SELECT * FROM t_order0 o JOIN t_order_item0 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);

SELECT * FROM t_order0 o JOIN t_order_item1 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);

SELECT * FROM t_order1 o JOIN t_order_item0 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);

SELECT * FROM t_order1 o JOIN t_order_item1 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);

在配置绑定表关系，并且使用 order_id 进行关联后，路由的 SQL 应该为 2 条：

SELECT * FROM t_order0 o JOIN t_order_item0 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);

SELECT * FROM t_order1 o JOIN t_order_item1 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);

5.2 创建绑定表

在server-order0、service-order1服务器中分别创建两张表t_order_item0、t_order_item1表

因为我们需要将t_order和t_order_item作为一组绑定表，因此这两个表的分片策略应该一致，

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

CREATE TABLE t_order_item0(
    id BIGINT AUTO_INCREMENT,
    detail VARCHAR(200),
    order_id BIGINT,
    user_id BIGINT,
    PRIMARY KEY(id)
);

CREATE TABLE t_order_item1(
    id BIGINT AUTO_INCREMENT,
    detail VARCHAR(200),
    order_id BIGINT,
    user_id BIGINT,
    PRIMARY KEY(id)
);

5.3 新增代码

5.3.1 创建实体类

OrderItem

package com.atguigu.shardingjdbcdemo.entity;

@TableName("t_order_item")
@Data
public class OrderItem {
    @TableId(type = IdType.ASSIGN_ID)
    private Long id;
    private String detail;
    private Long orderId;
    private Long userId;
}

OrderItemVo

package com.atguigu.shardingjdbcdemo.entity;

@Data
public class OrderItemVo {

    private Long id;
    private String detail;
    private Long orderId;
    private String orderNo;
}

5.3.2 创建Mapper

package com.atguigu.shardingjdbcdemo.mapper;

@Mapper
public interface OrderItemMapper extends BaseMapper<OrderItem> {

    @Select({"SELECT i.id, i.detail, i.order_id, o.order_no",
            "FROM t_order o JOIN t_order_item i ON o.id=i.order_id",
            "WHERE o.id = #{orderId}"})
    List<OrderItemVo> selectDetailByOrderId(Long orderId);
}

5.3.3 配置绑定表

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

#=======================================数据节点配置
spring.shardingsphere.rules.sharding.tables.t_order_item.actual-data-nodes=server-order$->{0..1}.t_order_item$->{0..1}


#=======================================t_order_item表分片配置
#水平分片到同一数据库
# 分片列名称
spring.shardingsphere.rules.sharding.tables.t_order_item.table-strategy.standard.sharding-column=order_id
# 分片算法名称
spring.shardingsphere.rules.sharding.tables.t_order_item.table-strategy.standard.sharding-algorithm-name=alg_mod

#水平分片到不同数据库
# 分片列名称
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


#=======================================绑定表t_order,t_order_item
# 绑定表规则列表
spring.shardingsphere.rules.sharding.binding-tables[0]=t_order,t_order_item

5.4 测试绑定表

@Autowired
private OrderItemMapper orderItemMapper;

/**
     * 绑定表：插入数据
     * 可以发现统一用户的订单详情数据被插入在和订单相同的数据库中，避免跨库关联
     */
@Test
public void testInsert3(){

    Long[] orderIdList = {
        1556695688627220482L,//测试sever-order0 t_order0订单
        1556695688681746433L,//测试sever-order0 t_order1订单
        1556695688719495170L,//测试sever-order1 t_order0订单
        1556695688857907201L//测试sever-order1 t_order0订单
    };

    for (Long orderId : orderIdList) {
        Order order = orderMapper.selectById(orderId);
        OrderItem orderItem = new OrderItem();
        orderItem.setOrderId(orderId);
        orderItem.setUserId(order.getUserId());
        orderItem.setDetail("订单详情...");
        orderItemMapper.insert(orderItem);
    }
}


/**
     * 关联查询：
     * 测试后主要查看控制台的sql语句。
     * 比较配置绑定表binding-tables[0]的前后，控制台sql语句发生的变化
     * 结论：配置了绑定表后，去除了笛卡尔即查询，查询效率提升
     */
@Test
public void testSelectOrderItemVo(){

    List<OrderItemVo> orderItemVoList = orderItemMapper.selectDetailByOrderId(1556695688857907201L);
    orderItemVoList.forEach(System.out::println);
}

6. ShardingSphere-JDBC广播表

6.1 什么是广播表

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

广播具有以下特性：

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

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

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

6.2 创建广播表

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

CREATE TABLE t_dict(
    id BIGINT,
    order_type VARCHAR(200),
    PRIMARY KEY(id)
);

6.3 程序实现

6.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 orderType;
}

6.3.2 创建Mapper

package com.atguigu.shardingjdbcdemo.mapper;

@Mapper
public interface DictMapper extends BaseMapper<Dict> {
}

6.3.3 配置广播表

# 广播表
spring.shardingsphere.rules.sharding.broadcast-tables[0]=t_dict

6.4 测试广播表

@Autowired
private DictMapper dictMapper;

/**
     * 广播表：每个服务器中的t_dict同时添加了新数据
     */
@Test
public void testBroadcast(){

    Dict dict = new Dict();
    dict.setOrderType("type1");
    dictMapper.insert(dict);
}

操作

6.2 创建广播表

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

CREATE TABLE t_dict(
    id BIGINT,
    order_type VARCHAR(200),
    PRIMARY KEY(id)
);

6.3 程序实现

6.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 orderType;
}

6.3.2 创建Mapper

package com.atguigu.shardingjdbcdemo.mapper;

@Mapper
public interface DictMapper extends BaseMapper<Dict> {
}

6.3.3 配置广播表

# 广播表
spring.shardingsphere.rules.sharding.broadcast-tables[0]=t_dict

6.4 测试广播表

@Autowired
private DictMapper dictMapper;

/**
     * 广播表：每个服务器中的t_dict同时添加了新数据
     */
@Test
public void testBroadcast(){

    Dict dict = new Dict();
    dict.setOrderType("type1");
    dictMapper.insert(dict);
}

小丁学Java

关注

28
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
JavaEE技术之MySql高级-ShardingSphere[旧版本,备用]（SpringBoot版本：2.3.7.RELEASE）

官网：https://shardingsphere.apache.org/index_zh.html文档：https://shardingsphere.apache.org/document/5.1.1/cn/overview/Apache ShardingSphere 由 JDBC、Proxy 和 Sidecar（规划中）这 3 款既能够独立部署，又支持混合部署配合使用的产品组成。指分片规则一致的一组分片表。
复制链接

扫一扫

专栏目录