java 动态创建mysql分区 java mysql分表

目录

一、事务

1）ACID

2）事务并发访问的问题

3）隔离级别

4）模拟事务

二、索引

存储引擎中索引的实现

三、慢 SQL

1、慢查询

2、explain 分析 SQL

四、SQL 调优

五、分库分表

1、垂直（纵向）切分

2、⽔平（横向）切分

3、分库分表带来的问题

4、什么时候考虑分片

六、MyCat 分库分表

常⻅应⽤场景:

SpringBoot+Mycat+MySQL实现分表分库

一、事务

事务就是一组原子性的SQL查询，或者说是一个独立的工作单元。事务内的语句，要么全部执行成功，要么全部执行失败。

1）ACID

原⼦性（atomicity）

⼀个事务必须被视为⼀个不可分割的最⼩⼯作单元，整个事务中所有的操作要么全部提交成 功，要么全部失败回滚，对于⼀个事务来说，不可能只执⾏其中的⼀部分操作，这就是事务的原⼦性。

⼀致性（consistency）

数据库总是从⼀个⼀致性的状态转换到另外⼀个⼀致性的状态。

隔离性（isolation）

通常来说，⼀个事务所做的修改在最终提交之前，对其他事务是不可⻅的。

持久性（durability）

⼀旦事务提交，则其所做的修改就会永久保存到数据库中。这⾥持久性是个有点模糊的概念，实际上持久性也分很多不同的级别。

2）事务并发访问的问题

① 脏读：事务A读取到了事务B未提交的数据

② 不可重复读：事务A读取到了事务B提交的数据

③ 幻读：事务A读取到了事务B新增的数据（区别：不可重复读是事务A读取到了事务B的更新数据；幻读是事务A读取到了事务B的更新数据）

3）隔离级别

① READ UNCOMMITTED（读未提交读），会出现脏读及其他问题
② READ COMMITTED（读提交），解决脏读问题，但会出现不可重复读及其他问题
③ REPEATABLE RREAD（可重复读），解决脏读和不可重复读问题，但会出现幻读问题（MySQL默认事务隔离级别）
④ SERIALIZABLE（串行化）最高隔离级别，强制事务串行执行，解决上面脏读、不可重复读、幻读问题

4）模拟事务

首先查看 ”自动提交“ 是否关闭

show variables like 'autocommit';

未关闭则使用以下命令关闭

set session autocommit=0;

关闭后如下：

完成模拟需要打开两个客户端，并都关闭自动提交。

接着查询事务类别

select @@tx_isolation;

MySQL 默认是可重复读：

设置隔离级别：（设置成 读未提交，两个客户端都需要设置）

set session transaction isolation level read uncommitted;

设置完后如下：

 

 现在开始测试 读未提交（脏读） ：

① 先查一下数据库：

 ② 使用以下命令开启事务（两个客户端都需要开启）

start transaction;

③ 事务 A 修改数据，不提交

④ 事务 B 查询到事务 A 未提交的数据（脏读）

 同样的方法设置 读已提交（不可重复读）：

set session transaction isolation level read committed;

 

事务 A 读取到了事务 B 提交的 更新 数据 

同样的方法设置 可重复读（幻读）：

set session transaction isolation level repeatable read;

事务 A 读取到了事务 B 提交的 新增 数据

二、索引

认识索引

1. 索引是按照特定的数据结构把数据表中的数据放在索引⽂件中，以便于快速查找；
2. 索引存在于磁盘中，会占据物理空间。

索引的类型

1. FULLTEXT 全⽂索引，⽬前只有MyISAM引擎⽀持。
2. HASH 索引，可以⼀次定位，不需要像树形索引那样逐层查找,因此具有极⾼的效率。但是，这种⾼效是有条件的，即只在“=”和“in”条件下⾼效，对于范围查询、排序及组合索引仍然效率不⾼。
3. BTREE 索引 ，就是⼀种将索引值按⼀定的算法，存⼊⼀个树形的数据结构中（⼆叉树），每次查询都是从树的⼊⼝root开始，依次遍历node，获取leaf。这是MySQL⾥默认和最常⽤的索引类型。

索引种类

