MySQL数据库基础之主从复制/GTID主从复制/读写分离

一：主从复制原理

一、什么是主从复制?

主从复制，是用来建立一个和主数据库完全一样的数据库环境，称为从数据库；主数据库一般是准实时的业务数据库

二、主从复制的作用

1、做数据的热备，作为后备数据库，主数据库服务器故障后，可切换到从数据库继续工作，避免数据丢失。
2、架构的扩展。业务量越来越大，I/O访问频率过高，单机无法满足，此时做多库的存储，降低磁盘I/O访问的频率，提高 单个机器的I/O性能。
3、读写分离，使数据库能支撑更大的并发。

三、主从复制的原理

主和从服务器之间会通过两个进程实现主从复制.1是I/O:负责通信.2是SQL:负责写数据.把主服务器的内容写到从服务器上.根据我们bin-log日志去写.
1.数据库有个bin-log二进制文件，记录了所有sql语句。
2.我们的目标就是把主数据库的bin-log文件的sql语句复制过来。
3.让其在从数据的relay-log(中继日志)重做日志文件中再执行一次这些sql语句即可。

四：具体原理

1.binlog输出线程:每当有从库连接到主库的时候，主库都会创建一个线程然后发送binlog内容到从库。在从库里，当复制 开始的时候，从库就会创建两个线程进行处理：
2.从库I/O线程:当START SLAVE语句在从库开始执行之后，从库创建一个I/O线程，该线程连接到主库并请求主库发送 binlog里面的更新记录到从库上。从库I/O线程读取主库的binlog输出线程发送的更新并拷贝这些更新到本地文件，其中包 括relay log文件。
3.从库的SQL线程:从库创建一个SQL线程，这个线程读取从库I/O线程写到relay log的更新事件并执行。可以知道，对于 每一个主从复制的连接，都有三个线程。拥有多个从库的主库为每一个连接到主库的从库创建一个binlog输出线程，每一个 从库都有它自己的I/O线程和SQL线程。

五：一句话原理

从库slave生成两个线程，i/o线程和sql线程，i/o将变更记录写到二进制日志文件中，再写到中继日志中，sql线程 读取中继日志，解析操作，最终数据统一

左边的是主数据库,当主数据库数据变更的时候,会产生日志,记录到binlog二进制日志里面,然后右边的从服务器的I/O线程会去读取这个二进制日志的内容,并且I/O线程再写到中继日志Relaylog里,然后从数据库里的SQL线程会再读取这个中继日志的SQL语句进行重写,最后达成主从数据库的数据统一.

注意：
master 对外提供 负责写数据
slave 读master日志写到relay-log
I/O进程：负责通信
SQL进程：负责写数据，根据log日志写数据

二：主从复制部署

需要准备至少2台环境干净的服务器,必须都有MySQL,作为AB主从服务器.

AB复制
环境：MASTER原来没有旧数据
1.主从都关闭防火墙selinux
#/etc/init.d/iptables stop centos 6
#systemctl stop firewalld centos 7
#setenforce 0

2.主
谁是主 给谁提供账户
安装软件mysql mysql-server
配置：
#vim /etc/my.cnf
[mysqld]
log-bin = my1log
server-id = 1

创建账户：
mysql> grant all on . to ‘slave’@’%’ identified by ‘123’;
mysql> flush privileges;
（replication slave,reload,super）

重启服务：
#systemctl restart mysqld

查看bin_log日志文件的名称：
>show binlog events;
注意:如果不成功删除以前的binlog日志

replication slave：
拥有此权限可以查看从服务器，从主服务器读取二进制日志。

super权限：
允许用户使用修改全局变量的SET语句以及CHANGE MASTER语句

reload权限：
必须拥有reload权限，才可以执行flush [tables | logs | privileges]

3.从
安装软件
配置：
#vim /etc/my.cnf
[mysqld]
server-id = 2
log-bin = my2log //1.使用双主的时候必须写 2.使用gtid方式的ab复制

启动服务：
#systemctl restart mysqld

