数据库中间件 Mycat（一）读写分离、分库分表

亦凉 2022-12-01 03:39 301阅读 0赞

**Table of Contents**

1.数据库中间件

2.Mycat介绍

3.Mycat 安装与使用(linux)

3.1下载

3.2解压后即可使用

3.3运行命令

3.4内存配置

4.Mycat配置

4.1修改配置文件server.xml

4.2修改配置文件 schema.xml

5.验证数据库访问情况

6.启动程序

7.登录

7.1登录后台管理窗口

7.2登录数据窗口

8.搭建读写分离

8.1搭建一主一从

8.2读写分离

8.3搭建双主双从

8.4双主双从读写分离

9.垂直拆分——分库

10.水平拆分——分表

10.1修改配置文件 schema.xml

10.2修改配置文件 rule.xml

10.3 在数据节点 dn2 上建 orders 表

10.4重启 Mycat 测试

11.分表后的“join”查询解决

11.1 ER Join

11.2 全局表

12.常用分片规则

12.1 取模

12.2 分片枚举

12.3 范围约定

12.4 按日期（天）分片

13.全局序列

13.1 本地文件

13.2  数据库方式

13.3 时间戳方式

13.4 自主生成全局序列

--------------------

## 1.数据库中间件 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70][]

## 2.Mycat介绍 ##

官网：

[http://mycat.org.cn/][http_mycat.org.cn]

[https://github.com/MyCATApache/Mycat-Server/wiki][https_github.com_MyCATApache_Mycat-Server_wiki]

Mycat 的原理中最重要的一个动词是“拦截”，它拦截了用户发送过来的 SQL 语句，首先对 SQL 语句做了 一些特定的分析：如分片分析、路由分析、读写分离分析、缓存分析等，然后将此 SQL 发往后端的真实数据库， 并将返回的结果做适当的处理，最终再返回给用户。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 1][]

当 Mycat 收到一个 SQL 时，会先解析这个 SQL，查找涉及到的表，然后看此表的定义，如果有分片规则， 则获取到 SQL 里分片字段的值，并匹配分片函数，得到该 SQL 对应的分片列表，然后将 SQL 发往这些分片去执 行，最后收集和处理所有分片返回的结果数据，并输出到客户端。以 select \* from Orders where prov=?语句为 例，查到 prov=wuhan，按照分片函数，wuhan 返回 dn1，于是 SQL 就发给了 MySQL1，去取 DB1 上的查询 结果，并返回给用户。

## 3.Mycat 安装与使用(linux) ##

### 3.1下载 ###

[https://github.com/MyCATApache/Mycat-download][https_github.com_MyCATApache_Mycat-download]

### 3.2解压后即可使用 ###

解压缩文件拷贝到  linux  下  /usr/local/

tar -zxvf Mycat-server-1.6-release-20190627191042-linux.tar.gz

![20200825172644713.png][]

### 3.3运行命令 ###

./mycat start 启动

./mycat stop 停止

./mycat console 前台运行

./mycat install 添加到系统自动启动（暂未实现）

./mycat remove 取消随系统自动启动（暂未实现）

./mycat restart 重启服务

./mycat pause 暂停

./mycat status 查看启动状态

### 3.4内存配置 ###

启动前，一般需要修改JVM配置参数，打开conf/wrapper.conf文件，如下行的内容为2G和2048，可根据本机配置情况修改为512M或其它值。 以下配置跟jvm参数完全一致，可以根据自己的jvm参数调整。

Java Additional Parameters

wrapper.java.additional.1=

wrapper.java.additional.1=-DMYCAT\_HOME=.

wrapper.java.additional.2=-server

wrapper.java.additional.3=-XX:MaxPermSize=64M

wrapper.java.additional.4=-XX:+AggressiveOpts

wrapper.java.additional.5=-XX:MaxDirectMemorySize=100m

wrapper.java.additional.6=-Dcom.sun.management.jmxremote

wrapper.java.additional.7=-Dcom.sun.management.jmxremote.port=1984

wrapper.java.additional.8=-Dcom.sun.management.jmxremote.authenticate=false

wrapper.java.additional.9=-Dcom.sun.management.jmxremote.ssl=false

wrapper.java.additional.10=-Xmx100m

wrapper.java.additional.11=-Xms100m

wrapper.java.additional.12=-XX:+UseParNewGC

wrapper.java.additional.13=-XX:+UseConcMarkSweepGC

wrapper.java.additional.14=-XX:+UseCMSCompactAtFullCollection

wrapper.java.additional.15=-XX:CMSFullGCsBeforeCompaction=0

wrapper.java.additional.16=-XX:CMSInitiatingOccupancyFraction=70

## 4.Mycat配置 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 2][]

--server.xml：是Mycat服务器参数调整和用户授权的配置文件。

--schema.xml：是逻辑库定义和表以及分片定义的配置文件。

--rule.xml：  是分片规则的配置文件，分片规则的具体一些参数信息单独存放为文件，也在这个目录下，配置文件修改需要重启MyCAT。

--log4j.xml： 日志存放在logs/log中，每天一个文件，日志的配置是在conf/log4j.xml中，根据自己的需要可以调整输出级别为debug                           debug级别下，会输出更多的信息，方便排查问题。

--autopartition-long.txt,partition-hash-int.txt,sequence\_conf.properties， sequence\_db\_conf.properties 分片相关的id分片规则配置文件

--lib        MyCAT自身的jar包或依赖的jar包的存放目录。

--logs        MyCAT日志的存放目录。日志存放在logs/log中，每天一个文件

### 4.1修改配置文件server.xml ###

修改用户信息，与MySQL区分，如下：

![20200825174441793.png][]

### 4.2修改配置文件 schema.xml ###

删除 <schema> 标签间的表信息，

<dataNode> 标签只留一个，

<dataHost> 标签只留一个，

<writeHost>  <readHost>只留一对

**se nu展示行号，dd删除一行，d2d删除两行**

<?xml version="1.0"?>
    <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
    <mycat:schema xmlns:mycat="http://io.mycat/">
    
            <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1" >
            </schema>
            
            <dataNode name="dn1" dataHost="host1" database="testdb" />
            <dataHost name="host1" maxCon="1000" minCon="10" balance="0"
                              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                    <heartbeat>select user()</heartbeat>
                    
                    <writeHost host="hostM1" url="192.168.71.128:3306" user="root"
                                       password="123456">
                            
                            <readHost host="hostS2" url="192.168.1.100:3306" user="root" password="123456" />
                    </writeHost>
            </dataHost>
    </mycat:schema>

## 5.验证数据库访问情况 ##

Mycat  作为数据库中间件要和数据库部署在不同机器上，所以要验证远程访问情况。

**mysql -uroot -p123123 -h 192.168.71.128 -P 3306**

**mysql -uroot -p123123 -h 192.168.1.100 -P 3306**

\# 如远程访问报错，请建对应用户

**指定ip主机访问数据的权限**

授权

grant all privileges on \*.\* to root@' 缺少的 host' identified by '123123';

修改立即生效

FLUSH PRIVILEGES ;

**虚拟机连接不上主机的数据库报错**

Can't connect to MySQL server on '192.168.0.100' (111)

**主机进行授权报错**

GRANT ALL PRIVILEGES ON \*.\* TO 'root'@'192.168.71.128' IDENTIFIED BY '123456';

错误代码： 1064  
You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'IDENTIFIED BY '123456'' at line 1

原因：主机的mysql版本为8.0，授权不支持：GRANT ALL PRIVILEGES ON \*.\* TO 'root'@'192.168.71.128' IDENTIFIED BY '123456';

需拆分（主机执行）：

CREATE USER 'root'@'192.168.71.128' IDENTIFIED BY '123456';

GRANT ALL PRIVILEGES ON \*.\* TO 'root'@'192.168.71.128' WITH GRANT OPTION;

## 6.**启动程序**  ##

启动方式看前面运行命令【3.运行命令】

①控制台启动 ：去 mycat/bin  目录下执行  ./mycat console

②后台启动 ：去  mycat/bin  目录下  ./mycat start

为了能第一时间看到启动日志，方便定位问题，我们选择①控制台启动。

![20200825190041188.png][]

启动时可能出现报错：域名解析失败

①用 vim  修改  /etc/hosts  文件， 在  127.0.0.1  后面增加你的机器名

②修改后重新启动网络服务：service network restart

## 7.登录 ##

### 7.1登录后台管理窗口 ###

**此登录方式用于管理维护 Mycat**

mysql -umycat -p123456 -P9066 -h192.168.71.128

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 4][]

### 7.2登录数据窗口 ###

此登录方式用于通过  Mycat  查询数据，我们选择这种方式访问  Mycat

mysql -umycat -p123456 -P8066 -h192.168.71.128

## 8.搭建读写分离 ##

通过  Mycat  和  MySQL  的主从复制配合搭建数据库的读写分离，实现  MySQL  的高可用性。

###    8.1搭建一主一从 ###

主机处理所有写请求，从机负责所有读请求，架构图如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 5][]