1. 主键索引：MySQL中主键必须唯⼀且不能有空值，因此在主键上的索引也是唯⼀索引。⼀个表上的唯⼀索引可以有多个，但主键只有⼀个。
2. 唯⼀索引：唯⼀索引顾名思义，索引必须唯⼀，唯⼀索引中允许有空值出现。
3. 普通索引
4. 组合索引（联合索引） INDEX(A, B, C)

存储引擎中索引的实现

1. 在MySQL中，索引是在存储引擎中实现的。
2. 不同的存储引擎可能⽀持不同的索引类型。
3. 不同的存储引擎对同⼀种索引类型可能有不同的实现⽅式。

InnoDB存储引擎：

特点：

① ⾮叶⼦节点不存真实数据（仅起索引作用，保证叶子节点高度相同，读写速度稳定），有且只有叶⼦节点存数据。（减少磁盘IO次数，读写代价低）

② 叶⼦节点的数据组织是有序的，双向链表。（使得B+树有更多顺序ID，效率高）

③ 数据查询是从根磁盘通过⼆分法向下查找数据。

B+ 索引类型：

聚簇索引： 主键索引

⾮聚簇索引：只存储主键ID，有⼀次回表

MyISAM索引实现：

MyISAM 引擎使用 B+Tree 作为索引结构，叶子节点的 data 域存放的是数据记录的物理地址

 

MyISAM 和 InnoDB 的区别：

①支持事务：MyISAM 不支持；InnoDB 支持；

②存储结构：MyISAM存成三个文件：.frm（存储表结构）.MYD（存储数据）.MYI（存储索引）；

InnoDB存成两种文件：.frm（存储表结构）.ibd（存储数据和索引【可多个】）；

③表锁差异：MyISAM 只支持表级锁；InnoDB 支持事务和行级锁；

④表主键：MyISAM 允许没有任何索引和主键的表存在；InnoDB 会自动生成一个6字节主键

⑤CRUD操作：MyISAM 执行大量SELECT操作更优；InnoDB 执行大量 INSERT 或 UPDATE 操作更优

⑥外键：MyISAM 不支持；InnoDB 支持

三、慢 SQL

从数据库⻆度看：每个SQL执⾏都需要消耗⼀定I/O资源，SQL执⾏的快慢，决定资源被占⽤时间的⻓短。

从应⽤的⻆度看：SQL执⾏时间⻓意味着等待，在OLTP应⽤当中，⽤户的体验较差。

优化 SQL 首先需要了解：MySQL 执行流程：

解析：词法解析 -> 语法解析 -> 逻辑计划 -> 查询优化 -> 物理执⾏计划

执⾏：检查⽤户、表权限 -> 表上加共享读锁 -> 取数据到query cache -> 取消共享读锁 -

1、慢查询

MySQL 的慢查询日志是 MySQL 提供的一种日志记录，它用来记录在 MySQL 中响应时间超过阀值的语句，具体指运行时间超过 long_query_time 值的 SQL，则会被记录到慢查询日志中。

long_query_time 的默认值为 10，意思是运行 10S 以上的语句。默认情况下，Mysql数据库并不启动慢查询日志，需要我们手动来设置这个参数，当然，如果不是调优需要的话，一般不建议启动该参数，因为开启慢查询日志会或多或少带来一定的性能影响。

当 Mysql 性能下降时，通过开启慢查询来找到执⾏慢的 SQL, ⽅便我们对这些 SQL 进⾏优化。

查看是否开启慢查询

show variables like "%slow%";

查看系统慢日志等其他系统功能信息

show variables like "%query%";

参数解析：

long_query_time：阈值时间

slow_query_log_file：日志文件位置

slow_query_log：是否开启慢查询日志

查看慢日志中包含的慢查询 sql 语句条数

show status like "%slow_queries%";

开启慢查询

set global slow_query_log='ON';

修改慢查询时间阈值

set long_query_time=1;

慢 SQL 的优化分两步，第一步是定位语句，就是通过上面的慢查询日志找到具体的 SQL 语句；第二步是分析语句，使用关键字 explain 来具体分析 SQL 语句慢的地方。

2、explain 分析 SQL

explain [sql 语句]；

 id：select 查询的序列号：id 值越大，优先级越高，id 值相同时，则执行顺序自上而下

