1、ShardingSphere概述

1.1、ShardingSphere概述

Apache ShardingSphere 是一套开源的分布式数据库解决方案组成的生态圈，它由 JDBC、Proxy 和 Sidecar（规划中）这 3 款既能够独立部署，又支持混合部署配合使用的产品组成。 它们均提供标准化的数据水平扩展、分布式事务和分布式治理等功能，可适用于如 Java 同构、异构语言、云原生等各种多样化的应用场景。
Apache ShardingSphere 旨在充分合理地在分布式的场景下利用关系型数据库的计算和存储能力，而并非实现一个全新的关系型数据库。 关系型数据库当今依然占有巨大市场份额，是企业核心系统的基石，未来也难于撼动，我们更加注重在原有基础上提供增量，而非颠覆。
Apache ShardingSphere 5.x 版本开始致力于可插拔架构，项目的功能组件能够灵活的以可插拔的方式进行扩展。 目前，数据分片、读写分离、数据加密、影子库压测等功能，以及 MySQL、PostgreSQL、SQLServer、Oracle 等 SQL 与协议的支持，均通过插件的方式织入项目。 开发者能够像使用积木一样定制属于自己的独特系统。Apache ShardingSphere 目前已提供数十个 SPI 作为系统的扩展点，仍在不断增加中。ShardingSphere 已于2020年4月16日成为 Apache 软件基金会的顶级项目。

主要来说就以下三点：

1. 一套开源的分布式数据库中间件解决方案
2. 有三个产品：主要使用到的是Sharding-JDBC 和 Sharding-Proxy
3. 定位为关系型数据库中间件，合理在分布式环境下使用关系型数据库操作

1.2、ShardingSphere-JDBC概述

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

• 适用于任何基于 JDBC 的 ORM 框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template 或直接使用 JDBC。
• 支持任何第三方的数据库连接池，如：DBCP, C3P0, BoneCP, Druid, HikariCP 等。
• 支持任意实现 JDBC 规范的数据库，目前支持 MySQL，Oracle，SQLServer，PostgreSQL 以及任何遵循 SQL92 标准的数据库。

1.3、ShardingSphere-Proxy概述

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

• 向应用程序完全透明，可直接当做 MySQL/PostgreSQL 使用。
• 适用于任何兼容 MySQL/PostgreSQL 协议的的客户端。

1.4、分库分表概述

存在问题：数据库数据量不可控的，随着时间和业务发展，造成表里面数据越来越多，如果再去对数据库表 curd 操作时候，造成性能问题。

解决方案：

• 方案 1：从硬件上
• 方案 2：分库分表

分库分表有两种方式：垂直切分和水平切分

1. 垂直切分：垂直分表和垂直分库
   1. 垂直分表：操作数据库中某张表，把这张表中一部分字段数据存到一张新表里面，再把这张表另一
      部分字段数据存到另外一张表里面
   2. 垂直分库：把单一数据库按照业务进行划分，专库专表
2. 水平切分：水平分表和水平分库
   1. 可以将数据的水平切分理解为是按照数据行的切分，就是将表中的某些行切分到一个数据库，而另外的某些行又切分到其他的数据库中，这也就是对应的分表和分库

1.5、分库分表应用和存在的问题

应用

• 在数据库设计时候考虑垂直分库和垂直分表
• 随着数据库数据量增加，不要马上考虑做水平切分，首先考虑缓存处理，读写分离，使用索引等等方式，如果这些方式不能根本解决问题了，再考虑做水平分库和水平分表

分库分表问题

• 跨节点连接查询问题（分页、排序）
• 多数据源管理问题

2、ShardingSphere-JDBC概述

ShardingSphere–JDBC操作流程，而使用他它的主要目的是为了帮我们简化对分库分表之后数据相关操作

项目构建：使用springboot进行集成ShardingSphere-JDBC，使用idea进行初始化一个springboot的项目，之后我们导入关于数据库和sharding-JDBC的相关依赖。关于Springboot可参考：SpringBoot 详解

		<!-- 连接池依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.20</version>
        </dependency>
        <!-- 数据库依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- sharding-jdbc依赖 -->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.0.0-RC1</version>
        </dependency>
        <!-- mybatis-plus依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
        <!-- lombok依赖 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

2.1、水平分表

约定规则：如果添加用户id是奇数把数据添加user1，如果偶数添加到user2。首先我们创建对应的两张表

create table user1(
	id BIGINT(20) PRIMARY KEY,
	name VARCHAR(50) NOT NULL,
	user_id BIGINT(20) NOT NULL
)