**搭建**  **MySQL**  **数据库主从复制**

①  MySQL  主从复制原理

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 6][]

② 主机配置( **192.168.71.128:13306** )

#修改配置文件：vim /etc/my.cnf  (docker安装的db,vim/etc/mysql/my.cnf)
    [mysqld]
    #主服务器唯一ID
    server-id=1
    #启用二进制日志
    log-bin=mysql-bin
    # 设置不要复制的数据库(可设置多个)
    binlog-ignore-db=mysql
    binlog-ignore-db=information_schema
    #设置需要复制的数据库
    binlog-do-db=需要复制的主数据库名字
    #设置logbin格式
    binlog_format=STATEMENT

binlog  日志三种格式

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 7][]

![20200826131536347.png][]

③ 从机配置( **192.168.71.128:23306** )

注意：由于之前的8.0的数据库192.168.1.100在windows系统，这里换成了5.7的**192.168.71.128:23306，前面的对应mycat的配置需修改。**

#改配置文件：vim /etc/my.cnf   (docker安装的db,vim/etc/mysql/my.cnf)
    [mysqld]
    #从服务器唯一ID
    server-id=2
    #启用中继日志
    relay-log=mysql-relay

![20200826131554362.png][]

④ 主机、从机重启  MySQL  服务

⑤ 主机从机都关闭防火墙

⑥ 在主机上建立帐户并授权  slave

\# 在主机 MySQL 里执行授权命令

GRANT REPLICATION SLAVE ON *.* TO 'slave'@'%' IDENTIFIED BY '123456';

\# 查询 master 的状态

show master status;

![20200826132326899.png][]

\# 记录下 File 和 Position 的值

\# 执行完此步骤后不要再操作主服务器 MySQL ，防止主服务器状态值变化

⑦ 在从机上配置需要复制的主机