select_type：表示查询的类型。

table：输出结果集的表

partitions：匹配的分区

type：表示表的连接类型

possible_keys：表示查询时，可能使⽤的索引

key：表示实际使⽤的索引

key_len：索引字段的⻓度

ref：列与索引的⽐较

rows：扫描出的⾏数(估算的⾏数)

filtered：按表条件过滤的⾏百分⽐

Extra：执⾏情况的描述和说明

官方文档：MySQL :: MySQL 5.7 Reference Manual :: 8.8.2 EXPLAIN Output Format

四、SQL 调优

① 不使⽤⼦查询

② 避免使用函数索引

【SELECT * FROM t WHERE YEAR(d) >= 2016;】

由于 MySQL 不像 Oracle 那样⽀持函数索引，即使 d 字段有索引，也会直接全表扫描。

应改为 【 SELECT * FROM t WHERE d >= '2016-01-01';】

③ ⽤ IN 来替换 OR

低效查询 > SELECT * FROM t WHERE LOC_ID = 10 OR LOC_ID = 20 OR LOC_ID = 30;

⾼效查询 > SELECT * FROM t WHERE LOC_ID IN (10,20,30);

④ LIKE 双百分号⽆法使⽤到索引

⑤ 读取适当的记录 LIMIT M,N

不限制的话，在数据量大的时候可能会进行跨存储页查询

⑥ 分组统计可以禁⽌排序

【SELECT goods_id,count(*) FROM t GROUP BY goods_id;】

默认情况下，MySQL 对所有 GROUP BY col1，col2... 的字段进⾏排序。如果查询包括 GROUP BY，想要避免排序结果的消耗，则可 以指定 ORDER BY NULL 禁⽌排序。

【 SELECT goods_id,count(*) FROM t GROUP BY goods_id ORDER BY NULL;】

⑦ 禁⽌不必要的 ORDER BY 排序

⑧ 正确使⽤组合索引（最左匹配原则）

index （age,name,addr）。a |a,b |a,b,c|

五、分库分表

关系型数据库本身⽐较容易成为系统瓶颈，单机存储容量、连接数、处理能⼒都有限。当单表的数据量达到2000W或100G以后，由于查询维度较多，即使添加从库、优化索引，做很多操作时性能仍下降严重。此时就要考虑对其进⾏切分了，切分的⽬的就在于减少数据库的负担，缩短查询时间。

数据切分根据其切分类型，可以分为两种⽅式：垂直（纵向）切分和⽔平（横向）切分

1、垂直（纵向）切分

① 垂直分库

垂直分库就是根据业务耦合性，将关联度低的不同表存储在不同的数据库。做法与⼤系统拆分为多个⼩系统类似，按业务分类进⾏独⽴划分。与"微服务治理"的做法相似，每个微服务使⽤单独的⼀个数据库。

② 垂直分表

垂直分表是基于数据库中的"列"进⾏，某个表字段较多，可以新建⼀张扩展表，将不经常⽤或字段⻓度较⼤的字段拆分出去到扩展表中。（一张表一般不超过 30 个字段）

MySQL底层是通过数据⻚存储的，⼀条记录占⽤空间过⼤会导致跨⻚，造成额外的性能开销。

 优点：

① 解决业务系统层⾯的耦合，业务清晰, 与微服务的治理类似，也能对不同业务的数据进⾏分级管理、维护、监控、扩展等；

② ⾼并发场景下，垂直切分⼀定程度的提升IO、数据库连接数、单机硬件资源的瓶颈。

缺点：

① 部分表⽆法 join，只能通过接⼝聚合⽅式解决，提升了开发的复杂度；

② 分布式事务处理复杂；

③ 依然存在单表数据量过⼤的问题（需要⽔平切分）。

2、⽔平（横向）切分

当⼀个应⽤难以再细粒度的垂直切分，或切分后数据量⾏数巨⼤，存在单库读写、存储性能瓶颈，这时候就需要进⾏⽔平切分了。 ⽔平切分分为 库内分表 和 分库分表，是根据表内数据内在的逻辑关系，将同⼀个表按不同的条件分散到多个数据库或多个表中，每个表中只包含⼀部分数据，从⽽使得单个表的数据量变⼩，达到分布式的效果。