指定主服务器信息
>help change master to 查看从mysql编辑文件
CHANGE MASTER TO
MASTER_HOST=‘mysql-master-1.blackmed.cn/ip’,
MASTER_USER=‘slave’, //主服务器用户
MASTER_PASSWORD=‘big’,
MASTER_PORT=3306,
MASTER_LOG_FILE=‘master2-bin.001’, //日志文件
MASTER_LOG_POS=4, //日志位置
MASTER_CONNECT_RETRY=10; //默认尝试次数
>edit
>show master status 在主服务器查看日志文件

启动：
mysql>start slave;
mysql>show slave status \G
如果没成功：删除从的binlog重启服务

log_slave_updates参数：
当从库log_slave_updates参数没有开启时，从库的binlog不会记录来源于主库的操作记录。只有开启 log_slave_updates，从库binlog才会记录主库同步的操作日志
log_slave_updates=1 重启服务既可以

出现的问题整理：
问题：1.报uuid重复的错误。
方案：在/var/lib/mysql/里的auto.cnf里的uuid号修改。

主从复制演示

[root@localhost ~]# systemctl stop mysqld
[root@localhost ~]# rm -rf /var/lib/mysql/*
[root@localhost ~]# systemctl start mysqld
[root@localhost ~]# cat /var/log/mysqld.log | grep password
#如果不是全新干净的环境,老规矩,初始化数据库,重新设置密码.确保环境干净.
#并且AB两台服务器都能正常登陆进数据库.

然后开始做主从复制.
如果是用的虚拟机,切记关闭防火墙和SElinux.
systemctl stop firewalld

Master部署：

[root@mysql-tnt1 ~]# vi /etc/my.cnf
log-bin = my1log
server-id = 1
#开启binlog日志的功能.
#添加两行内容,第一个是binlog日志的名字,默认放在/var/lib/mysql里面
#serverid就是主从服务器的一个标识,用来区分主从服务器.把ID改不一样的就可以.

[root@mysql-tnt1 ~]# systemctl restart mysqld
#重启数据库.加载配置文件.

mysql> grant all privileges on *.* to slave@'%' identified by 'TNTnb@123';
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)
#服务器1进入主库.
#授权所有的库所有的表而且是所有的权限给账户slave.
#刷新.

Slave部署：

[root@mysql-tnt2 ~]# vi /etc/my.cnf
log-bin = my2log
server-id = 2
#同样第二台服务器也要开启binlog日志功能.
[root@mysql-tnt2 ~]# systemctl restart mysqld
#重启加载.

mysql> help change master to
CHANGE MASTER TO
  MASTER_HOST='master2.example.com',
  MASTER_USER='replication',
  MASTER_PASSWORD='password',
  MASTER_PORT=3306,
  MASTER_LOG_FILE='master2-bin.001',
  MASTER_LOG_POS=4,
  MASTER_CONNECT_RETRY=10;
#服务器2进入从库.进行建立与主库的链接.
#用help change master to这个指令查询一下内容.
#然后找到这些内容.这是主从复制,从服务器上需要执行的内容.
#上面内容的意思是.为了链接我们的master要去写的信息.因为从服务器要知道master是谁.从要去master上面获取信息.所以这个master的配置要在从库上进行修改.
mysql> edit
#由于上面的文件是断行的,我们可以用这个工具,类似于vim的编辑工具.然后把上面的那几行内容复制,然后运行这个命令,粘贴进去进行修改.
CHANGE MASTER TO
  MASTER_HOST='master2.example.com', 	//这里可以写主库的IP地址,或者域名.
  MASTER_USER='replication',			//主库授权的用户.
  MASTER_PASSWORD='password',		    //密码
  MASTER_PORT=3306,					   //端口
  MASTER_LOG_FILE='master2-bin.001',  //主库的binlog日志名称,进主库用show binlog events查看
  MASTER_LOG_POS=4,					  //主库的binlog日志为支点,同上查看.
  MASTER_CONNECT_RETRY=10;			  //链接尝试的次数.

CHANGE MASTER TO
  MASTER_HOST='192.168.10.130',
  MASTER_USER='slave',
  MASTER_PASSWORD='TNTnb@123',
  MASTER_PORT=3306,
  MASTER_LOG_FILE='my1log.000001',
  MASTER_LOG_POS=4,
  MASTER_CONNECT_RETRY=10;
  