#如果之前挂载过主机，需重置
    STOP SLAVE;
    RESET MASTER;
    
    #复制主机的命令
    CHANGE MASTER TO MASTER_HOST='192.168.71.128',
    MASTER_USER='slave',
    MASTER_PASSWORD='123456',
    MASTER_PORT=13306,
    MASTER_LOG_FILE='mysql-bin.000001',
    MASTER_LOG_POS=430;
    
    #启动从服务器复制功能
    START SLAVE;
    
    #查看从服务器状态
    SHOW SLAVE STATUS;

![20200826144322291.png][]

\#上 面两个参数都是 Yes ，则说明主从配置成功！

⑧ 主机新建库、新建表、 insert  记录，从机会复制

主机新建testdb数据库，从机会生成testdb

⑨ 如何停止从服务复制功能

stop slave;

⑩ 如何重新配置主从

stop slave;

reset master;

### 8.2读写分离 ###

①验证是否读写分离

SELECT @@hostname;

13306主机：

![20200826151656335.png][]

23306从机：

![20200826151658803.png][]

在13306主机 插入带系统变量数据，造成主从数据不一致 ：

insert into user(name) values (@@hostname);

![20200826152228553.png][]

23306从机的数据：

![20200826152245831.png][]

在 Mycat 里查询： select \* from user;

![20200826152433864.png][]

主从主机数据不一致了，查询是主机的数据。

原因：balance=“0“

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 8][]

②修改<dataHost>的balance属性，通过此属性配置读写分离的类型

负载均衡类型，目前的取值有4 种：

（1）balance="0", 不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上。
    （2）balance="1"，全部的 readHost 与 stand by writeHost 参与 select 语句的负载均衡，简单的说，当双主双从
    模式(M1->S1，M2->S2，并且 M1 与 M2 互为主备)，正常情况下，M2,S1,S2 都参与 select 语句的负载均衡。
    （3）balance="2"，所有读操作都随机的在 writeHost、readhost 上分发。
    （4）balance="3"，所有读请求随机的分发到 readhost 执行，writerHost 不负担读压力

故：一主一从应配置为 3，多主多从应配置为 1.

重启mycat即可

### 8.3搭建双主双从 ###

一个主机  m1  用于处理所有写请求，它的从机  s1  和另一台主机  m2  还有它的从机  s2  负责所有读请

求。当  m1  主机宕机后， m2  主机负责写请求， m1 、 m2  互为备机。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 9][]

<table> 
 <tbody> 
  <tr> 
   <td style="width:76px;"><span style="color:#000000;">编号</span></td> 
   <td style="width:214px;"><span style="color:#000000;">角色</span></td> 
   <td style="width:272px;"><span style="color:#000000;">IP 地址</span></td> 
   <td style="width:237px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:76px;">1</td> 
   <td style="width:214px;"><span style="color:#000000;">Master1</span></td> 
   <td style="width:272px;">192.168.71.128:13306</td> 
   <td style="width:237px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:76px;">2</td> 
   <td style="width:214px;"><span style="color:#000000;">Slave1</span></td> 
   <td style="width:272px;">192.168.71.128:23306</td> 
   <td style="width:237px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:76px;">3</td> 
   <td style="width:214px;"><span style="color:#000000;">Master2</span></td> 
   <td style="width:272px;">192.168.71.128:13307</td> 
   <td style="width:237px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:76px;">4</td> 
   <td style="width:214px;"><span style="color:#000000;">Slave2</span></td> 
   <td style="width:272px;">192.168.71.128:23307</td> 
   <td style="width:237px;">&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

![20200826160533950.png][]

①把前面的13306和23306的主从删除，并删除testdb

②分别修改my.cnf

Master1(13306)

[mysqld]
    #主服务器唯一ID
    server-id=1
    #启用二进制日志
    log-bin=mysql-bin
    # 设置不要复制的数据库(可设置多个)
    binlog-ignore-db=mysql
    binlog-ignore-db=information_schema
    #设置需要复制的数据库
    binlog-do-db=testdb
    #设置logbin格式
    binlog_format=STATEMENT
    # 在作为从数据库的时候，有写入操作也要更新二进制日志文件
    log-slave-updates
    #表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1，取值范围是1 .. 65535
    auto-increment-increment=2
    # 表示自增长字段从哪个数开始，指字段一次递增多少，他的取值范围是1 .. 65535
    auto-increment-offset=1

Master2(13307)

[mysqld]
    #主服务器唯一ID
    server-id=3
    #启用二进制日志
    log-bin=mysql-bin
    # 设置不要复制的数据库(可设置多个)
    binlog-ignore-db=mysql
    binlog-ignore-db=information_schema
    #设置需要复制的数据库
    binlog-do-db=testdb
    #设置logbin格式
    binlog_format=STATEMENT
    # 在作为从数据库的时候，有写入操作也要更新二进制日志文件
    log-slave-updates
    #表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1，取值范围是1 .. 65535
    auto-increment-increment=2
    # 表示自增长字段从哪个数开始，指字段一次递增多少，他的取值范围是1 .. 65535
    auto-increment-offset=2

Slave1(23306)

[mysqld]
    #从服务器唯一ID
    server-id=2
    #启用中继日志
    relay-log=mysql-relay

Slave2(23307)

[mysqld]
    #从服务器唯一ID
    server-id=4
    #启用中继日志
    relay-log=mysql-relay

③重启 mysql 服务、检查防火墙

④在两台主机上建立帐户并授权 slave 并查询主机状态

GRANT REPLICATION SLAVE ON *.* TO 'slave'@'%' IDENTIFIED BY '123456';

![20200826181615946.png][]

SHOW MASTER STATUS;

Master1(13306)

![20200826181754659.png][]

Master2(13307)

![20200826181920928.png][]

\# 分别记录下 File 和 Position 的值