优点：

① 不存在单库数据量过⼤、⾼并发的性能瓶颈，提升系统稳定性和负载能⼒；

② 应⽤端改造较⼩，不需要拆分业务模块。

缺点：

① 跨分⽚的事务⼀致性难以保证，跨库的 join 关联查询性能较差；

② 数据多次扩展难度和维护量都极⼤。

水平分⽚规则为：

（1）根据数值范围：

按照 时间区间 或 ID区间 来切分。例如：按⽇期将不同⽉甚⾄是⽇的数据分散到不同的库中；将userId为1~9999的记录分到第⼀个库，10000~20000的分到第⼆个库，以此类推。

优点：

① 单表⼤⼩可控；

② 便于⽔平扩展，后期如果想对整个分⽚集群扩容时，只需要添加节点即可，⽆需对其他分⽚的数据进⾏迁移；

③ 使⽤分⽚字段进⾏范围查找时，连续分⽚可快速定位分⽚进⾏快速查询，有效避免跨分⽚查询的问题。

缺点：

热点数据成为性能瓶颈。连续分⽚可能存在数据热点，例如按时间字段分⽚，有些分⽚存储最近时间段内的数据，可能会被频繁的读写，⽽有些分⽚存储的历史数据，则很少被查询。

（2）根据数值取模：

⼀般采⽤ hash取模 mod 的切分⽅式，例如：将 Customer 表根据 cusno 字段切分到 4 个库中，余数为 0 的放到第⼀个库，余数为 1 的放到第⼆个库，以此类推。

优点：

数据分⽚相对⽐较均匀，不容易出现热点和并发访问的瓶颈

缺点：

① 后期分⽚集群扩容时，需要迁移旧的数据（使⽤⼀致性hash算法能较好的避免这个问题）；

② 容易⾯临跨分⽚查询的复杂问题。⽐如上例中，如果频繁⽤到的查询条件中不带cusno时，将会导致⽆法定位数据库，从⽽需要同时向4个库发起查询，再在内存中合并数据，取最⼩集返回给应⽤，分库反⽽成为拖累。

3、分库分表带来的问题

1 ） 事务⼀致性问题

当更新内容同时分布在不同库中，不可避免会带来跨库事务问题。跨分⽚事务也是分布式事务，没有简单的⽅案，⼀般可使⽤"XA协议"和"两阶段提交"处理。

2 ） 跨节点关联查询 join 问题

切分前，查询详情⻚所需的数据可以通过sql join 来完成。但切分后，数据可能分布在不同的节点上，此时 join 带来的问题就⽐较麻烦了，考虑到性能，尽量避免使⽤ join 查询。

解决这个问题的⼀些⽅法：

① 全局表

全局表，也可看做是"数据字典表"，就是系统中所有模块都可能依赖的⼀些表，为了避免跨库 join 查询，可以将这类表在每个数据库中都保存⼀份。

② 字段冗余

⼀种典型的反范式设计，利⽤空间换时间，为了性能⽽避免 join 查询。例如：订单表保存 userId 时候，也将 userName 冗余保存⼀份，这样查询订单详情时就不需要再去查询"买家 user 表"了。

③ 数据组装

在系统层⾯，分两次查询，第⼀次查询的结果集中找出关联数据 id，然后根据 id 发起第⼆次请求得到关联数据。最后将获得到的数据进⾏字段拼装。

3 ） 跨节点分⻚、排序、函数问题

4 ） 全局主键避重问题

在分库分表环境中，由于表中数据同时存在不同数据库中，某个分区数据库⾃⽣成的ID⽆法保证全局唯⼀。因此需要单独设计全局主键，以避免跨库主键重复问题。有⼀些常⻅的主键⽣成策略：

① UUID

UUID 标准形式包含 32 个 16 进制数字，分为5段，例如：550e8400e29b41d4a716446655440000

UUID 是主键是最简单的⽅案，本地⽣成，性能⾼，没有⽹络耗时。但缺点也很明显，由于 UUID ⾮常⻓，会占⽤⼤量的存储空间；另外，作为主键建⽴索引和基于索引进⾏查询时都会存在性能问题，在 InnoDB 下，UUID 的⽆序性会引起数据位置频繁变动，导致分⻚。