mysql> edit
    -> ;
Query OK, 0 rows affected, 2 warnings (0.00 sec)
#修改后的内容.修改完之后保存退出.

mysql> start slave;
Query OK, 0 rows affected (0.01 sec)

mysql> show slave status\G
 Slave_IO_Running: Yes
 Slave_SQL_Running: Yes
#启动我们的从库服务.
#查看我们的从库状态.
#如果看到IO和SQL这两行是Yes,则代表主从复制完成了.接下来就是验证.

mysql> create database TNT;
Query OK, 1 row affected (0.00 sec)
mysql> create database TNT1;
Query OK, 1 row affected (0.00 sec)
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| TNT                |
| TNT1               |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
6 rows in set (0.00 sec)
#进入服务器1的主库,建一个或者两个库.
#这里要说明,主库和从库都是全新环境进行部署的.所以主库在创建这两个库之前主从数据库都是没有库的.

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| TNT                |
| TNT1               |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
6 rows in set (0.00 sec)
#然后进入服务器2的从库,查看库,会发现,同样也有两个库.
#这就是主从复制.你在主库上进行操作,从服务器上会进行一个复制的操作.

mysql> use TNT;
Database changed
mysql> create table t1(id int);
Query OK, 0 rows affected (0.02 sec)
#再进入到主库里面的TNT库里建立了一个t1的表,字段为id.

mysql> use TNT;
Database changed
mysql> show tables;
+---------------+
| Tables_in_TNT |
+---------------+
| t1            |
+---------------+
1 row in set (0.00 sec)
#换从库进入到TNT里同样也有一个t1.

三：GTID主从复制

M-S GTID 基于事务ID复制 ，主体流程和主从复制差不多。
说白了就是主服务器有一个唯一的server uuid.

GTID

全局事务标识：global transaction identifiers
是用来代替传统复制的方法，GTID复制与普通复制模式的最大不同就是不需要指定二进制文件名和位置，不再使用 MASTER_LOG_FILE+MASTER_LOG_POS开启复制。而是使用MASTER_AUTO_POSTION=1的方式开始复制。

MySQL-5.6.5开始支持的，MySQL-5.6.10后开始完善

在传统的slave端，binlog是不用开启的，但是在GTID中slave端的binlog是必须开启的，目的是记录执行过的GTID（强制）

GTID的组成

GTID = source_id:transaction_id

source_id源id：
用于鉴别原服务器，即mysql服务器唯一的server_uuid，由于GTID会传递到slave，所以也可以理解 为源ID。

transaction_id事务id：
为当前服务器上已提交事务的一个序列号，通常从1开始自增长的序列，一个数值对应一个事 务。

示例：
server_uuid，即3E11FA47-71CA-11E1-9E33-C80AA9429562，后面的23为transaction_id

3E11FA47-71CA-11E1-9E33-C80AA9429562:23
#冒号之前的是源id，冒号之后的是事务id，事务id从1开始自增.有1个事务提交1个,以此类推.最终GTID的组成就是这种.GTID主从复制就是利用它来进行.

GTID的工作原理

1、master更新数据时，会在事务前产生GTID，一同记录到binlog日志中。
2、slave端的i/o 线程将变更的binlog，写入到本地的relay log中。
3、sql线程从relay log中获取GTID，然后对比slave端的binlog是否有记录。
4、如果有记录，说明该GTID的事务已经执行，slave会忽略。
5、如果没有记录，slave就会从relay log中执行该GTID的事务，并记录到binlog。

GTID主从复制演示

同样要准备2台服务器.
部署前将服务器重新初始化.

# systemctl stop mysqld
# rm -rf /var/lib/mysql/*
# systemctl start mysqld
# grep password /var/log/mysqld.log
# mysqladmin -p’5ovl_*4WV0Ct’ password ‘(123123456)’
#两台都要做干净.

Master部署：

[root@mysql-tnt1 ~]# vi /etc/my.cnf
log-bin 
server-id=1 
gtid_mode = ON 
enforce_gtid_consistency=1
#主服务器1去修改配置文件.保存退出.
[root@mysql-tnt1 ~]# systemctl restart mysqld
#重启.