create table user2(
	id BIGINT(20) PRIMARY KEY,
	name VARCHAR(50) NOT NULL,
	user_id BIGINT(20) NOT NULL
)

先加上实体类、以及mapper直接继承BaseMapper进行后续操作，在启动类上加入注解 @MapperScan(mapper文件目录) 用来扫描mapper。而对于mybatis-plus可参考文章：Mybatis-Plus 详解

// 实体类
@Data
public class User {
    private Long id;
    private String name;
    private int userId;
}

// mapper
@Repository
public interface UserMapper extends BaseMapper<User> {
}

// 启动类
@MapperScan("com.lzq.mapper")

而后需要对ShardingJdbc分表进行相关的配置：官网配置地址

# 配置真实数据源（给数据源取一个名字）
spring.shardingsphere.datasource.names=ds

# 配置第 1 个数据源（对应自己的数据库）
spring.shardingsphere.datasource.ds.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds.url=jdbc:mysql://localhost:3306/springboot?serverTimezone=GMT%2B8
spring.shardingsphere.datasource.ds.username=root
spring.shardingsphere.datasource.ds.password=root

# 分表规则 表名+1，2
spring.shardingsphere.sharding.tables.user.actual-data-nodes=ds.user$->{1..2}

# 指定主键生成策略 主键id通过雪花算法生成
spring.shardingsphere.sharding.tables.user.key-generator.column=id
spring.shardingsphere.sharding.tables.user.key-generator.type=SNOWFLAKE

# 指定分片策略 根据生成的id进行分表
spring.shardingsphere.sharding.tables.user.table-strategy.inline.sharding-column=id
spring.shardingsphere.sharding.tables.user.table-strategy.inline.algorithm-expression=user$->{id % 2 +1}

# 打印执行的sql语句日志
spring.shardingsphere.props.sql.show=true

# 防止bean已被使用
spring.main.allow-bean-definition-overriding=true

最后直接来对水平分表进行测试，直接for循环100次将数据插入到数据库当中，添加代码：

    @Test
    void contextLoads() {
        for (int i =0;i<100;i++){
            User user = new User();
            user.setName("yue");
            user.setUserId(i+100);
            userMapper.insert(user);
        }
    }
    
    @Test
    void search(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("user_id",43);
        wrapper.eq("id",1465571154688245765L);
        List<Object> list = userMapper.selectObjs(wrapper);
        for (Object user:list){
            System.out.println(user);
        }
    }

2.2、水平分库分表

约定规则：如果添加用户id是奇数把数据添加user1，如果偶数添加到user2。这里还是用上面的表结构，但是在这里我们将创建两个库，springboot1和springboot2两个库，当userid为奇数加入springboot1这个库当中，偶数加入到springboot2这个库当中。首先将两个库以及库里面的表创建出来。

在这里修改配置文件，加入第二个数据源，以及分库的策略。其余Java代码不变，同样的直接执行test进行测试，查看对应的数据库的表数据进行验证。

# 配置真实数据源（给数据源取一个名字）
spring.shardingsphere.datasource.names=ds1,ds2

# 配置第 1 个数据源（对应自己的数据库）
spring.shardingsphere.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds1.url=jdbc:mysql://localhost:3306/springboot1?serverTimezone=GMT%2B8
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=root

# 配置第 2 个数据源（对应自己的数据库）
spring.shardingsphere.datasource.ds2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds2.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds2.url=jdbc:mysql://localhost:3306/springboot2?serverTimezone=GMT%2B8
spring.shardingsphere.datasource.ds2.username=root
spring.shardingsphere.datasource.ds2.password=root

# 指定库表的分布规则
spring.shardingsphere.sharding.tables.user.actual-data-nodes=ds$->{1..2}.user$->{1..2}

# 指定主键生成策略 主键id通过雪花算法生成
spring.shardingsphere.sharding.tables.user.key-generator.column=id
spring.shardingsphere.sharding.tables.user.key-generator.type=SNOWFLAKE

# 指定分片策略 根据生成的id进行分表
spring.shardingsphere.sharding.tables.user.table-strategy.inline.sharding-column=id
spring.shardingsphere.sharding.tables.user.table-strategy.inline.algorithm-expression=user$->{id % 2 +1}

# 指定库的分片策略
spring.shardingsphere.sharding.tables.user.database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.tables.user.database-strategy.inline.algorithm-expression=ds$->{user_id % 2 +1}

# 打印执行的sql语句日志
spring.shardingsphere.props.sql.show=true