\# 执行完此步骤后不要再操作主服务器 MYSQL ，防止主服务器状态值变化

⑤在从机上配置需要复制的主机

Slave1(23306)

#如果之前挂载过主机，需重置
    STOP SLAVE;
    RESET MASTER;
     
    #复制主机的命令
    CHANGE MASTER TO MASTER_HOST='192.168.71.128',
    MASTER_USER='slave',
    MASTER_PASSWORD='123456',
    MASTER_PORT=13306,
    MASTER_LOG_FILE='mysql-bin.000002',
    MASTER_LOG_POS=324;
     
    #启动从服务器复制功能
    START SLAVE;
     
    #查看从服务器状态
    SHOW SLAVE STATUS;

Slave2(23307)

#如果之前挂载过主机，需重置
    STOP SLAVE;
    RESET MASTER;
     
    #复制主机的命令
    CHANGE MASTER TO MASTER_HOST='192.168.71.128',
    MASTER_USER='slave',
    MASTER_PASSWORD='123456',
    MASTER_PORT=13307,
    MASTER_LOG_FILE='mysql-bin.000001',
    MASTER_LOG_POS=154;
     
    #启动从服务器复制功能
    START SLAVE;
     
    #查看从服务器状态
    SHOW SLAVE STATUS;

⑥两个主机互相复制

Master1(13306)

#复制主机的命令
    CHANGE MASTER TO MASTER_HOST='192.168.71.128',
    MASTER_USER='slave',
    MASTER_PASSWORD='123456',
    MASTER_PORT=13307,
    MASTER_LOG_FILE='mysql-bin.000001',
    MASTER_LOG_POS=154;
     
    #启动从服务器复制功能
    START SLAVE;
     
    #查看从服务器状态
    SHOW SLAVE STATUS;

Master2(13307)

#复制主机的命令
    CHANGE MASTER TO MASTER_HOST='192.168.71.128',
    MASTER_USER='slave',
    MASTER_PASSWORD='123456',
    MASTER_PORT=13306,
    MASTER_LOG_FILE='mysql-bin.000002',
    MASTER_LOG_POS=324;
     
    #启动从服务器复制功能
    START SLAVE;
     
    #查看从服务器状态
    SHOW SLAVE STATUS;

⑦Master1 主机新建库、新建表、insert 记录，Master2 和从机都会复制。

### 8.4双主双从读写分离 ###

修改 mycat    schema.xml

负载均衡类型，目前的取值有4 种：

#writeType="0": 所有写操作发送到配置的第一个writeHost，第一个挂了切到还生存的第二个
    #writeType="1"，所有写操作都随机的发送到配置的 writeHost，1.5 以后废弃不推荐
    #writeHost，重新启动后以切换后的为准，切换记录在配置文件中:dnindex.properties 。 
    #switchType="1": 1 默认值，自动切换。
    #               -1 表示不自动切换
    #                2 基于 MySQL 主从同步的状态决定是否切换。

<?xml version="1.0"?>
    <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
    <mycat:schema xmlns:mycat="http://io.mycat/">
     
            <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1" >
            </schema>
            
            <dataNode name="dn1" dataHost="host1" database="testdb" />
            <dataHost name="host1" maxCon="1000" minCon="10" balance="1"
                              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                    <heartbeat>select user()</heartbeat>
                    
                    <writeHost host="hostM1" url="192.168.71.128:13306" user="root"
                                       password="123456">
                            
                            <readHost host="hostS1" url="192.168.71.128:23306" user="root" password="123456" />
                    </writeHost>
                    <writeHost host="hostM2" url="192.168.71.128:13307" user="root"
                                       password="123456">
                            
                            <readHost host="hostS2" url="192.168.71.128:23307" user="root" password="123456" />
                    </writeHost>
            </dataHost>
    </mycat:schema>

**重启mycat测试**

验证：Master1、Master2 互做备机，负责写的主机宕机，备机切换负责写操作，保证数据库读写分离高

可用性。

1.mycat中插入数据，只会查询 M2、S1、S2，M1只写操作。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 10][]

根据M1中的数据查询不到

![202008262327440.png][]

2.关闭M1，会切换到 M2为写主机，mycat中写入数据只有存在M2、S2

3.启动M1后，前面写的数据会同步到M1和S1，且M1为读的主机。

根据查询条件，M1中可以查询到，M2查询不到

![20200826233147304.png][]

## 9.垂直拆分——分库 ##

原则：有紧密关联关系的表应该在一个库里，相互没有关联关系的表可以分到不同的库里。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 11][]

#客户表
    CREATE TABLE customer(
     id INT AUTO_INCREMENT,
     NAME VARCHAR(200),
     PRIMARY KEY(id)
    );
    #订单表
    CREATE TABLE orders(
     id INT AUTO_INCREMENT,
     order_type INT,
     customer_id INT,
     amount DECIMAL(10,2),
     PRIMARY KEY(id)); 
    #订单详细表
    CREATE TABLE orders_detail(
     id INT AUTO_INCREMENT,
     detail VARCHAR(2000),
     order_id INT,
     PRIMARY KEY(id)
    );
    #订单状态字典表
    CREATE TABLE dict_order_type(
     id INT AUTO_INCREMENT,
     order_type VARCHAR(200),
     PRIMARY KEY(id)
    );

客户表分在一个数据库：13306数据库orders

另外三张都需要关联查询，分在另外一个数据库：13307数据库orders

**修改 schema ****配置文件**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 12][]