② 结合数据库维护主键 ID 表 （跨步ID）

整体思想是：建⽴2个以上的 全局 ID ⽣成的服务器，每个服务器上只部署⼀个数据库，每个库有⼀张 sequence表⽤于记录当前全局 ID。表中 ID 增⻓的步⻓是库的数量， 起始值依次错开，这样能将ID的⽣成散列到各个数据库上。

缺点：系统添加机器，⽔平扩展时较复杂；每次获取ID都要读写⼀次 DB，DB 的压⼒还是很⼤，只能靠堆机器来提升性能。

③ Snowflake 分布式⾃增ID算法（雪花算法）

由 64 位的 Long 型数字组成：

（1）第1位未使⽤；

（2）41位毫秒级时间，41位的⻓度可以表示69年的时间；

（3）10位机器 id：5位 datacenterId，5位 workerId。10位的⻓度最多⽀持部署1024个节点；

（4）12位毫秒内的计数，12位的计数顺序⽀持每个节点每毫秒产⽣4096个ID序列。

 理论上 QPS 约为 409.6w/s（1000*2^12），并且整个分布式系统内不会产⽣ID碰撞；

不⾜就在于：强依赖机器时钟，如果时钟回拨，则可能导致⽣成ID重复。

5）数据迁移、扩容问题

⼀般做法是先读出历史数据，然后按指定的分⽚规则再将数据写⼊到各个分⽚节点中。此外还需要根据当前的数据量和 QPS，以及业务发展的速度，进⾏容量规划，推算出⼤概需要多少分⽚（⼀般建议单个分⽚上的单表数据量不超过1000W）。

4、什么时候考虑分片

（1）能不切分尽量不要切分，并不是所有表都需要进⾏切分，主要还是看数据的增⻓速度。分库分表之前，不要为分⽽分，先尽⼒去做⼒所能及的事情，例如：升级硬件、升级⽹络、读写分离、索引优化等等。当数据量达到单表的瓶颈时候，再考虑分库分表。

（2）数据量过⼤、增⻓过快，正常运维影响业务访问

（3）随着业务发展，需要对某些字段垂直拆分

（4）安全性和可⽤性：① 在业务层⾯上垂直切分，将不相关的业务的数据库分隔，因为每个业务的数据量、访问量都不同，不能因为⼀个业务把数据库搞挂⽽牵连到其他业务。② 利⽤⽔平切分，当⼀个数据库出现问题时，不会影响到100%的⽤户，每个库只承担业务的⼀部分数据，这样整体的可⽤性就能提⾼。

怎么写分库分表的组件

需要解决以下问题：

① 分⽚算法；② sql解析；③ sql路由；④ 数据聚合

六、MyCat 分库分表

Mycat是⼀个开源的分布式数据库系统，是⼀个实现了 MySQL 协议的的 Server。

前端⽤户可以把它看作是⼀个数据库代理，⽤ MySQL 客户端⼯具和命令⾏访问；

后端可以⽤MySQL 原⽣（Native）协议与多个 MySQL 服务器通信，也可以 ⽤ JDBC 协议与⼤多数主流数据库服务器通信。

其核⼼功能是分表分库，即将⼀个⼤表⽔平分割为 N 个⼩表，存储在后端数据库⾥。

官方文档：https://github.com/MyCATApache/Mycat-Server

常⻅应⽤场景:

① 单纯的读写分离，此时配置最为简单，⽀持读写分离，主从切换；

② 分表分库，对于超过 1000 万的表进⾏分⽚，最⼤⽀持 1000 亿的单表分⽚；

③ 多租户应⽤，每个应⽤⼀个库，但应⽤程序只连接 Mycat，从⽽不改造程序本身，实现多租户化。

SpringBoot+Mycat+MySQL实现分表分库

Mycat 已经帮我们在内部实现了路由的功能，我们只需要在 Mycat 中配置切分规则即可。对于开发者来说，我们就可以把 Mycat 看做是⼀个数据库。

步骤一：（jdk 运行环境）

Mycat 是使⽤ java 写的数据库中间件，所以要运⾏ Mycat 前要准备要jdk的环境，要求是 jdk1.7 以上的环境。

步骤二：下载解压