# 防止bean已被使用
spring.main.allow-bean-definition-overriding=true

2.3、垂直分库分表

加入新库和新表，

CREATE DATABASE detail；

CREATE TABLE user_detail(
	user_id BIGINT(20) PRIMARY KEY,
	age VARCHAR(50) NOT NULL,
	sex VARCHAR(2) NOT NULL
);

修改配置文件：

# 配置真实数据源（给数据源取一个名字）
spring.shardingsphere.datasource.names=ds1,ds2,ds3

# 配置第 1 个数据源（对应自己的数据库）
spring.shardingsphere.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds1.url=jdbc:mysql://localgost:3306/springboot1?serverTimezone=GMT%2B8
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=root

# 配置第 2 个数据源（对应自己的数据库）
spring.shardingsphere.datasource.ds2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds2.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds2.url=jdbc:mysql://localhost:3306/springboot2?serverTimezone=GMT%2B8
spring.shardingsphere.datasource.ds2.username=root
spring.shardingsphere.datasource.ds2.password=root

# 配置第 3 个数据源（对应自己的数据库）
spring.shardingsphere.datasource.ds3.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds3.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds3.url=jdbc:mysql://localhost:3306/detail?serverTimezone=GMT%2B8
spring.shardingsphere.datasource.ds3.username=root
spring.shardingsphere.datasource.ds3.password=root

# 指定库表的分布规则
spring.shardingsphere.sharding.tables.user_detail.actual-data-nodes=ds3.user_detail

# 指定主键生成策略 主键id通过雪花算法生成
spring.shardingsphere.sharding.tables.user_detail.key-generator.column=user_id
spring.shardingsphere.sharding.tables.user_detail.key-generator.type=SNOWFLAKE

# 指定分片策略 根据生成的id进行分表
spring.shardingsphere.sharding.tables.user_detail.table-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.tables.user_detail.table-strategy.inline.algorithm-expression=user_detail

# 打印执行的sql语句日志
spring.shardingsphere.props.sql.show=true

# 防止bean已被使用
spring.main.allow-bean-definition-overriding=true

2.4、公共表操作

在进行分库分表之后，多个数据表的数据会存在公共使用的表，在这里shardingjdbc也提供了对公共表的操作，在多个库当中的相同表，再每对其中一个公共表进行操作之后，另外库里面的公共表也会随之进行该变。在前面有使用到了三个库，直接在这三个库当中都加入一个相同表结构的表，作为一个公共表。

create table common(
	common_id BIGINT(20) PRIMARY KEY,
	common_name VARCHAR(50) NOT NULL,
	common_detail VARCHAR(20) NOT NULL
)

而后在对于前面的配置文件进行修改，只需要加上对公共表的配置进行即可：

# 配置公共表
spring.shardingsphere.sharding.broadcast-tables=common
spring.shardingsphere.sharding.tables.common.key-generator.column=common_id
spring.shardingsphere.sharding.tables.common.key-generator.type=SNOWFLAKE

之后加上对应的实体类和mapper进行测试：直接跑一遍执行，程序跑完之后，直接在这三个库当中的common表进行查看数据。

2.5、读写分离与主从复制

为了确保数据库产品的稳定性，很多数据库拥有双机热备功能。也就是，第一台数据库服务器，是对外提供增删改业务的生产服务器;第二台数据库服务器，主要进行读的操作。原理∶让主数据库( master )处理事务性增、改、删操作，而从数据库( slave )处理SELECT查询操作。

在进行搭建数据库主从复制，首先我们需要准备两个数据库服务，这里以就按windows上的mysql服务为例，只需要将第一次安装的mysql服务复制一份出来，修改对应的my.ini配置文件，将端口、安装位置，数据存储目录进行相对应的修改即可。

[mysql]
# 设置mysql客户端默认字符集
default-character-set=utf8 
[mysqld]
#设置3307端口
port = 3307
# 设置mysql的安装目录
basedir=F:mysqlmysql-8.0.18-winx64-slave
# 允许最大连接数
max_connections=200
# 服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=utf8
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
# 设置mysql数据库的数据的存放目录
datadir=F:mysqlmysql-8.0.18-winx64-slavedata
default-time_zone = '+8:00'

修改完成之后，进入到复制后的bin目录当中打开cmd窗口，将这个服务进行安装，使用以下命令：

mysqld install mysqlslave --defaults-file="F:mysqlmysql-8.0.18-winx64-slavemy.ini"
# 安装失败报错，使用管理员打开cmd安装即可
Install/Remove of the Service Denied