<?xml version="1.0"?>
    <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
    <mycat:schema xmlns:mycat="http://io.mycat/">
     
            <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1" >
              <table name="customer" dataNode="dn2" ></table>
            </schema>
            <dataNode name="dn1" dataHost="host1" database="orders" />
            <dataNode name="dn2" dataHost="host2" database="orders" />
            <dataHost name="host1" maxCon="1000" minCon="10" balance="0"
                              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                    <heartbeat>select user()</heartbeat>
                    
                    <writeHost host="hostM1" url="192.168.71.128:13306" user="root"
                                       password="123456">
                    </writeHost>
            </dataHost>
            <dataHost name="host2" maxCon="1000" minCon="10" balance="0"
                              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                    <heartbeat>select user()</heartbeat>
                    <writeHost host="hostM2" url="192.168.71.128:13307" user="root"
                                       password="123456">
                    </writeHost>
            </dataHost>
    </mycat:schema>

**在数据节点 dn1、dn2 上分别创建数据库 orders**

CREATE DATABASE orders;

重启mycat，执行上面建表语句

结果：

13306数据库orders：只创建customer表

13307数据库orders：创建其他三个表

## 10.水平拆分——分表 ##

按照数据行的切分，将表中的某些行切分 到一个数据库，而另外的某些行又切分到其他的数据库中。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 13][]

**针对订单表，可根据customer\_id（客户 id） 去分，两个节点访问平均，一个客户的所**

**有订单都在同一个节点。**

### 10.1修改配置文件 schema.xml ###

为 orders 表设置数据节点为 dn1、dn2，并指定分片规则为 mod\_rule（自定义的名字），

选择分片算法 mod-long（对字段求模运算），customer\_id 对两个节点求模，根据结果分片

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 14][]

### 10.2修改配置文件 rule.xml ###

在 rule 配置文件里新增分片规则 mod\_rule，并指定规则适用字段为 customer\_id

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 15][]

配置算法 mod-long 参数 count 为 2，两个节点

![2020082715102834.png][]

### 10.3 在数据节点 dn2 上建 orders 表 ###

到13307数据库执行

CREATE TABLE orders(
     id INT AUTO_INCREMENT,
     order_type INT,
     customer_id INT,
     amount DECIMAL(10,2),
     PRIMARY KEY(id));

### 10.4重启 Mycat 测试 ###

#在 mycat 插入数据，表字段不能省略，因为mycat要根据字段customer_id分片
     
    INSERT INTO orders(id,order_type,customer_id,amount) VALUES (1,101,100,100100);
    INSERT INTO orders(id,order_type,customer_id,amount) VALUES(2,101,100,100300);
    INSERT INTO orders(id,order_type,customer_id,amount) VALUES(3,101,101,120000);
    INSERT INTO orders(id,order_type,customer_id,amount) VALUES(4,101,101,103000);
    INSERT INTO orders(id,order_type,customer_id,amount) VALUES(5,102,101,100400);
    INSERT INTO orders(id,order_type,customer_id,amount) VALUES(6,102,100,100020);

![20200827152802102.png][]

**13306**

![20200827152842138.png][]

**13307**

![20200827152848679.png][]

## 11.分表后的“join”查询解决 ##

Mycat 目前版本支持跨分片的 join，主要实现的方式有四种：**全局表，ER 分片**，catletT(人工智能)和 ShareJoin，ShareJoin 在开发版中支持，前面三种方式 1.3.0.1 支持。

Orders 订单表已经进行分表操作了，和它关联的 orders\_detail 订单详情表只存在13306机器，此时进行 join 查询会报错。因此要对 orders\_detail 也要进行分片操作。Join 的原理如下图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 16][]

### 11.1 ER Join ###

MyCAT 借鉴了 NewSQL 领域的新秀 Foundation DB 的设计思路，Foundation DB 创新性的提出了 Table

Group 的概念，其将子表的存储位置依赖于主表，并且物理上紧邻存放，因此彻底解决了 JION 的效率和性能问

题，根据这一思路，提出了基于 E-R 关系的数据分片策略，子表的记录与所关联的父表记录存放在同一个数据分

片上。

**修改 schema.xml 配置文件**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 17][]

**在 dn2 创建 orders\_detail 表**

CREATE TABLE orders_detail(
     id INT AUTO_INCREMENT,
     detail VARCHAR(2000),
     order_id INT,
     PRIMARY KEY(id)
    );

**重启 Mycat**

**访问 Mycat 向 orders\_detail 表插入数据**

INSERT INTO orders_detail(id,detail,order_id) values(1,'detail1',1);
    INSERT INTO orders_detail(id,detail,order_id) VALUES(2,'detail1',2);
    INSERT INTO orders_detail(id,detail,order_id) VALUES(3,'detail1',3);
    INSERT INTO orders_detail(id,detail,order_id) VALUES(4,'detail1',4);
    INSERT INTO orders_detail(id,detail,order_id) VALUES(5,'detail1',5);
    INSERT INTO orders_detail(id,detail,order_id) VALUES(6,'detail1',6);

**在mycat、dn1、dn2中运行两个表join语句**

Select o.*,od.detail from orders o inner join orders_detail od on o.id=od.order_id;

![20200827160313135.png][]

### 11.2 全局表 ###

一个真实的业务系统中，往往存在大量的类似字典表的表格，它们与业务表之间可能有关系，这种关系，可  
以理解为“标签”，而不应理解为通常的“主从关系”，这些表基本上很少变动，可以根据主键 ID 进行缓存，下  
面这张图说明了一个典型的“标签关系”图：

![20200827160911240.png][]

在分片的情况下，当业务表因为规模而进行分片以后，业务表与这些附属的字典表之间的关联，就成了比较