mysql> grant all privileges on *.* to slave@'%' identified by 'TNTnb@123';
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)
#主服务器1进库,同样需要进行授权.
#刷新授权表.退出
#这样主服务器1就配置好了.

Slave部署：

[root@mysql-tnt2 ~]# vi /etc/my.cnf
log-bin 
server-id=2 
gtid_mode = ON 
enforce_gtid_consistency=1 
master-info-repository=TABLE 
relay-log-info-repository=TABLE
relay_log_recovery = on
#加入这几行参数.打开gtid功能
#master-info-repository和relay-log-info-repository，这两个参数会将master.info和relay.info保存在表中，默认是Myisam引擎，官方建议用
[root@mysql-tnt2 ~]# systemctl restart mysqld
#重启,加载配置文件.

mysql> edit
#change master to 
#master_host='master1', 
#master_user='授权用户', 
#master_password='授权密码',
#master_auto_position=1;

change master to
master_host='192.168.10.130',
master_user='slave',
master_password='TNTnb@123',
master_auto_position=1;

mysql> edit
    -> ;
Query OK, 0 rows affected, 2 warnings (0.02 sec)
#从服务器2进库,仍然需要让从库和主库建立链接.
#edit编辑添加内容.然后保存退出.

mysql> start slave;
Query OK, 0 rows affected (0.00 sec)
#启动slave角色

mysql> show slave status\G
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
#查看状态,IO和SQL都是yes代表GTID主从复制成功.
#接着就是验证

mysql> create database TNT;
Query OK, 1 row affected (0.00 sec)

mysql> use TNT;
Database changed
mysql> create table t1(id,int);

mysql> create table t1(id int);
Query OK, 0 rows affected (0.01 sec)
#服务器1进库创建1个库,1个表.

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| TNT                |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)

mysql> use TNT;
Database changed
mysql> show tables;
+---------------+
| Tables_in_TNT |
+---------------+
| t1            |
+---------------+
1 row in set (0.00 sec)
#服务器2进库验证库和表是否同步.
#这就是GTID的主从复制方式.

主从复制和GTID方式的主从复制不同点其实在最开始主从服务器的主配置文件参数,和从服务器的内容参数.

四：读写分离

对于数据库而言,要么数读数据,要么是写数据,把读放在一台服务器上,把写放在另一台服务器上.这样可以增大或者实现超大量的并发.
需要用到一款为数不多的中国人编写的软件,阿里巴巴的读写分离软件mycat.

正常访问流程：
客户端-web服务器-数据库-web服务器-客户端

部署mycat读写分离访问流程：
客户端-web服务器-（读数据，写数据）-Mycat-读数据库或写数据库-mycat-web服务器-客户端

mycat 服务器端不需要安装mysql
客户端测试需要安装mysql

一：部署mycat
1.安装jdk环境，在/etc/profile下面写java的环境变量
vim /etc/profile
JAVA_HOME=/usr/local/java
PATH=$JAVA_HOME/bin:$PATH
export JAVA_HOME PATH
source /etc/profile //使环境变量生效

2.安装mycat,在～/.bash_profile下面写mycat的环境变量
vim ～/.bash_profile
：/usr/local/mycat/bin
source ~/.bash_profile

3.然后启动
mycat start

4.测试端口：
jps
1762 WrapperSimpleApp
2023 Jps

ss -ntpl | grep java

二：mycat使用
mysql中添加数据库和账户：
mysql> create database shop;
mysql> create database bbs;
mysql> create database blog;
mysql> grant all on shop.* to shop@’%’ identified by ‘QianFeng@123’;
mysql> grant all on bbs.* to bbs@’%’ identified by ‘QianFeng@123’;
mysql> grant all on blog.* to blog@’%’ identified by ‘QianFeng@123’;
mysql> flush privileges;
设置3个账户和3个schema:
切换到mycat的工作目录：
server.xml Mycat的配置文件，设置账号、参数等
schema.xml Mycat对应的物理数据库和数据库表的配置
rule.xml Mycat分片（分库分表）规则

1、user标签
user 用户配置节点
–name 登录的用户名，也就是连接Mycat的用户名
–password 登录的密码，也就是连接Mycat的密码
–schemas 数据库名，这里会和schema.xml中的配置关联，多个用逗号分开，例如需要这个用户需要管理两个数据库
db1,db2，则配置db1,db2