之后我们需要对两个mysql服务进行设置主服务器和从服务器。首先在主服务器上加上配置：

[mysqld]
server-id = 1        # 节点ID，确保唯一 一般设置为IP
binlog-do-db=springboot  # 复制过滤：需要备份的数据库，输出binlog
# log config
log-bin = mysql-bin        #开启mysql的binlog日志功能 可以随便取，最好有含义
sync_binlog = 1            #控制数据库的binlog刷到磁盘上去 , 0 不控制，性能最好，1每次事物提交都会刷到日志文件中，性能最差，最安全
binlog_format = mixed      #binlog日志格式，mysql默认采用statement，建议使用mixed
expire_logs_days = 7       #binlog过期清理时间 二进制日志自动删除/过期的天数。默认值为0，表示不自动删除
max_binlog_size = 100m     #binlog每个日志文件大小
binlog_cache_size = 4m     #binlog缓存大小  为每个session 分配的内存，在事务过程中用来存储二进制日志的缓存
max_binlog_cache_size= 512m   #最大binlog缓存大
binlog-ignore-db=mysql     #不需要备份的数据库不生成日志文件的数据库，多个忽略数据库可以用逗号拼接，或者 复制这句话，写多行
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
#slave-skip-errors = all #跳过从库错误
slave-skip-errors = all 
auto-increment-offset = 1     # 自增值的偏移量
auto-increment-increment = 1  # 自增值的自增量

而后在从服务器上同样的加上配置：

[mysqld]
server-id = 2
log-bin=mysql-bin
relay-log=mysql-relay-bin
replicate-wild-ignore-table=mysql.%
replicate-wild-ignore-table=test.%
replicate-wild-ignore-table=information_schema.%

修改配置之后，将服务进行重启，同样，可以创建另外的用户进行测试。或者直接拿root用户进行测试。

GRANT REPLICATION SLAVE ON *.* TO 'db_sync'@'%' IDENTIFIED BY 'db_sync';
#刷新权限
FLUSH PRIVILEGES;

先进入到主服务器当中查看主服务器的状态：

mysql> SHOW MASTER STATUS;

+------------------+----------+--------------+------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000001 |      537 | springboot   | mysql            |                   |
+------------------+----------+--------------+------------------+-------------------+

而后进入到从服务器当中，

# 先停止同步
STOP SLAVE;

# 修改从库指向到主库，使用上一步记录的文件名以及位点，对应前面主服务的状态数据
CHANGE MASTER TO
MASTER_HOST = 'localhost',
MASTER_USER = 'root',
MASTER_PASSWORD = 'root',
MASTER_LOG_FILE = 'mysql-bin.000001',
MASTER_LOG_POS = 155;

# 启动同步
START SLAVE;

# 查看Slave_IO_Runing和Slave_SQL_Runing字段值都为Yes，表示同步配置成功。
SHOW SLAVE STATUS;

# 存在问题 slave_io_running的值为NO，继续看查出来的表数据，发现在后面有一个单元格有错误的log信息，可以查看log信息：
# Fatal error: The slave I/O thread stops because master and slave have equal MySQL server UUIDs; these UUIDs must be different for replication to work.
# 因为主服务器和从服务器具有相同的MySQL服务器UUID；这些UUID必须不同，复制才能工作。
# 在前面进行复制的时候，是全量复制过来的，而UUID又没有进行修改，直接修改mysql的存放数据目录的auto.cnf文件，将UUID随便给个值，再重启从服务器即可。

最后进行验证，直接再主服务器当中对对应的库的数据进行修改或者新增等等操作，看从服务器当中的数据会不会进行相对应的改变即可。

代码实现，修改配置文件：对主服务器和从服务器进行相关配置

# 配置真实数据源（给数据源取一个名字）
spring.shardingsphere.datasource.names=ds1,s1

# 主服务器
spring.shardingsphere.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds1.url=jdbc:mysql://localhost:3306/springboot?serverTimezone=GMT%2B8
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=root

# 从服务器
spring.shardingsphere.datasource.s1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.s1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.s1.url=jdbc:mysql://localhost:3307/springboot?serverTimezone=GMT%2B8
spring.shardingsphere.datasource.s1.username=root
spring.shardingsphere.datasource.s1.password=root

# 主从关系
spring.shardingsphere.sharding.master-slave-rules.ds1.master-data-source-name=ds1
spring.shardingsphere.sharding.master-slave-rules.ds1.slave-data-source-names=s1

spring.shardingsphere.sharding.tables.user1.actual-data-nodes=ds1.user1