棘手的问题，考虑到字典表具有以下几个特性：

1.   变动不频繁
2.  数据量总体变化不大
3.  数据规模不大，很少有超过数十万条记录。

鉴于此，MyCAT 定义了一种特殊的表，称之为“全局表”，全局表具有以下特性：

1.  全局表的插入、更新操作会实时在所有节点上执行，保持各个分片的数据一致性
2.  全局表的查询操作，只从一个节点获取
3.  全局表可以跟任何一个表进行 JOIN 操作

将字典表或者符合字典表特性的一些表定义为**全局表**，则从另外一个方面，很好的解决了数据 JOIN 的难题。

通过全局表+基于 E-R 关系的分片策略，MyCAT 可以满足 80%以上的企业应用开发。

**修改 schema.xml 配置文件**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 18][]

**在 dn2 创建 dict\_order\_type 表**

CREATE TABLE dict_order_type(
     id INT AUTO_INCREMENT,
     order_type VARCHAR(200),
     PRIMARY KEY(id)
    );

**重启 Mycat**

**访问 Mycat 向 dict\_order\_type 表插入数据**

INSERT INTO dict_order_type(id,order_type) VALUES(101,'type1');
    INSERT INTO dict_order_type(id,order_type) VALUES(102,'type2');

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 19][]

## 12.常用分片规则 ##

### 12.1 取模 ###

此规则为对分片字段求摸运算。也是水平分表最常用规则。前面的配置orders分表中采用了此规  
则。

###    12.2 分片枚举 ###

通过在配置文件中配置可能的枚举 id，自己配置分片，本规则适用于特定的场景，比如有些业务  
需要按照省份或区县来做保存，而全国省份区县固定的，这类业务使用本条规则。

\#（1）修改schema.xml配置文件

\#（2）修改rule.xml配置文件

<tableRule name="sharding_by_intfile">
     <rule>
     <columns>areacode</columns>
     <algorithm>hash-int</algorithm>
     </rule>
     </tableRule>
    
    
    
    
    
    <function name="hash-int"
     class="io.mycat.route.function.PartitionByFileMap">
     <property name="mapFile">partition-hash-int.txt</property>
     <property name="type">1</property>
     <property name="defaultNode">0</property>
     </function>

\# columns：分片字段，algorithm：分片函数

\# mapFile：标识配置文件名称，type：0为int型、非0为String【即areacode的类型】

\#defaultNode：默认节点:小于 0 表示不设置默认节点，大于等于 0 表示设置默认节点，设置默认节点如果碰到不识别的枚举值，就让它路由到默认节点，如不设置不识别就报错

\#（3）修改partition-hash-int.txt配置文件  
110=0  
120=1

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 20][]  
\#（4）重启 Mycat  
\#（5）访问Mycat创建表  
\#订单归属区域信息表

CREATE TABLE orders_ware_info
    (
     `id` INT AUTO_INCREMENT comment '编号',
     `order_id` INT comment '订单编号',
     `address` VARCHAR(200) comment '地址',
    `areacode` VARCHAR(20) comment '区域编号',
    PRIMARY KEY(id)
    );

\#（6）插入数据

INSERT INTO orders_ware_info(id, order_id,address,areacode) VALUES (1,1,'北京','110');
    INSERT INTO orders_ware_info(id, order_id,address,areacode) VALUES (2,2,'天津','120');

\#（7）查询Mycat、dn1、dn2可以看到数据分片效果

### 12.3 范围约定 ###

此分片适用于，提前规划好分片字段某个范围属于哪个分片。

\#（1）修改schema.xml配置文件

\#（2）修改rule.xml配置文件

<tableRule name="auto_sharding_long">
     <rule>
     <columns>order_id</columns>
     <algorithm>rang-long</algorithm>
     </rule>
     </tableRule>
    
    
    
    <function name="rang-long"
     class="io.mycat.route.function.AutoPartitionByLong">
     <property name="mapFile">autopartition-long.txt</property>
     <property name="defaultNode">0</property>
     </function>

\#（3）修改autopartition-long.txt配置文件

0-102=0

103-200=1

\#（4）重启 Mycat  
\#（5）访问Mycat创建表  
\# 支付信息表

CREATE TABLE payment_info
    (
     `id` INT AUTO_INCREMENT comment '编号',
     `order_id` INT comment '订单编号',
     `payment_status` INT comment '支付状态',
     PRIMARY KEY(id)
    );

\#（6）插入数据

INSERT INTO payment_info (id,order_id,payment_status) VALUES (1,101,0);
    INSERT INTO payment_info (id,order_id,payment_status) VALUES (2,102,1);
    INSERT INTO payment_info (id,order_id ,payment_status) VALUES (3,103,0);
    INSERT INTO payment_info (id,order_id,payment_status) VALUES (4,104,1);

\#（7）查询Mycat、dn1、dn2可以看到数据分片效果

### 12.4 按日期（天）分片 ###

此规则为按天分片。设定时间格式、范围

\#（1）修改schema.xml配置文件

\#（2）修改rule.xml配置文件

<tableRule name="sharding_by_date">
     <rule>
     <columns>login_date</columns>
     <algorithm>shardingByDate</algorithm>
     </rule>
     </tableRule>
    
    
    <function name="shardingByDate" class="io.mycat.route.function.PartitionByDate">
     <property name="dateFormat">yyyy-MM-dd</property>
     <property name="sBeginDate">2019-01-01</property>
     <property name="sEndDate">2019-01-04</property>
    <property name="sPartionDay">2</property> 
     </function>

\#dateFormat  ：日期格式