[root@mycat conf]# cd /usr/local/mycat/conf
[root@mycat conf]# cat server.xml

[root@master conf]# cat schema.xml


balance=1
开启读写分离机制，所有读操作都发送到当前备用的 writeHost 上。

wirteType=0
所有写操作发送到第一个writeHost，第一个挂了切换到第二个

switchType=3
基于MySQL Galera cluster的切换机制，心跳语句为show status like ‘wsrep%’

重新启动mycat
[root@mycat ~]# mycat stop
[root@mycat ~]# mycat start

随便找台机器做客户端：
[root@client ~]# mysql -u shop -p’123456’ -h 192.168.245.3 -P8066

读写分离演示

准备环境：
mycat服务器：1台.对服务器配置要求高.（最少2G内存）
主从服务器：2台.（512-1G内存）
验证服务器：1台

一：部署mycat

需要2个包,Mycat和JDK.

[root@localhost ~]# ls
anaconda-ks.cfg  Mycat-server-1.6-RELEASE-20161028204710-linux.tar.gz  openjdk-9.0.1_linux-x64_bin.tar.gz
#mycat服务器先把2个包下载下来.
[root@localhost ~]# tar xf openjdk-9.0.1_linux-x64_bin.tar.gz -C /usr/local/
[root@localhost ~]# tar xf Mycat-server-1.6-RELEASE-20161028204710-linux.tar.gz -C /usr/local/
#解压安装JDK和MYCAT.
[root@localhost ~]# cd /usr/local/

[root@localhost local]# ls
bin  etc  games  include  jdk-9.0.1  lib  lib64  libexec  mycat  sbin  share  src
#进去安装目录看看这两个目录是否存在,是否安装好.
#要想JDK能正常运行,要添加环境变量.
[root@localhost local]# mv jdk-9.0.1/ java
#改个名字.

[root@localhost local]# vi /etc/profile
#JAVA_HOME=/usr/local/java  //指定java的路径
#PATH=$JAVA_HOME/bin:$PATH  //让bin能调用java的路径
#export JAVA_HOME PATH		//让上面指定的东西生效.

JAVA_HOME=/usr/local/java 
PATH=$JAVA_HOME/bin:$PATH 
export JAVA_HOME PATH
#编写jdk的环境变量.添加几行参数.

[root@localhost local]# source /etc/profile
#让配置文件生效.

[root@localhost local]# vi ~/.bash_profile 
PATH=$PATH:$HOME/bin:/usr/local/mycat/bin
#编写mycat的环境变量.
#在文件中找到PATH=$PATH:$HOME/bin补上mycat的路径:/usr/local/mycat/bin.

[root@localhost local]# source ~/.bash_profile 
#让配置文件生效.
#这样就可以直接调用maycat了.


[root@localhost local]# mycat start
Starting Mycat-server...
#试下启动mycat.成功.

[root@localhost local]# jps
102616 Jps
101627 WrapperSimpleApp

[root@localhost local]# ss -antpl | grep java
LISTEN     0      1      127.0.0.1:32000                    *:*                   users:(("java",pid=101627,fd=4))
LISTEN     0      50          :::43422                   :::*                   users:(("java",pid=101627,fd=49))
LISTEN     0      50          :::1984                    :::*                   users:(("java",pid=101627,fd=50))
LISTEN     0      100         :::8066                    :::*                   users:(("java",pid=101627,fd=67))
LISTEN     0      100         :::9066                    :::*                   users:(("java",pid=101627,fd=63))
LISTEN     0      50          :::40246                   :::*                   users:(("java",pid=101627,fd=51))
#多次输入jps,看是否出现两个内容.mycat对服务器配置要求比较高.如果只有1个则代表有问题.
#端口检测.都能正常的话代表mycat运行正常.

[root@localhost local]# mycat stop
Stopping Mycat-server...
Stopped Mycat-server.
[root@localhost local]# jps
106318 Jps
[root@localhost local]# ss -antpl | grep java
#反过来,关闭mycat.
#jps查看只有一个.
#端口也没了,代表mycat没运行成功.