# 打印执行的sql语句日志
spring.shardingsphere.props.sql.show=true

# 防止bean已被使用
spring.main.allow-bean-definition-overriding=true

最后添加代码进行测试，加入一个插入和查询的方法，查看日志，插入操作的是主服务器，而查询数据是操作的从服务器。这样也就完成了读写分离和主从复制。

在对诸如订单、交易、支付等实时在线业务系统的研发、维护过程中，随着业务量的快速增长，我们经常会遇到由于关系型数据库（如:MySql）单表数据量增长过大而引发的线上事故；虽然这些事故多数时候是由于不合理的慢SQL而引起的系统雪崩，但有时也会出现由于数据库热点块IO争用而引发的系统性性能下降。总之，单表数据量的无限增长总是会在这样或那样的情况下增加系统的不稳定性因素。

所以在大规模实时系统的设计中，除了重点考虑应用结构的分布式化外，往往也不应该忽略数据库实时存储、计算能力扩展性方面的考虑。目前解决实时数据增长一般有两种思路：一种是直接采用分布式数据库（例如:***Tidb、OceanBase***之类）；另一种是对关系型数据库进行分库分表来最大化利用现有数据库的实时计算能力。绝大部分情况下，后一种方案往往会更现实一些。

本文的主要内容就是通过模拟一个交易系统的订单库，来具体演示如何通过***ShardingJdbc***实现交易订单数据的分库分表存储。在这个过程中会到涉及分库分表实践的三种主要场景：1、新系统在设计之初直接使用分库分表方案；2、历史系统运行一段时间后如何平滑地实施分库分表；3、对现有分库分表逻辑的Scaling操作(包括减少分表、增加分表)涉及的数据迁移问题。

Spring Boot集成ShardingJdbc实现分库分表

交易系统的订单数据是分库分表的一个非常典型场景，由于交易系统对单条数据的实时处理性能要求很高，所以一旦单个订单表数据量规模达到10亿+，就很容易出现由于数据库热点块IO争用而导致的性能下降，也很容易出现个别不谨慎的SQL操作而引起的系统性雪崩。

但一旦决定实施分库分表就要提前做好存储规划，并对未来数据增长的规模进行一定的评估，同时做好未来增加分库、增加分表的系统Scaling方案。此外，分库分表的实施还要考虑应用的接入难度，分库分表的细节逻辑应该对应用透明；所以一般来说我们需要一个中间代理层来屏蔽分库分表对应用程序本身带来的侵入。

目前在Java社区中比较知名的分库分表代理组件就是ShardingJdbc（目前已被集成在Apache开源项目 ShardingSphere之中），ShardingJdbc本质上是一个轻量级的JDBC驱动代理，在使用的过程中只需要依赖相关Jar包即可，并不需要额外部署任何服务。通过系统配置文件就可以实现分库分表逻辑的定义，并实现应用透明代理访问。

接下来，我们以Spring Boot为例演示如何集成ShardingJdbc实现对交易订单的分库分表操作，具体步骤如下：

1）、订单数据的分库分表规划

在系统设计之初，如果能够预见到未来数据量的增长规模，那么提前做好分库分表规划是非常有远见的。从分库分表的形式上来说，一般可以有两类规划方式：1）、单库水平分表，如果单一数据库计算能力比较强，可以在同一个库中进行数据表的水平拆分；2）、分库+分表，如果数据规模爆炸式增长，单库的计算资源有限，为了提升数据库的整体计算处理性能，也可以同时实现多个库的分库分表存储。

在本文的实例中，我们将订单数据分库分表规划为：1）、数据库节点2个（ds0、ds1）；2)、每个库的分表数为32张表（0~31）。订单表的整体数据分库分表逻辑是根据订单表中的**“user_id字段%2”实现分库；然后在分库逻辑的基础上根据订单表中的“order_id字段%32”**实现水平分表。例如，有条user_id为1001、订单编号为20200713001的订单数据，根据上述分库分表规则1001%2=1，20200713001%32=9，那么该数据将存储在ds1库中的第9个分表。

具体的订单逻辑表结构如下：