\#sBeginDate  ：开始日期

\#sEndDate ：结束日期 , 则代表数据达到了这个日期的分片后循环从开始分片插入

\#sPartionDay ：分区天数，即默认从开始日期算起，分隔 2 天一个分区，即当2019-01-01到2019-01-02【2天算】为第一个节点，2019-01-03到2019-01-04第二个节点，2019-01-05到2019-01-06又回到第一个节点，以此类推。

\#（3）重启 Mycat  
\#（4）访问Mycat创建表  
\# 用户信息表

CREATE TABLE login_info
    (
     `id` INT AUTO_INCREMENT comment '编号',
     `user_id` INT comment '用户编号',
     `login_date` date comment '登录日期',
     PRIMARY KEY(id)
    );

\#（5）插入数据

INSERT INTO login_info(id,user_id,login_date) VALUES (1,101,'2019-01-01');
    INSERT INTO login_info(id,user_id,login_date) VALUES (2,102,'2019-01-02');
    INSERT INTO login_info(id,user_id,login_date) VALUES (3,103,'2019-01-03');
    INSERT INTO login_info(id,user_id,login_date) VALUES (4,104,'2019-01-04');
    INSERT INTO login_info(id,user_id,login_date) VALUES (5,103,'2019-01-05');
    INSERT INTO login_info(id,user_id,login_date) VALUES (6,104,'2019-01-06');

\#（6）查询Mycat、dn1、dn2可以看到数据分片效果

## 13.全局序列 ##

在实现分库分表的情况下，数据库自增主键已无法保证自增主键的全局唯一。为此，Mycat 提供  
了全局 sequence，并且提供了包含本地配置和数据库配置等多种实现方式。目**前在分布式中大多使用雪花算法。**

###    13.1 本地文件 ###

此方式 Mycat 将 sequence 配置到文件中，当使用到 sequence 中的配置后，Mycat 会更新  
classpath 中的 sequence\_conf.properties 文件中 sequence 当前的值。  
① 优点：本地加载，读取速度较快  
② 缺点：抗风险能力差，Mycat 所在主机宕机后，无法读取本地文件。

### 13.2  数据库方式 ###

利用数据库一个表来进行计数累加。但是并不是每次生成序列都读写数据库，这样效率太低。  
Mycat 会预加载一部分号段到 Mycat 的内存中，这样大部分读写序列都是在内存中完成的。  
如果内存中的号段用完了 Mycat 会再向数据库要一次。

问：那如果 Mycat 崩溃了 ，那内存中的序列岂不是都没了？  
是的。如果是这样，那么 Mycat 启动后会向数据库申请新的号段，原有号段会弃用。  
也就是说如果 Mycat 重启，那么损失是当前的号段没用完的号码，但是不会因此出现主键重复

① 建库序列脚本

#在 dn1 上创建全局序列表
    CREATE TABLE MYCAT_SEQUENCE (NAME VARCHAR(50) NOT NULL,current_value INT NOT
    NULL,increment INT NOT NULL DEFAULT 100, PRIMARY KEY(NAME)) ENGINE=INNODB;
    
    #创建全局序列所需函数
    DELIMITER $$ 
    CREATE FUNCTION mycat_seq_currval(seq_name VARCHAR(50)) RETURNS VARCHAR(64)
    DETERMINISTIC 
    BEGIN
    DECLARE retval VARCHAR(64);
    SET retval="-999999999,null";
    SELECT CONCAT(CAST(current_value AS CHAR),",",CAST(increment AS CHAR)) INTO retval FROM
    MYCAT_SEQUENCE WHERE NAME = seq_name;
    RETURN retval;
    END $$
    DELIMITER ;
    DELIMITER $$
    CREATE FUNCTION mycat_seq_setval(seq_name VARCHAR(50),VALUE INTEGER) RETURNS 
    VARCHAR(64)
    DETERMINISTIC
    BEGIN
    UPDATE MYCAT_SEQUENCE
    SET current_value = VALUE
    WHERE NAME = seq_name;
    RETURN mycat_seq_currval(seq_name);
    END $$
    DELIMITER ;
    DELIMITER $$
    CREATE FUNCTION mycat_seq_nextval(seq_name VARCHAR(50)) RETURNS VARCHAR(64) 
    DETERMINISTIC
    BEGIN
    UPDATE MYCAT_SEQUENCE
    SET current_value = current_value + increment WHERE NAME = seq_name;
    RETURN mycat_seq_currval(seq_name);
    END $$
    DELIMITER ; 
    
    #初始化序列表记录
    INSERT INTO MYCAT_SEQUENCE(NAME,current_value,increment) VALUES ('ORDERS', 400000,
    100);

![20200827190019351.png][]

② 修改 Mycat 配置

\#修改sequence\_db\_conf.properties   
vim sequence\_db\_conf.properties  
\#意思是 ORDERS这个序列在dn1这个节点上，具体dn1节点是哪台机子，即如果实在dn2安装的，这里为dn2

![20200827190318847.png][]

\#修改server.xml  
vim server.xml  
\#全局序列类型：0-本地文件，1-数据库方式，2-时间戳方式。此处应该修改成1。

![20200827190537551.png][]

\#重启Mycat

③ 验证全局序列  
\#登录 Mycat，插入数据

insert into orders(id,amount,customer_id,order_type) values(next value for 
    MYCATSEQ_ORDERS,1000,101,102);

\#查询数据

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 21][]  
\#重启Mycat后，再次插入数据，再查询

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 22][]

### 13.3 时间戳方式 ###