二：mycat使用

mysql> create database shop;
Query OK, 1 row affected (0.00 sec)

mysql> create database bbs;
Query OK, 1 row affected (0.01 sec)

mysql> create database blog;
Query OK, 1 row affected (0.00 sec)

mysql>  grant all on shop.* to shop@'%' identified by 'TNTnb@123';
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> grant all on bbs.* to bbs@'%' identified by 'TNTnb@123';
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> grant all on blog.* to blog@'%' identified by 'TNTnb@123';
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

#用已经做好主从赋值的,主服务器进库里,添加3个数据库和3个账户.
#刷新授权表.

现在mycat装好能用了,怎样实现给后端的主从数据库实现读写分离呢.
要修改两个配置文件.主要靠的就是这两个配置文件.

1:server.xml
Mycat的配置文件，设置账号、参数等
主要写登陆的用户名和密码,想登陆mycat需要在这里面指定用户名和密码.包括该用户名和密码对应的逻辑库.

<user name="root">
                <property name="password">123456</property>
                <property name="schemas">TESTDB</property>

逻辑库：
它要高于现有的库,正常数据库是（库-表），在mycat这里又给它包了一层变为，库（库-表）。
所以在上面要想访问,就要有用户名和密码.

2:schema.xml
Mycat对应的物理数据库和数据库表的配置

设置3个账户和3个schema: 切换到mycat的工作目录：

[root@localhost ~]# cd /usr/local/mycat/
[root@localhost mycat]# ls
bin  catlet  conf  lib  logs  version.txt
[root@localhost mycat]# cd conf/
[root@localhost conf]# ls
autopartition-long.txt      index_to_charset.properties  partition-range-mod.txt      sequence_distributed_conf.properties  zkconf
auto-sharding-long.txt      log4j2.xml                   rule.xml                     sequence_time_conf.properties         zkdownload
auto-sharding-rang-mod.txt  migrateTables.properties     schema.xml                   server.xml
cacheservice.properties     myid.properties              sequence_conf.properties     sharding-by-enum.txt
ehcache.xml                 partition-hash-int.txt       sequence_db_conf.properties  wrapper.conf
[root@localhost conf]# pwd
/usr/local/mycat/conf
#两个配置文件都在这里面.

[root@localhost conf]# vi server.xml
#主要写登陆的用户名和密码,想登陆mycat需要在这里面指定用户名和密码.包括该用户名和密码对应的逻辑库.
#set nu，设置行号.v，x,12-78删掉.15-24再删掉.16-22再再删掉.留剩下的.
<mycat:server xmlns:mycat="http://io.mycat/">
              <user name="root">
                      <property name="password">123456</property>
                      <property name="schemas">TESTDB</property>
              </user>
</mycat:server>
#要确保留有这一块.
#然后多添加几个,改为
<!DOCTYPE mycat:server SYSTEM "server.dtd">
     <mycat:server xmlns:mycat="http://io.mycat/">
            <user name="shop">
                      <property name="password">123456</property>
                      <property name="schemas">shop</property>
              </user>
              <user name="bbs">
                      <property name="password">123456</property>
                      <property name="schemas">bbs</property>
              </user>
              <user name="blog">
                      <property name="password">123456</property>
                      <property name="schemas">blog,bbs</property>
              </user>
</mycat:server>
#这些等于是mycat的用户名和密码了.保存退出.
#这就是server.xml的配置