create table t_order (
 id bigint not null primary key auto_increment,
 order_id bigint comment '业务方订单号（业务方系统唯一）',
 trade_type varchar (30) comment '业务交易类型，例如topup-表示钱包充值',
 amount bigint comment '交易金额，以分为单位',
 currency varchar (10) comment '币种，cny-人民币',
 status varchar (2) comment '支付状态，0-待支付；1-支付中；2-支付成功；3-支付失败',
 channel varchar (10) comment '支付渠道编码，0-微信支付，1-支付宝支付',
 trade_no varchar (32) comment '支付渠道流水号',
 user_id bigint (60) comment '业务方用户id',
 update_time timestamp null default current_timestamp on update current_timestamp comment '最后一次更新时间',
 create_time timestamp null default current_timestamp comment '交易创建时间',
 remark varchar(128)  comment '订单备注信息',
 key unique_idx_pay_id ( order_id ),
 key idx_user_id ( user_id ),
 key idx_create_time ( create_time )
);
alter table t_order comment '交易订单表';

以上逻辑表的具体分表形式为t_order_{0~31}，分别分布在ds0、ds1两个数据库节点中。

2）、创建实验工程代码结构

首先创建一个基于Maven构建的Spring Boot项目，并集成MyBatis数据库访问框架，代码结构如下：

如上图所示，我们创建了一个基于Spring Boot的基本工程，并在集成了基于Mybatis的数据库访问功能。此外该工程还实现了单元/集成测试代码的分离管理。

3）、SpringBoot+ShardingJdbc实现订单分库分表规则配置

接下来我们来看下在Spring Boot项目中如何集成ShardingJdbc，并按照规划的分库分表规则进行具体的配置。

首先引入ShardingJdbc针对Spring Boot项目的starter依赖包，具体如下：

<!-- 引入Sharding-JDBC Spring Boot依赖组件 -->
<!-- Sharding-JDBC For Spring Boot Start -->
<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    <version>${sharding-sphere.version}</version>
</dependency>
<!-- for spring namespace -->
<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>sharding-jdbc-spring-namespace</artifactId>
    <version>${sharding-sphere.version}</version>
</dependency>
<!-- Sharding-JDBC For Spring Boot End -->

引入Spring Boot Starter依赖后，ShardingJdbc会使用自己的数据源配置逻辑，为避免冲突需要在主类中排除掉默认的数据源自动配置类，具体如下：

//排除掉默认的数据源自动配置类
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class OrderServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServerApplication.class, args);
    }
}

完成上述操作后，从工程逻辑上看就已经完成了ShardingJdbc与Spring Boot应用的集成。接下来我们要做的就是根据规划的分库分表规则，通过配置文件进行分库分表规则的配置，具体如下：

#SQL控制台打印（开发时配置）
spring.shardingsphere.props.sql.show = true
# 配置真实数据源
spring.shardingsphere.datasource.names=ds0,ds1

# 配置第1个数据源
spring.shardingsphere.datasource.ds0.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds0.url=jdbc:mysql://127.0.0.1:3306/order_0?characterEncoding=utf-8
spring.shardingsphere.datasource.ds0.username=root
spring.shardingsphere.datasource.ds0.password=123456

# 配置第2个数据源
spring.shardingsphere.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds1.url=jdbc:mysql://127.0.0.1:3306/order_1?characterEncoding=utf-8
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=123456

# 配置t_order表规则
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds$->{0..1}.t_order_$->{0..31}
# 配置t_order表分库策略（inline-基于行表达式的分片算法）
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression=ds${user_id % 2}
# 配置t_order表分表策略
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression = t_order_$->{order_id % 32}

#如其他表有分库分表需求，配置同上述t_order表
# ...

上述配置文件中，我们配置了两个数据源，对应的数据库分别为order_0、order_1，这两个数据库中分别存储了t_order这张逻辑表的分表信息{0~31}，总共64张数据库来分散存储订单信息。分库分表的维度主要有2个分别是：用户ID作为分库键、订单ID作为分表键。

4）、编写订单入库逻辑测试ShardingJdbc分库分表效果

通过上述步骤，到这里我们已经从功能上完成了针对订单表的分库分表逻辑。具体针对订单表的操作逻辑，还是和正常使用Mybatis操作数据库表一样，并不需要针对分库分表进行额外的代码操作，因为ShardingJdbc会在数据库驱动层拦截SQL并进行分库分表规则的匹配及路由操作。

和正常基于Spring Mvc的开发一样，我们编写一个基于Mvc分层的订单创建接口,启动应用程序，效果如下：

可以看到从编程方式上看，与我们平时写Java代码的分层结构完全一致，此时模拟调用该订单创建接口，具体请求参数如下：

{
    "orderId":123458,
    "tradeType":"topup",
    "amount":1000,
    "currency":"cny",
    "userId":63631725
}

按照该请求参数的数据规则，此条订单应该存在编号为1数据库中编号2的分表中，具体计算（“userId->63631725%2=1;orderId->123458%32=2”），完成接口调用后可以查询数据库表数据进行验证！