https://github.com/MyCATApache/Mycat-Server/releases

windows 系统搭建，则下载版本：Mycat-server-1.6.7.5-release-20200422133810-win.tar.gz

步骤三：修改配置文件

将 mycat/conf/schema.xml 文件内容修改为以下内容

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">

    <!-- 逻辑库配置，逻辑库名称为 TESTDB -->
    <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100">
        <!-- 逻辑表配置，逻辑表名为 user ，映射到两个数据库节点 dn01,dn02，切分规则为 rule1(在 rule.xml 配置文件配置) -->
        <table name="user" primaryKey="id" dataNode="dn01,dn02" rule="rule1" />
    </schema>

    <!-- 设置 dataNode 对应的数据库，及 mycat 连接的地址 dataHost -->
    <dataNode name="dn01" dataHost="dh01" database="db01" />
    <dataNode name="dn02" dataHost="dh01" database="db02" />

    <!-- mycat是逻辑主机 dataHost是对应的物理主机，并设置对应的mysql登录信息 -->
    <dataHost name="dh01" maxCon="1000" minCon="10" balance="0"
              writeType="0" dbType="mysql" dbDriver="native">
        <heartbeat>select user()</heartbeat>
        <writeHost host="server1" url="127.0.0.1:3306" user="root"
                   password="123465" />
    </dataHost>
</mycat:schema>

将 mycat/conf/rule.xml 文件内容修改为以下内容

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mycat:rule SYSTEM "rule.dtd">
<mycat:rule xmlns:mycat="http://io.mycat/">
    
    <tableRule name="rule1">
        <rule>
            <columns>id</columns>
            <algorithm>mod-long</algorithm>
        </rule>
    </tableRule>

    <!-- 定义具体的切分规则：按照 id 列进行切分，切分规则为 取模 -->
    <function name="mod-long"
              class="io.mycat.route.function.PartitionByMurmurHash">
        <property name="count">2</property><!-- 要分片的数据库节点数量，必须指定，否则没法分片 -->
    </function>

</mycat:rule>

步骤四：数据库配置

在数据库中创建两个 database： db01/db02，并在每个库中执行以下语句创建 user 表

CREATE TABLE USER(
    id bigint(20) NOT NULL,
    name varchar(255) DEFAULT NULL,
    PRIMARY KEY(id)
)ENGINE=innoDB DEFAULT CHARSET=utf8;

步骤五：搭建 SpringBoot 环境

① 配置 application.properties 文件

# 配置数据源
spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver
# 配置 mycat 中 server.xml 中配置的账号密码（非物理数据库的密码）
spring.datasource.druid.username=root
spring.datasource.druid.password=123456
# mycat 逻辑数据库地址
spring.datasource.druid.url=jdbc:mysql://localhost:8066/TESTDB

② 实体类 User.java

@Data
public class User {
    private int id;
    private String name;
}

③ UserMapper.java

@Mapper
@Repository
public interface UserMapper {

    @Insert("insert into user(id,name) value (#{id},#{name})")
    int insert(User user);

    @Select("select * from user")
    List<User> selectAll();
}

④ UserController.java

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserMapper userMapper;

    @RequestMapping("/save")
    public String save(User user) {
        userMapper.insert(user);
        return "保存成功";
    }

    @RequestMapping("/list")
    public List<User> list() {
        return userMapper.selectAll();
    }
}

⑤ 上面使用了 druid 所以需要添加依赖

<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.6</version>
        </dependency>

步骤六：启动 mycat

在 mycat/bin/ 目录下，双击 startup_nowrap.bat 文件启动 mycat。如果出现闪退的情况，则使用命令行 ./startup_nowrap.bat 运行，查看启动失败原因。

步骤七：测试

① 启动 SpringBoot 测试项目

② 在浏览器地址栏输入：

http://localhost:8080/user/save?id=101&name=tom

http://localhost:8080/user/save?id=102&name=jack

③ 查看数据：

http://localhost:8080/user/list

两条数据都成功入库

 ④ 查看数据库：

id=101 的数据插入到了数据库 db01 的 user 表中；

id=102 的数据插入到了数据库 db02 的 user 表中。

 自此 【SpringBoot+Mycat+MySQL实现分表分库 】测试完成