[root@localhost conf]# vi schema.xml 
#配置schema.xml,里面管理着逻辑库和表.
#把里面的内容全删.
#改为
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
        <schema name="shop" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1"></schema>
        <schema name="bbs" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn2"></schema>
        <schema name="blog" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn3"></schema>
        <dataNode name="dn1" dataHost="localhost1" database="shop" />
        <dataNode name="dn2" dataHost="localhost2" database="bbs" />
        <dataNode name="dn3" dataHost="localhost3" database="blog" />
        
        <dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"
                        writeType="0" dbType="mysql" dbDriver="native" switchType="1"   slaveThreshold="100">
                <heartbeat>show status like 'wsrep%'</heartbeat>
                <writeHost host="master-1" url="master-1:3306" user="shop" password="TNTnb@123">
                        <readHost host="slave-1" url="slave-1:3306" user="shop" password="TNTnb@123" />
                </writeHost>
        </dataHost>

        <dataHost name="localhost2" maxCon="1000" minCon="10" balance="1"
                        writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
                <heartbeat>show status like 'wsrep%'</heartbeat>
                <writeHost host="master-1" url="master-1:3306" user="bbs" password="TNTnb@123">
                        <readHost host="slave-1" url="slave-1:3306" user="bbs" password="TNTnb@123" />
                </writeHost>
        </dataHost>

        <dataHost name="localhost3" maxCon="1000" minCon="10" balance="1"
                        writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
                <heartbeat>show status like 'wsrep%'</heartbeat>
                <writeHost host="master-1" url="master-1:3306" user="blog" password="TNTnb@123">
                         <readHost host="slave-1" url="slave-1:3306" user="blog" password="TNTnb@123" />
                </writeHost>
        </dataHost>
</mycat:schema>

内容解释：

<schema name="shop" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1"></schema>
<dataNode name="dn1" dataHost="localhost1" database="shop" />
#逻辑库的名称shop,然后给这个逻辑库赋了一个标签叫做dn1.标签是自定义的,但是要保证和下面的dataNode name保持一致.
#然后在dataNode name这里进行关联.给它关联一个数据库的主机为localhost1,数据库为shop
#然后在下面分别对localhost1-3每个库进行读写分离的部署配置.

<dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"
#在这个主机1里面包含下面的内容.
writeType="0" dbType="mysql" dbDriver="native" switchType="1"   slaveThreshold="100">
<heartbeat>show status like 'wsrep%'</heartbeat>
#包含心跳检测.
<writeHost host="master-1" url="master-1:3306" user="shop" password="TNTnb@123">
<readHost host="slave-1" url="slave-1:3306" user="shop" password="TNTnb@123" />
#包含两台服务器,master-1负责读,slave-1负责写.
#也就是我们之前准备的另外两台主从服务器.并且已经授权好了的库和用户.
#这个是mycat的配置文件,因为我们需要通过mycat去链接我们的数据库,所以要在这个配置文件里面做好配置.
</writeHost>
</dataHost>

上面这段是主机1,localhost1,针对的是我们的shop库和dh1库.还有其它库可以编辑.

[root@localhost conf]# vim /etc/hosts
192.168.10.130 master-1
192.168.10.131 slave-1

[root@localhost conf]# ping master-1
PING master-1 (192.168.10.130) 56(84) bytes of data.
64 bytes from master-1 (192.168.10.130): icmp_seq=1 ttl=64 time=0.466 ms

[root@localhost conf]# ping slave-1
PING slave-1 (192.168.10.131) 56(84) bytes of data.
64 bytes from slave-1 (192.168.10.131): icmp_seq=1 ttl=64 time=0.364 ms

#mycat服务器里修改域名解析.把配置文件里所配置的负责读和写的名称修改对.
#再ping下域名解析是否正常.

[root@localhost conf]# mycat start
Starting Mycat-server...
Mycat-server is already running.
[root@localhost conf]# jps
7761 WrapperSimpleApp
25612 Jps
#然后再启动mycat.jps查看,到这里，MYCAT的配置包括对另外两台主从服务器的配置就完成了.
#接下来就是验证.

客户端验证：

[root@client ~]# mysql -u shop -p'123456' -h 192.168.10.133 -P8066
#找一台有mysql客户端的服务器.进行验证.
#使用的是之前注册的mycat用户shop,密码也是Mycat里server.xml里面配置的123456.192.168.10.133是mycat的主机,端口是8066.

进来之后链接的就是mycat而不是数据库了.是先链接mycat,mycat再去链主从读写分离数据库.

然后在这台客户端上面的shop库里面创建一个t2的表.
实际就是这个客户端创建好了这个表.通过我们的mycat在我们真正的数据库上面创建了.

然后去主数据库里面看看是否成功.
发现也有一个t2的表.代表成功.

同样的可以再回到客户端上,再创建一个表或者库甚至插入字段.再去看看从数据库是否同步,同步则代表成功.