前面我们演示了在预先规划好分库分表结构的情况下，使用ShardingJdbc实现了应用透明的分库分表操作。但大部分情况下，能够有先见之明提前规划好长远数据表分散存储方案的系统是很少的，只有当数据规模达到一定的级别，系统性能遇到相应瓶颈时分库分表方案才会被顺理成章的放到桌面选项中。

而这一般又会涉及两个场景的场景：

• 1)、尚未进行分库分表的单库单表系统如何平稳的实施分库分表方案；
• 2)、已经实时过分库分表方案的系统，由于数据量的持续增长导致原有分库分表不够用了，需要二次扩容的情况。*

上述两个场景，无论哪种情况都会面临由于存储规则改变而需要大量进行数据迁移的情况,这对于正在线上运行的系统来说，无异于是要给正在高速行驶中的汽车换轮子，稍有不慎就会造成系统崩溃的严重后果。所以敢于对这类系统进行结构性重塑的程序员都是真的猛士！

写在最后

欢迎大家关注我的公众号【风平浪静如码】，海量Java相关文章，学习资料都会在里面更新，整理的资料也会放在里面。

觉得写的还不错的就点个赞，加个关注呗！点关注，不迷路，持续更新！！！

Apache ShardingSphere 是一套开源的分布式数据库解决方案组成的生态圈，它由 JDBC、Proxy 和 Sidecar 这 3 款既能够独立部署，又支持混合部署配合使用的产品组成。它们均提供标准化的数据水平扩展、分布式事务和分布式治理等功能，可适用于如 Java 同构、异构语言、云原生等各种多样化的应用场景。

ShardingSphere 是一个很活跃的项目，当前稳定版是 4.x ，预览版 5.x 及文档早已发布。ShardingSphere 早期 3.x 之前版本和 4.x 之后版本配置不兼容，而且从 4.x 开始才修复解析 select for update 语句问题，并且严格校验 schema ，不允许跨库查询。

本章基于 4.x 版本，使用 Sharding JDBC 实现分库分表，并配置 Sharding Proxy 和 Sharding UI 实现聚合查询。

Sharding JDBC

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

• 引入依赖

Sharding JDBC：

 <dependency>
	<groupId>org.apache.shardingsphere</groupId>
	<artifactId>sharding-jdbc-spring-boot-starter</artifactId>
	<version>${version}</version>
</dependency>

Spring JDBC 和 MySQL 驱动：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
</dependency>

• 配置

配置数据源

spring:
  shardingsphere:
    props:
      show-sql: true # 打印sql语句，调试时可开启
    datasource:
      names: master1,slave1,slave2 # 配置三个数据源，主库master1，从库slave1和slave2
      master1:
        type: org.apache.commons.dbcp2.BasicDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://${MYSQL_HOST:localhost}:3307/engrz?useSSL=false&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
        username: ${MYSQL_USER:engrz}
        password: ${MYSQL_PASSWORD:engrz2021}
      slave1:
        type: org.apache.commons.dbcp2.BasicDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://${MYSQL_HOST:localhost}:3308/engrz?useSSL=false&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
        username: ${MYSQL_USER:engrz}
        password: ${MYSQL_PASSWORD:engrz2021}
      slave2:
        type: org.apache.commons.dbcp2.BasicDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://${MYSQL_HOST:localhost}:3309/engrz?useSSL=false&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
        username: ${MYSQL_USER:engrz}
        password: ${MYSQL_PASSWORD:engrz2021}

读写分离和分库分表

spring:
  shardingsphere:
    sharding:
      master-slave-rules:
        ds1: # 读写分离数据源，如果有多个库可配置多个
          master-data-source-name: master1
          slave-data-source-names: slave1,slave2
      tables:
        t_user_info: # 表名
          actual-data-nodes: ds1.t_user_info_${0..9} # 规则，使用Groovy语法
          table-strategy:
            inline:
              sharding-column: user_id # 分片字段
              algorithm-expression: t_user_info_${user_id % 10}
        t_user_log: # 表名
          actual-data-nodes: ds1.t_user_log_$->{2019..2021} # 规则，使用Groovy语法
          table-strategy:
            standard:
              sharding-column: log_date # 分片字段
              precise-algorithm-class-name: com.engrz.commons.sharding.jdbc.algorithm.DatePreciseModuloShardingTableAlgorithm
              range-algorithm-class-name: com.engrz.commons.sharding.jdbc.algorithm.DateRangeModuloShardingTableAlgorithm