全局序列ID= 64 位二进制 (42(毫秒)+5(机器 ID)+5(业务编码)+12(重复累加) 换算成十进制为 18 位数的  
long 类型，每毫秒可以并发 12 位二进制的累加。  
① 优点：配置简单  
② 缺点：18 位 ID 过长

### 13.4 自主生成全局序列 ###

可在 java 项目里自己生成全局序列，如下：

① 根据业务逻辑组合  
② 可以利用 redis 的单线程原子性 incr 来生成序列  
但，自主生成需要单独在工程中用 java 代码实现

# #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70]: /images/20221123/00a5c3a3275e481fb61640e521493010.png
[http_mycat.org.cn]: http://mycat.org.cn/
[https_github.com_MyCATApache_Mycat-Server_wiki]: https://github.com/MyCATApache/Mycat-Server/wiki
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 1]: /images/20221123/84ad196789ee438b9dec0041ea6193ea.png
[https_github.com_MyCATApache_Mycat-download]: https://github.com/MyCATApache/Mycat-download
[20200825172644713.png]: /images/20221123/b8effed4042e4d3498d91fc6a9feb872.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 2]: /images/20221123/1af48f7ebeb44100b4017cc4d221bcc0.png
[20200825174441793.png]: /images/20221123/3e77c45a6dc84213bbb522f64fa7f8cd.png
[20200825190041188.png]: /images/20221123/e92a022e122f4ead9b66bf1b8f7e8546.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 3]: /images/20221123/90742d626e494a9aafb14d2648d9818d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 4]: /images/20221123/1142285a45eb4d6cafe23d4d179779d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 5]: /images/20221123/3c0842af032047789dfb32688c30aebd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 6]: /images/20221123/b2e42e6dbdff4251836ad999789dec49.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 7]: /images/20221123/c4dfb921f2e244819119d08a208f559d.png
[20200826131536347.png]: /images/20221123/ea7d7cd473f74ed58dac4790eb1d3ca8.png
[20200826131554362.png]: /images/20221123/470923e2d7ac4904b63e2da9ff74712c.png
[20200826132326899.png]: /images/20221123/8fa9ba2995dc4c808188e3ef379ba357.png
[20200826144322291.png]: /images/20221123/6a4b11327d6a4fa3b29871638777f361.png
[20200826151656335.png]: /images/20221123/a2c2435ffded4921bbb6964897dad24e.png
[20200826151658803.png]: /images/20221123/d793dfc533874d5c83923d0b131bd7b7.png
[20200826152228553.png]: /images/20221123/74caeae7b2994360ad74b345f0b4901e.png
[20200826152245831.png]: /images/20221123/0939dffe019e4d5eb51240207856cdd7.png
[20200826152433864.png]: /images/20221123/d53d279b8ea24363ab534ca470b04da0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 8]: /images/20221123/ad6356127f63492bb62fec6d07648ff0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 9]: /images/20221123/4c252946faed46d9b46913bdc4d6682c.png
[20200826160533950.png]: /images/20221123/11ae2f4cc0884386b9ea7b6d5f7edb16.png
[20200826181615946.png]: /images/20221123/bd55ee48554244afbc2fbf21f7a797e8.png
[20200826181754659.png]: /images/20221123/ff7404861783455faea892a5a5dd1cd3.png
[20200826181920928.png]: /images/20221123/a16f247657354707b38d5dcd56bb729f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 10]: /images/20221123/34ee221e7b9c4b30a6843ca22bbbc158.png
[202008262327440.png]: /images/20221123/e5d4901e2d55420bbe8605a1828bafb2.png
[20200826233147304.png]: /images/20221123/6991df880f294a14be4a04f4971515f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 11]: /images/20221123/34d6b86289a44e2880e237dcd1f9563e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 12]: /images/20221123/270a666fa9474323ad54de70eb951133.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 13]: /images/20221123/6ca13b8970a74464ba57242ea1bd8996.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 14]: /images/20221123/e85d8ad78f8c43df926a5951159098b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 15]: /images/20221123/0fff91c8c240455697c0d73a3825232d.png
[2020082715102834.png]: /images/20221123/ebe11e6318bc480dab6e1001b03c0c12.png
[20200827152802102.png]: /images/20221123/1cfd66f513e3409a868ea9923d39b7f2.png
[20200827152842138.png]: /images/20221123/133d917d7d914d7c810c89ed7528f743.png
[20200827152848679.png]: /images/20221123/4600950d7d3b4df7a8f689ee27aaa0d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 16]: /images/20221123/48f87a655e16454e8f6785416a0bf32c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 17]: /images/20221123/4a6cefe56763437e9508d501530977db.png
[20200827160313135.png]: /images/20221123/ec9798fb30404643afaa25a58d6bd2ae.png
[20200827160911240.png]: /images/20221123/f6e097a5941144258f1d0bfe0cb984fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 18]: /images/20221123/44edfff45afc4e0b957015655c70ab8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 19]: /images/20221123/793a1b7fdfc2467ca5a6b3b1c9e0cee7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 20]: /images/20221123/bd61863e3ddd4335a5f7b84a6ddb1e75.png
[20200827190019351.png]: /images/20221123/18af4eea9fd141deadad5ccc3302065a.png
[20200827190318847.png]: /images/20221123/e24e9816cc654bb6a44a91e66954b5fc.png
[20200827190537551.png]: /images/20221123/569a5f5635634e9bbd1e15cb5b8d915f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 21]: /images/20221123/dc53099568554c48afea71fecc7c5e30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAzMjE5OQ_size_16_color_FFFFFF_t_70 22]: /images/20221123/071a89f00bae43328a0b04470537ec45.png