DBA MySQL MyCat中间件
MyCat简介
MyCat是目前最流行的基于Java语言编写的数据库中间件，是一个实现了MySQL协议的服务器，前端用户可以将它看做是一个数据库代理，用MySQL客户端工具和命令对其进行访问，其核心功能是分库分表，配合数据库的主从模式还可以实现读写分离。
它的后端不仅仅可以支持MySQL，还可以支持SQL Server、Oracle、DB2、PostgreSQL等主流数据库，并且还支持MongoDB这种新型的NoSQL存储方式。
在学习MyCat之前，我们先要了解一下为何要使用它，那么就得从下一小节的架构演变开始说起。
架构演变
单机时代
最早的时候，单机单服务，若服务器发生故障，则业务也会受到影响：
主从单活
有没有什么好的办法能够解决这种状况呢？主从复制诞生。
主从复制解决了单机提供服务的问题，从库数据和主库一模一样，主库宕机后从库顶上，但是每次主库发生故障后都需要手动进行切换，十分繁琐。
于是MHA诞生了，它可以检测主库宕机后让从库自动顶上，而且可以监听多组主从，十分的方便（缺点就是一次性服务）：
读写分离
看起来上面的方案已经十分完美了，但是三台服务器中只有一台提供对外服务，读写都在主库上，让硬件资源造成了极大的浪费，真正意义上的主库有难从库围观。
有没有什么方案能让主库只负责写，剩下的两个从库来处理读操作呢？
随之而来MySQL官方提供了一种读写分离的中间件，名为MysqlProxy，但是由于各方面原因使用的人较少，在前面的文章中我们介绍了一种更好的替代产品，第三方读写分离中间件Atlas。
现在，我们已经能成功解决硬件资源利用率低的问题：
分片集群
互联网的发展总是迅猛的，数据量级的提升是飞速的，如果仅用上面的架构来存储超大量级的数据，假如有6亿条数据，即使在有索引的情况下查询也会十分缓慢，因为主库和从库的数据都一致，不管从哪个节点上进行读取，速度都会非常慢。
有没有什么好的方案进行解决呢？有，我们可以将6亿数据拆成3份，再配以多个MHA架构节点进行分片处理，如下图所示，mycat中间件能够提供读写分离机制+数据分片策略，下图应该算是一个比较不错的解决方案：
如果分片1上的master挂掉之后，则分片1的slave将在MHA控制下自动顶替上，其他的分片组同理。
同时，如果用户发起的是读取操作，mycat中间件会根据分片策略在不同节点上从库中进行读取，如果是写入操作，则会根据分片策略在不同节点上的主库中进行写入。
MyCat切片
垂直拆分
将一个原本存储于单库上的数据存储在多库中。
如图所示：
原本应用对三个表的所有请求都只在一个库中完成，该库压力比较大。
通过垂直拆分，将这三个表拆成三个独立的库中存放，那么应用对不同表的操作其实就会分发到单独的库中进行处理。
但是无法解决单表数据量太大的问题。
水平拆分
将单表的数据拆分到多表中，如下图所示：
这样做的好处会提升单表的并发能力，且能提升磁盘I/O性能。
缺点是无法提供表连接查询。
MyCat概念
逻辑库
MyCat中定义的库，物理中并不存在，仅针对纵向切片提供的概念：
逻辑表
MyCat中定义的表，物理中并不存在，仅针对横向分片提供的概念：
主从搭建
规划配置
由于MHA服务需要多台虚拟机，所以这里演示不搭建上面的MHA架构，仅用最简单的1主1从配合mycat来进行读写分离和分库分表的应用。
地址规划如下：
Master : 192.168.1.120
Slave : 192.168.1.121
mysql安装
首先要在两台机器上安装mysql，先下载：
T > cd ~
T > wget https://downloads.mysql.com/archives/get/p/23/file/mysql-5.7.28-linux-glibc2.12-x86_64.tar.gz
下载完成后，进行解压操作：
T > tar -zxvf mysql-5.7.28-linux-glibc2.12-x86_64.tar.gz -C /usr/local
解压完成后重命名：
T > mv /usr/local/mysql-5.7.28-linux-glibc2.12-x86_64 /usr/local/mysql
进入/usr/local文件夹，创建数据文件目录和日志文件目录：
T > cd /usr/local/
T > mkdir -p logs
T > mkdir -p data
创建mysql用户和用户组：
T > groupadd mysql
T > useradd mysql -g mysql
修改权限：
T > chown -R mysql:mysql ./mysql
T > chown -R mysql:mysql ./data
T > chown -R mysql:mysql ./logs
设置配置文件
T > vim /etc/my.cnf
[mysqld]
user=mysql
server_id=2 # 主库改1，从库改2
port=3306
basedir=/usr/local/mysql
datadir=/usr/local/data
log_error=/usr/local/logs/mysqld.log
log_bin=/usr/local/logs/mysql_bin
binlog_format=row
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
slow_query_log=1
long_query_time=10
slow_query_log_file=/usr/local/logs/slow.log
log_queries_not_using_indexes
character-set-server=utf8mb4
collation-server=utf8mb4_general_ci
default-storage-engine=INNODB
socket=/tmp/mysql.sock
设置sys服务：
cat >/etc/systemd/system/mysqld.service <<EOF
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target
[Install]
WantedBy=multi-user.target
[Service]
User=mysql
Group=mysql
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/etc/my.cnf
LimitNOFILE = 5000
EOF
设置环境变量：
T > vim /etc/profile
export PATH=/usr/local/mysql/bin:$PATH
T > source /etc/profile
进行免密初始化：
T > mysqld --initialize-insecure
开启mysqld.service服务：
T > systemctl start mysqld.service
这一步骤仅在主库上执行，创建复制用户：
T > mysql -uroot -p -S /tmp/mysql.sock -e "GRANT REPLICATION SLAVE ON *.* TO repl@'192.168.1.%' IDENTIFIED BY '123'"
接下来的步骤是从库执行的，先登录mysql：
T > mysql -uroot -p -S /tmp/mysql.sock
然后是开启复制：
M > CHANGE MASTER TO MASTER_HOST='192.168.1.120',
MASTER_USER='repl',
MASTER_PASSWORD='123',
MASTER_PORT=3306,
MASTER_CONNECT_RETRY=10,
MASTER_AUTO_POSITION=1;
检查复制状态：
M > START SLAVE;
至此，普通的主从搭建完成了。
安装MyCat
java环境
由于我们只有一主一从，因此我打算在从库节点上安装MyCat。
需要在从库节点上先安装java环境：
T > yum install java -y
MyCat
趁着安装java环境的时间，我们看一看去哪里下载MyCat。
刚好，我准备下载1.6.7.6版本，也是目前比较新的一版，链接地址如下，通过wget直接下载就好。
T > cd ~
T > wget http://dl.mycat.org.cn/1.6.7.6/20201104174609/Mycat-server-1.6.7.6-test-20201104174609-linux.tar.gz
下载完成后，对其进行解压操作：
T > tar -zxvf Mycat-server-1.6.7.6-test-20201104174609-linux.tar.gz -C /usr/local/
解压完成后，可以查看该目录下具有一个mycat文件夹了：
T > cd /usr/local
T > ll | grep mycat
drwxr-xr-x 7 root root 85 3月 18 21:02 mycat
查看目录结构：
T > ls ./mycat
bin catlet conf lib logs version.txt
目录介绍：
- bin ：启动脚本
- conf ：配置文件
- catlet ：扩展功能
- lib ：MyCat及其依赖jar
- logs ：wrapper.log保存启动日志，mycat.log保存mycat的工作日志
server.xml
打开文件
server.xml主要用于定义了application链接MyCat中间件的用户，以及该链接用户对逻辑库表的权限方面配置。
使用vim编辑器，打开该文件，观察文件结构：
T > vim /usr/local/mycat/conf/server.xml
文件节选内容如下，略有改动：
<!DOCTYPE mycat:server SYSTEM "server.dtd">
<mycat:server xmlns:mycat="http://io.mycat/">
<system>
<property name="nonePasswordLogin">0</property> <!-- 0为需要密码登陆、1为不需要密码登陆 ,默认为0，设置为1则需要指定默认账户-->
<property name="ignoreUnknownCommand">0</property><!-- 0遇上没有实现的报文(Unknown command:),就会报错、1为忽略该报文，返回ok报文。 -->
<user name="root" defaultAccount="true">
<property name="password">123456</property>
<property name="schemas">TESTDB</property>
<property name="defaultSchema">TESTDB</property>
<!-- 表级 DML 权限设置 -->
<!--
<privileges check="false">
<schema name="TESTDB" dml="0110" >
<table name="tb01" dml="0000"></table>
<table name="tb02" dml="1111"></table>
</schema>
</privileges>
-->
</user>
<user name="user">
<property name="password">user</property>
<property name="schemas">TESTDB</property>
<property name="readOnly">true</property>
<property name="defaultSchema">TESTDB</property>
</user>
</mycat:server>
配置解读
其实该文件的配置项非常多，但是我们仅需关注上面的即可。
主要看这里：
<user name="root" defaultAccount="true">
<property name="password">123456</property>
<property name="schemas">TESTDB</property>
<property name="defaultSchema">TESTDB</property>
<!-- 表级 DML 权限设置 -->
<!--
<privileges check="false">
<schema name="TESTDB" dml="0110" >
<table name="tb01" dml="0000"></table>
<table name="tb02" dml="1111"></table>
</schema>
</privileges>
-->
</user>
<user name="user">
<property name="password">user</property>
<property name="schemas">TESTDB</property>
<property name="readOnly">true</property>
<property name="defaultSchema">TESTDB</property>
</user>
它定义了2个用户用于让application进行链接，并且密码也有所不同：
<user name="root" defaultAccount="true">
<property name="password">123456</property>
<user name="user">
<property name="password">user</property>
这两个用户默认链接的虚拟库都是TESTDB：
<property name="defaultSchema">TESTDB</property>
这两个用户拥有对该虚拟库不同的权限，其中user用户是只能读，而root用户没有进行定义，则是可读可写：
<user name="user">
<property name="readOnly">true</property>
接下来我们看一看root用户的DDL设置，注意它是注释了的：
# 权限为4位数，顺序如下：
# insert、update、select、delete
<!-- 表级 DML 权限设置 -->
<!--
<privileges check="false">
# TESTDB逻辑库权限：0110 则对该库不能插入，不能删除
<schema name="TESTDB" dml="0110" >
# 对tb01(这是个逻辑库，但真正的默认配置文件schema.xml中没有配置)
# 不能增删改查
<table name="tb01" dml="0000"></table>
# 对tb02则可以允许全部操作
<table name="tb02" dml="1111"></table>
</schema>
</privileges>
-->
schema.xml
打开文件
schema.xml主要定义MyCat中逻辑库与逻辑表对应的MySQL中物理库表的配置。
除此之外，还有读写分离以及分片规则等配置。
使用vim编辑器，打开该文件，观察文件结构：
T > vim /usr/local/mycat/conf/schema.xml
文件节选内容如下，略有改动：
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" randomDataNode="dn1">
<table name="customer" primaryKey="id" dataNode="dn1,dn2" rule="sharding-by-intfile" autoIncrement="true" fetchStoreNodeByJdbc="true">
</table>
</schema>
<dataNode name="dn1" dataHost="localhost1" database="db1" />
<dataNode name="dn2" dataHost="localhost1" database="db2" />
<dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
writeType="0" dbType="mysql" dbDriver="jdbc" switchType="1" slaveThreshold="100">
<heartbeat>select user()</heartbeat>
<writeHost host="hostM1" url="jdbc:mysql://localhost:3306" user="root"
password="root">
<readHost host="hostS1" url="jdbc:mysql://192.168.1.121:3306" user="root"
password="root">
</readHost>
</writeHost>
</dataHost>
</mycat:schema>
逻辑库表相关
下面这4个标签，是比较基础的4个配置标签：
| 标签 | 描述 |
|---|---|
| schema | 配置逻辑库，name与server.xml中schema对应 |
| table | 配置逻辑表 |
| dataNode | 配置逻辑表中有哪些物理库 |
| dataHost | 配置物理库的读写分离策略 |
schema标签
该标签为配置逻辑库的标签：
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" randomDataNode="dn1">
...
</schema>
主要属性如下：
-
name ：逻辑库名称，与server.xml中schema对应
-
checkSQLschema ：是否检测SQL语法中的schema信息，假如MyCat逻辑库名称为A，dataNode（分库的表）名称为B，如果该参数为false，则SQL查询语句为SELECT * FROM A.table;, 如果该参数为true，则查询语句为SELECT * FROM table;
-
sqlMaxLimit：如果MyCat在执行SQL查询时，没有指定limit子句，则自动添加并且值为100
table标签
table标签位于schema标签中，用于定义逻辑表：
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" randomDataNode="dn1">
<table name="customer" primaryKey="id" dataNode="dn1,dn2" rule="sharding-by-intfile" autoIncrement="true" fetchStoreNodeByJdbc="true">
</table>
</schema>
主要属性如下：
- name ：逻辑表名称
- dataNode ：物理数据库中的数据库名称，即指定当application请求读取虚拟表时，通过哪些物理库来找这张真实表
- rule ：分片规则，具体规则请参照rule.xml文件
dataNode标签
dataNode标签与table标签中的dataNode属性做对应，它的作用是指定一个真实的物理库，将多个物理库加入到逻辑库中，当application请求读取虚拟表时，通过哪些物理库来找这张真实表：
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" randomDataNode="dn1">
<table name="customer" primaryKey="id" dataNode="dn1,dn2" rule="sharding-by-intfile" autoIncrement="true" fetchStoreNodeByJdbc="true">
</table>
</schema>
<!-- 当application请求customer表是，可以通过db1库里找这张表，也可以通过db2库找这张表 -->
<dataNode name="dn1" dataHost="localhost1" database="db1" />
<dataNode name="dn2" dataHost="localhost1" database="db2" />
主要属性如下：
- name ：节点名称，是一个可以随意命名的逻辑名称，主要与schema标签或者table标签dataNode属性做对接
- dataHost ：与dataHost标签的name做对接，用于引用该库在复制集群中的配置信息等，如读写分离配置
- database ：指定指定逻辑表对应的真实表在哪个物理库下进行存放
dataHost标签
dataHost标签是与dataNode做对接，主要负责dataNode标签中物理库读写分离的相关事宜：
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" randomDataNode="dn1">
<table name="customer" primaryKey="id" dataNode="dn1,dn2" rule="sharding-by-intfile" autoIncrement="true" fetchStoreNodeByJdbc="true">
</table>
</schema>
<dataNode name="dn1" dataHost="localhost1" database="db1" />
<dataNode name="dn2" dataHost="localhost1" database="db2" />
<dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
writeType="0" dbType="mysql" dbDriver="jdbc" switchType="1" slaveThreshold="100">
....
</dataHost>
主要属性如下：
- name ： 主要与dataNode标签的dataHost参数做对接，用于提供复制集读写策略等配置给dataNode标签的物理数据库
- maxCon/minCon：最大链接数与最小链接数
- writeType ：0，所有写操作都发送到可用的writeHost上。1，所有写操作都随机的发送到readHost。2，所有写操作都随机的在writeHost、readHost上发。
- dbType ：数据库类型，mysql数据库
- dbDriver ：数据库驱动类型，native是MyCat自带的一种用于驱动MySQL的驱动程序
- banlance ：0，读操作都在写库中。1，当有多主多从的时候，主之间互为主从，mater1->slave1 master2->slave2 master1和master2互为主备，select会在slave1 master2 slave2随机调用。2，所有读操作将会在所有数据库中随机执行。3， 所有读操作将会在所有读数据库中执行
- switchType ：-1，表示不自动切换。1，表示自动切换，推荐使用。2，基于mysql主从同步状态切换
heartbeat标签
heartbeat标签位于dataHost标签中，用于MyCat对MySQL服务的心跳检测。
<dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
writeType="0" dbType="mysql" dbDriver="jdbc" switchType="1" slaveThreshold="100">
<heartbeat>select user()</heartbeat>
...
</dataHost>
writeHost标签
writeHost标签位于dataHost标签中，用于定义物理库在复制集群中写时的操作：
<dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
writeType="0" dbType="mysql" dbDriver="jdbc" switchType="1" slaveThreshold="100">
<writeHost host="hostM1" url="jdbc:mysql://localhost:3306" user="root"
password="root">
....
</writeHost>
</dataHost>
主要属性如下：
- host ：数据库命名
- url ： 数据库访问路径
- user ： 数据库访问用户名
- password ： 访问用户的密码
readHost标签
readHost标签位于writeHost标签中，用于定义物理库在复制集群中读时的操作：
<writeHost host="hostM1" url="jdbc:mysql://localhost:3306" user="root"
password="root">
<readHost host="hostS1" url="jdbc:mysql://192.168.1.121:3306" user="root"
password="root">
</readHost>
</writeHost>
主要属性如下：
- host ：数据库命名
- url ： 数据库访问路径
- user ： 数据库访问用户名
- password ： 访问用户的密码
配置图示
大量的文字描述是否感觉很心累？这里有一张图供你查看：
rule.xml
打开文件
rule.xml主要定义了分片规则。
使用vim编辑器，打开该文件，观察文件结构：
T > vim /usr/local/mycat/conf/rule.xml
文件节选内容如下，略有改动：
<!DOCTYPE mycat:rule SYSTEM "rule.dtd">
<mycat:rule xmlns:mycat="http://io.mycat/">
<tableRule name="rule1">
<rule>
<columns>id</columns>
<algorithm>func1</algorithm>
</rule>
</tableRule>
...
<function name="func1" class="io.mycat.route.function.PartitionByLong">
<property name="partitionCount">8</property>
<property name="partitionLength">128</property>
</function>
...
</mycat:rule>
tableRule标签
该标签定义分片规则以及分片列，如下所示：
<tableRule name="rule1">
<rule>
<columns>id</columns>
<algorithm>func1</algorithm>
</rule>
</tableRule>
name表示分片规则，内嵌rule表示详细规则
columns表示拆分列，algorithm表示分片函数
function标签
该标签定义了分片函数，如下所示：
<function name="func1" class="io.mycat.route.function.PartitionByLong">
<property name="partitionCount">8</property>
<property name="partitionLength">128</property>
</function>
name为函数本身，class为指定的分片算法具体类名
property表示该分片算法会用到的一些属性
MyCat前戏
用户创建
我们需要在复制集上创建一个用户，让MyCat通过该用户链接MySQL。
只需要在主库上做以下操作即可，用户名为root，密码也为root：
T > mysql -uroot -S /tmp/mysql.sock -e "GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' identified by 'root';"
从库由于已经搭建好了复制集，也会自动的复制该用户。
库表创建
我们创建一个名为db1的数据库，并且插入3条数据在里面，接下来在主库中操作：
T > mysql -uroot
M > CREATE DATABASE db1 CHARSET utf8mb4;
M > use db1;
M > CREATE TABLE t1(id INT PRIMARY KEY AUTO_INCREMENT COMMENT "主键",name CHAR(32) NOT NULL COMMENT "姓名");
M > INSERT INTO t1(name) VALUES("Jack"),("Ken"),("Tom");
管理命令
以下是MyCat的基础管理命令。
启动MyCat：
/usr/local/mycat/bin/mycat start
停止命令：
/usr/local/mycat/bin/mycat stop
重启命令：
/usr/local/mycat/bin/mycat restart
查看状态：
/usr/local/mycat/bin/mycat status
如何排错
MyCat的错误大多集中在启动时。
如发现服务启动不成功，则可以查看wrapper.log这个启动日志。
里面关键的错误信息都是使用中文编写，十分的方便。
读写分离
schema.xml配置
配置文件如下：
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" dataNode="dn1">
</schema>
<dataNode name="dn1" dataHost="mycatLocal1" database= "db1" />
<dataHost name="mycatLocal1" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1">
<heartbeat>select user()</heartbeat>
<writeHost host="hostM1" url="192.168.1.120:3306" user="root" password="root">
<readHost host="hostS1" url="192.168.1.121:3306" user="root" password="root" />
</writeHost>
</dataHost>
</mycat:schema>
-
balance=”0”, 不开启读写分离机制，所有读操作都发送到当前可用的writeHost上
-
balance=”1”，全部的readHost与stand by writeHost参与select语句的负载均衡
-
balance=”2”，所有读操作都随机的在writeHost、readhost上分发
-
balance=”3”， 所有读请求随机的分发到writeHost对应的readhost执行,writerHost 不负担读压力
功能测试
接下来启动MyCat：
/usr/local/mycat/bin/mycat start
<property name="serverPort">8066</property> <property name="managerPort">9066</property>
登录主库中，查看MyCat是否链接主库：
M > show processlist;
+----+------+---------------------+------+------------------+-------+---------
| Id | User | Host | db | Command | Time | State | Info |
+----+------+---------------------+------+------------------+-------+---------
| 5 | repl | 192.168.1.121:47766 | NULL | Binlog Dump GTID | 15897 | Master has sent all binlog to slave; waiting for more updates | NULL |
| 20 | root | 192.168.1.106:53245 | db1 | Sleep | 2347 | | NULL |
| 21 | root | localhost | NULL | Query | 0 | starting | show processlist |
使用Navicat链接MyCat中间件：
现在，我们对于物理库db1（逻辑库TESTDB）做了一个读写分离。
创建一个t2表，然后插入2条数据：
查看MyCat的mycat.log日志（太乱了，该兴趣的自己看吧）。
注意事项
在这个schema.xml的配置文件中，并没有配置虚拟表，而是直接指定了一个虚拟库，使用dataNode参数对其做了物理库的指定。
如果你用table虚拟表来指定dataNode的话，是无效的，这会导致MyCat打不开其中的任何表。
如我对配置文件中进行了下面的修改：
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100">
<table name="mycatTable001" dataNode="dn1"></table>
</schema>
在我测试时，发现打不开表，所以这是一个坑点吧：
另外，使用MyCat搭建读写分离，仅能针对某个数量的库进行读写分离（取决于虚拟库的dataNode参数），而不能针对全库。
相较于Atlas的全库读写分离，这一点希望能有所改进。
分库分表
垂直分库
因为节点的原因，所以我们这里不再进行试验而是进行演示操作。
假如我们本来有一个商城bazaar库，在里面存了orders、users、goods这3张表。
此时想对bazaar库中的3张表进行拆分，要怎么做呢？
如下图所示：
完美方案是MHA集群架构，总共需要9台服务器（如果不做MHA则3台足以），在各个MHA集群上的Master中添加bazaar库，并且在其中添加3张表：
server1 -> bazaar
server2 -> bazaar
server3 -> bazaar
server1 -> bazaar -> users
server2 -> bazaar -> orders
server3 -> bazaar -> goods
然后需要到schema.xml中进行配置：
<schema xmlns:mycat="http://io.mycat/">
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100">
<!-- 如果用户读写虚拟库TESTDB中的3个表中的任意一个 -->
<table name="users" dataNode="sh1" />
<table name="orders" dataNode="sh2" />
<table name="goods" dataNode="sh3" />
</schema>
<!-- 都会走以下的策略，如读取users表会在repSet1的bazaar库中查找 -->
<dataNode name="sh1" dataHost="repSet1" database="bazaar" />
<dataNode name="sh2" dataHost="repSet2" database="bazaar" />
<dataNode name="sh3" dataHost="repSet3" database="bazaar" />
<!-- users的读写配置 -->
<dataHost name="repSet1" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1">
<heartbeat>
select user()
</heartbeat>
<writeHost host="repMaster" url="192.168.1.110:3306" user="root" password="root">
<readHost host="repSlave" url="192.168.1.111:3306" user="root" password="root" />
</writeHost>
</dataHost>
<!-- orders的读写配置 -->
<dataHost name="repSet2" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1">
<heartbeat>
select user()
</heartbeat>
<writeHost host="repMaster" url="192.168.1.120:3306" user="root" password="root">
<readHost host="repSlave" url="192.168.1.121:3306" user="root" password="root" />
</writeHost>
</dataHost>
<!-- goods的读写配置 -->
<dataHost name="repSet3" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1">
<heartbeat>
select user()
</heartbeat>
<writeHost host="repMaster" url="192.168.1.130:3306" user="root" password="root">
<readHost host="repSlave" url="192.168.1.131:3306" user="root" password="root" />
</writeHost>
</dataHost>
</schema>
水平分表
我们继续对orders做一个水平分表。
同样的，如果该表中有6000万数据，我们需要将表分成3分，又要用到3个MHA集群。
在所有MHA集群主库上同样创建3个bazaar库：
server2 -> bazaar # 如果按照上面的策略继续往下做，就不用创建这个库了
server2_1 -> bazaar
server2_2 -> bazaar
并且在3个节点的bazaar库中，创建3个orders表：
server2 -> bazaar -> users # 如果按照上面的策略继续往下做，就不用创建这个库了
server2_1 -> bazaar -> orders
server2_2 -> bazaar -> goods
如下图所示：
然后需要到schema.xml中进行配置：
<schema xmlns:mycat="http://io.mycat/">
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100">
<!-- 如果用户读写虚拟库TESTDB中的3个表中的任意一个 -->
<table name="users" dataNode="sh1" />
<!-- orders指定分片策略，按照id进行分片 -->
<table name="orders" dataNode="sh2,sh4,sh5" rule="auto-sharding-long" />
<table name="goods" dataNode="sh3" />
</schema>
<!-- 都会走以下的策略，如要访问orders表，则由repSet2，4，5的bazaar中的3个orders表组成逻辑表 -->
<dataNode name="sh1" dataHost="repSet1" database="bazaar" />
<dataNode name="sh3" dataHost="repSet3" database="bazaar" />
<!-- orders水平拆分的集群与物理库 -->
<dataNode name="sh2" dataHost="repSet2" database="bazaar" />
<dataNode name="sh4" dataHost="repSet4" database="bazaar" />
<dataNode name="sh5" dataHost="repSet5" database="bazaar" />
<!-- 访问users，读写配置 -->
<dataHost name="repSet1" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1">
<heartbeat>
select user()
</heartbeat>
<writeHost host="repMaster" url="192.168.1.110:3306" user="root" password="root">
<readHost host="repSlave" url="192.168.1.111:3306" user="root" password="root" />
</writeHost>
</dataHost>
<!-- 访问goods，读写配置 -->
<dataHost name="repSet3" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1">
<heartbeat>
select user()
</heartbeat>
<writeHost host="repMaster" url="192.168.1.130:3306" user="root" password="root">
<readHost host="repSlave" url="192.168.1.131:3306" user="root" password="root" />
</writeHost>
</dataHost>
<!-- 访问orders，读写配置 -->
<!-- 水平分片1 -->
<dataHost name="repSet2" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1">
<heartbeat>
select user()
</heartbeat>
<writeHost host="repMaster" url="192.168.1.120:3306" user="root" password="root">
<readHost host="repSlave" url="192.168.1.121:3306" user="root" password="root" />
</writeHost>
</dataHost>
<!-- 水平分片2 -->
<dataHost name="repSet2" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1">
<heartbeat>
select user()
</heartbeat>
<writeHost host="repMaster" url="192.168.1.140:3306" user="root" password="root">
<readHost host="repSlave" url="192.168.1.141:3306" user="root" password="root" />
</writeHost>
</dataHost>
<!-- 水平分片3 -->
<dataHost name="repSet2" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1">
<heartbeat>
select user()
</heartbeat>
<writeHost host="repMaster" url="192.168.1.150:3306" user="root" password="root">
<readHost host="repSlave" url="192.168.1.151:3306" user="root" password="root" />
</writeHost>
</dataHost>
</schema>
至此，水平分表构建完成。
拆分策略
指定片键
我们以范围拆分为例，如果想指定拆分的键（上面是id），可以打开配置文件rule.xml中修改即可：
<tableRule name="auto-sharding-long">
<rule>
<columns>id</columns>
<algorithm>rang-long</algorithm>
</rule>
</tableRule>
常见拆分
针对拆分策略，有以下的几种常见的：
| 策略 | 描述 |
|---|---|
| auto-sharding-long | range，范围拆分 |
| mod-long | 取余 |
| sharding-by-intfile | 枚举 |
| hash | 哈希 |
| time | 时间 |
若想了解更多，可参见如下文章：
点我跳转
工作管理
基本概述
MyCat具有工作端口和管理端口之分。
工作端口号为8066，也是application链接的端口号。
管理端口号为9066，可对MyCat配置与节点等做出管控。
相关文章
由于篇幅原因，这里不再介绍，如果你感兴趣，可参见如下文章：
点我跳转