Sharding JDBC 配置单纯的读写分离和分库分表的读写分离配置写法有一点差别
仅使用读写分离配置属性：spring.shardingsphere.masterslave.*
分库分表的读写分离配置属性：spring.shardingsphere.sharding.master-slave-rules.*

配置文件中分片说明：

t_user (用户表)

分10张表，user_id字段为long型主键，使用 user_id 值取模，把计算结果拼上表名，完整名如：t_user_info_0、t_user_info_1

t_user_log (用户日志表)

按年份分表，从2019到2021，使用自定义分片策略

DatePreciseModuloShardingTableAlgorithm：

/**
 * 日期精确匹配
 */
public class DatePreciseModuloShardingTableAlgorithm implements PreciseShardingAlgorithm<Date> {

    @Override
    public String doSharding(Collection<String> collection, PreciseShardingValue<Date> preciseShardingValue) {

        Date date = preciseShardingValue.getValue();
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        String year = String.valueOf(c.get(Calendar.YEAR));

        String tableName = null;
        for (String tmp : collection) {
            if (tmp.endsWith(year)) {
                // 如果以当前年份结尾
                tableName = tmp;
                break;
            }
        }

        if (null == tableName) {
            String str = collection.iterator().next();
            tableName = str.substring(0, str.lastIndexOf("_"));
        }

        return tableName;
    }
}

DateRangeModuloShardingTableAlgorithm：

/**
 * 日期范围查询
 */
public class DateRangeModuloShardingTableAlgorithm implements RangeShardingAlgorithm<Date> {

    @Override
    public Collection<String> doSharding(Collection<String> collection, RangeShardingValue<Date> rangeShardingValue) {

        // 这里可以处理日期字段，避免多余查询
        Range<Date> range = rangeShardingValue.getValueRange();

        Integer start = null;
        if (range.hasLowerBound()) {
            Date lowerEndpoint = range.lowerEndpoint();
            Calendar c = Calendar.getInstance();
            c.setTime(lowerEndpoint);
            start = Calendar.YEAR;
        }
        Integer end = null;
        if (range.hasUpperBound()) {
            Date upperEndpoint = range.upperEndpoint();
            Calendar c = Calendar.getInstance();
            c.setTime(upperEndpoint);
            end = Calendar.YEAR;
        }

        if (null == start && null == end) {
            return collection;
        }

        List<String> list = new ArrayList<>();
        for (String tableName : collection) {
            int suffix = Integer.parseInt(tableName.substring(tableName.lastIndexOf("_") + 1));
            if (null != start && suffix < start) {
                continue;
            }
            if (null != end && suffix > end) {
                continue;
            }
            list.add(tableName);
        }

        return list;
    }
}

如果日志量大，还可以按季度分表，只要在方法中稍作修改，返回对应的表名即可。

关于 Sharding JDBC 的分片策略和分片算法，可查阅官方文档。

• 注意事项

1. 使用分库分表后要注意主键唯一，可使用雪花算法生成主键
2. 使用 Sharding JDBC 查询时尽量带上分库分表字段作为条件，避免全局扫描
3. 主从模型中，事务中读写均用主库
4. 某些sql语句不支持解析，如 distinct 和 group by 连用

• Sharding JDBC 4.x SQL 解析支持说明

Sharding Proxy

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

使用 Sharding JDBC 分库分表后，数库落在不同的数据库和数据表中，使用 Sharding Proxy 作为代理，它会帮我们把上面的 t_user_0，t_user_1 … 聚合成一张 t_user 逻辑表。

Sharding Proxy 的安装配置请参考官方文档。如果有自定义分片算法，把代码打成JAR包放到 Sharding Proxy 解压后的conf/lib目录下。

实际使用中发现 Sharding Proxy 对连接的客户端有版本校验，比如我用 MySQL Workbench 8.0 无法连接 MySQL 5.7 的数据库。可以使用 DBeaver 客户端，手动指定与服务端版本对应的驱动。

Sharding UI

Sharding UI是 ShardingSphere 的一个简单而有用的web管理控制台。它用于帮助用户更简单地使用 ShardingSphere 的相关功能，目前提供注册中心管理、动态配置管理、数据库编排等功能。

Sharding UI 和 Sharding Proxy 方便我们管理数据库，在理解 Sharding JDBC 分库分表后配置十分简单，可参考 Sharding Sphere 4.x 相关文档

除非注明，否则均为"攻城狮·正"原创文章，转载请注明出处。
本文链接：https://engr-z.com/177.html