1 MyCat 常用命令
 
 
 
启动MyCat
 
 
./mycat start
 
 
 
查看启动状态
 
 
./mycat status
 
 
 
停止 
 
 
./mycat stop
 
 
 
重启
 
 
​./mycat restart
 
 
 
控制台启动，测试使用，方便发现报错信息
 
 
./mycat console
 

2 使用Mycat实现一主一从的读写分离
 
 
 
一主一从搭建过程 : https://yuanyu.blog.csdn.net/article/details/106320629#t0
 
 
tar -zxvf Mycat-server-1.6.7.1-release-20190627191042-linux.tar.gz
 
mv mycat /usr/local/ && cd /usr/local/mycat
 
 
 
vim server.xml  
 
 
<user name="mycat" defaultAccount="true">
    <property name="password">123456</property>
    <property name="schemas">TESTDB</property>
</user>
 
 
 
vim schema.xml 
 
 
<?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="easycode_db"/>
    <!--
        （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 不负担读压力
    -->
    <dataHost name="host1" maxCon="1000" minCon="10" balance="3" writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
        <heartbeat>select user()</heartbeat>
        <!--写-->
        <writeHost host="master" url="39.106.196.224:5569" user="root" password="123456">
            <!--读-->
            <readHost host="slave" url="121.36.33.154:5596" user="root" password="123456"/>
        </writeHost>
    </dataHost>
</mycat:schema>
 
 
 
控制台启动
 
 
./mycat console
 
//版本过高
λ mysql -umycat -p123456 -P 8066 -h 121.36.33.154
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 1045 (HY000): Access denied for user 'mycat', because password is error
 
 
 
9066端口用于管理维护Mycat
 
 
mysql -umycat -p123456 -P 9066 -h 39.106.196.224
 
 
 
8066端口用于通过Mycat查询数据
 
 
mysql -umycat -p123456 -P 8066 -h 39.106.196.224
 
 
 
使用java程序访问
 
 
spring:
  datasource:
    url: jdbc:mysql://39.106.196.224:8066/TESTDB?serverTimezone=UTC&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
    username: mycat
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
 
//mycat 123456
jdbc:mysql://39.106.196.224:8066/?serverTimezone=UTC
 
use TESTDB;
select `name` from user where id = 6;
 

3 使用Mycat实现双主双从的读写分离
 
 
 
双主双从搭建过程 : https://yuanyu.blog.csdn.net/article/details/106320629#t4
 
 
 
 
vim schema.xml  
 
 
<?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="easycode_db"/>
    <!--
        balance="1" : 全部的readHost与stand by writeHost参与select语句的负载均衡
        writeType="0" : 所有写操作发送到配置的第一个writeHost，第一个挂了切到还生存的第二个

        switchType="1" : 1 默认值，自动切换
           -1 表示不自动切换
           2 基于 MySQL 主从同步的状态决定是否切换
    -->
    <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="master1" url="101.200.43.221:4500" user="root" password="123456">
            <readHost host="slave1" url="120.25.216.234:4501" user="root" password="123456"/>
        </writeHost>
        <writeHost host="master2" url="121.36.33.154:5000" user="root" password="123456">
            <readHost host="slave2" url="39.106.196.224:5001" user="root" password="123456"/>
        </writeHost>
    </dataHost>
</mycat:schema>
 
spring:
  datasource:
    url: jdbc:mysql://39.106.196.224:8066/TESTDB?serverTimezone=UTC&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
    username: mycat
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
 
3.1 正常访问 
 
 
 
 
抗风险能力
 
 
3.2 master1宕机 
 
docker stop mysql_master1
 
 
 
3.3 master1故障恢复
 
docker start mysql_master1
 
 
docker exec -it mysql_master1 /bin/bash
 
 
 

Mycat官网：http://www.mycat.io/
 可以了解下Mycat的背景和应用情况，这样使用起来比较有信心。
 
Mycat下载地址：http://dl.mycat.io/
 官网有个文档，属于详细的介绍，初次入门，看起来比较花时间。
 
下载：
 建议大家选择 1.6-RELEASE 版本，毕竟是比较稳定的版本。
 
安装：
 根据不同的系统选择不同的版本。包括linux、windows、mac,作者考虑还是非常周全的，当然，也有源码版的。（ps:源码版的下载后，只要配置正确，就可以正常运行调试，这个赞一下。）
 
Mycat的安装其实只要解压下载的目录就可以了，非常简单。
 安装完成后，目录如下：
 
目录
说明
bin
mycat命令，启动、重启、停止等
catlet
catlet为Mycat的一个扩展功能
conf
Mycat 配置信息,重点关注
lib
Mycat引用的jar包，Mycat是java开发的
logs
日志文件，包括Mycat启动的日志和运行的日志。
配置
 
Mycat的配置文件都在conf目录里面，这里介绍几个常用的文件：
 
文件
说明
server.xml
Mycat的配置文件，设置账号、参数等
schema.xml
Mycat对应的物理数据库和数据库表的配置
rule.xml
Mycat分片（分库分表）规则
Mycat的架构其实很好理解，Mycat是代理，Mycat后面就是物理数据库。和Web服务器的Nginx类似。对于使用者来说，访问的都是Mycat，不会接触到后端的数据库。
 我们现在做一个主从、读写分离，简单分表的示例。结构如下图：
 
服务器
IP
说明
Mycat
192.168.0.2
mycat服务器，连接数据库时，连接此服务器
database1
192.168.0.3
物理数据库1，真正存储数据的数据库
database2
192.168.0.4
物理数据库2，真正存储数据的数据库
Mycat作为主数据库中间件，肯定是与代码弱关联的，所以代码是不用修改的，使用Mycat后，连接数据库是不变的，默认端口是8066。连接方式和普通数据库一样，如：jdbc:mysql://192.168.0.2:8066/
 
server.xml
 
示例
 
 
 
 
<user name="test">
 
 
<property name="password">test</property> 
 
 
<property name="schemas">lunch</property> 
 
 
<property name="readOnly">false</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
登录的用户名，也就是连接Mycat的用户名
--password
登录的密码，也就是连接Mycat的密码
--schemas
数据库名，这里会和schema.xml中的配置关联，多个用逗号分开，例如需要这个用户需要管理两个数据库db1,db2，则配置db1,dbs
--privileges
配置用户针对表的增删改查的权限，具体见文档吧
我这里配置了一个账号test 密码也是test,针对数据库lunch,读写权限都有，没有针对表做任何特殊的权限。
 
schema.xml
 schema.xml是最主要的配置项，首先看我的配置文件。
 
 
 
 
<?xml version="1.0"?>
 
 
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
 
 
<mycat:schema xmlns:mycat="http://io.mycat/">
 
 
 
<!-- 数据库配置，与server.xml中的数据库对应 -->
 
 
<schema name="lunch" checkSQLschema="false" sqlMaxLimit="100">
 
 
<table name="lunchmenu" dataNode="dn1" />
 
 
<table name="restaurant" dataNode="dn1" />
 
 
<table name="userlunch" dataNode="dn1" />
 
 
<table name="users" dataNode="dn1" />
 
 
<table name="dictionary" primaryKey="id" autoIncrement="true" dataNode="dn1,dn2" rule="mod-long" />
 
 
 
 
</schema>
 
 
 
<!-- 分片配置 -->
 
 
<dataNode name="dn1" dataHost="test1" database="lunch" />
 
 
<dataNode name="dn2" dataHost="test2" database="lunch" />
 
 
 
<!-- 物理数据库配置 -->
 
 
<dataHost name="test1" maxCon="1000" minCon="10" balance="0" writeType="0" dbType="mysql" dbDriver="native">
 
 
<heartbeat>select user();</heartbeat>
 
 
<writeHost host="hostM1" url="192.168.0.2:3306" user="root" password="123456"> 
 
 
</writeHost>
 
 
</dataHost>
 
 
 
<dataHost name="test2" maxCon="1000" minCon="10" balance="0" writeType="0" dbType="mysql" dbDriver="native">
 
 
<heartbeat>select user();</heartbeat>
 
 
<writeHost host="hostS1" url="192.168.0.3:3306" user="root" password="123456"> 
 
 
</writeHost>
 
 
</dataHost>
 
 
 
</mycat:schema>
 
参数
说明
schema
数据库设置，此数据库为逻辑数据库，name与server.xml中schema对应
dataNode
分片信息，也就是分库相关配置
dataHost
物理数据库，真正存储数据的数据库
每个节点的属性逐一说明：
 
schema:
 
属性
说明
name
逻辑数据库名，与server.xml中的schema对应
checkSQLschema
数据库前缀相关设置，建议看文档，这里暂时设为folse
sqlMaxLimit
select 时默认的limit，避免查询全表
table:
 
属性
说明
name
表名，物理数据库中表名
dataNode
表存储到哪些节点，多个节点用逗号分隔。节点为下文dataNode设置的name
primaryKey
主键字段名，自动生成主键时需要设置
autoIncrement
是否自增
rule
分片规则名，具体规则下文rule详细介绍
dataNode
 
属性
说明
name
节点名，与table中dataNode对应
datahost
物理数据库名，与datahost中name对应
database
物理数据库中数据库名
dataHost
 
属性
说明
name
物理数据库名，与dataNode中dataHost对应
balance
均衡负载的方式
writeType
写入方式
dbType
数据库类型
heartbeat
心跳检测语句，注意语句结尾的分号要加。
应用场景
 
数据库分表分库
 
配置如下：
 
 
 
 
<?xml version="1.0"?>
 
 
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
 
 
<mycat:schema xmlns:mycat="http://io.mycat/">
 
 
 
<!-- 数据库配置，与server.xml中的数据库对应 -->
 
 
<schema name="lunch" checkSQLschema="false" sqlMaxLimit="100">
 
 
<table name="lunchmenu" dataNode="dn1" />
 
 
<table name="restaurant" dataNode="dn1" />
 
 
<table name="userlunch" dataNode="dn1" />
 
 
<table name="users" dataNode="dn1" />
 
 
<table name="dictionary" primaryKey="id" autoIncrement="true" dataNode="dn1,dn2" rule="mod-long" />
 
 
 
 
</schema>
 
 
 
<!-- 分片配置 -->
 
 
<dataNode name="dn1" dataHost="test1" database="lunch" />
 
 
<dataNode name="dn2" dataHost="test2" database="lunch" />
 
 
 
<!-- 物理数据库配置 -->
 
 
<dataHost name="test1" maxCon="1000" minCon="10" balance="0" writeType="0" dbType="mysql" dbDriver="native">
 
 
<heartbeat>select user();</heartbeat>
 
 
<writeHost host="hostM1" url="192.168.0.2:3306" user="root" password="123456"> 
 
 
</writeHost>
 
 
</dataHost>
 
 
 
<dataHost name="test2" maxCon="1000" minCon="10" balance="0" writeType="0" dbType="mysql" dbDriver="native">
 
 
<heartbeat>select user();</heartbeat>
 
 
<writeHost host="hostS1" url="192.168.0.3:3306" user="root" password="123456"> 
 
 
</writeHost>
 
 
</dataHost>
 
 
 
</mycat:schema>
 
我在192.168.0.2、192.168.0.3均有数据库lunch。
 lunchmenu、restaurant、userlunch、users这些表都只写入节点dn1，也就是192.168.0.2这个服务，而dictionary写入了dn1、dn2两个节点，也就是192.168.0.2、192.168.0.3这两台服务器。分片的规则为：mod-long。
 主要关注rule属性，rule属性的内容来源于rule.xml这个文件，Mycat支持10种分表分库的规则，基本能满足你所需要的要求，这个必须赞一个，其他数据库中间件好像都没有这么多。
 table中的rule属性对应的就是rule.xml文件中tableRule的name,具体有哪些分表和分库的实现，建议还是看下文档。我这里选择的mod-long就是将数据平均拆分。因为我后端是两台物理库，所以rule.xml中mod-long对应的function count为2，见下面部分代码：
 
 
 
 
<tableRule name="mod-long">
 
 
<rule>
 
 
<columns>id</columns>
 
 
<algorithm>mod-long</algorithm>
 
 
</rule>
 
 
</tableRule>
 
 
 
<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
 
 
<!-- how many data nodes -->
 
 
<property name="count">2</property>
 
 
</function>
 
数据库读写分离
 
配置如下：
 
 
 
 
<?xml version="1.0"?>
 
 
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
 
 
<mycat:schema xmlns:mycat="http://io.mycat/">
 
 
 
<!-- 数据库配置，与server.xml中的数据库对应 -->
 
 
<schema name="lunch" checkSQLschema="false" sqlMaxLimit="100">
 
 
<table name="lunchmenu" dataNode="dn1" />
 
 
<table name="restaurant" dataNode="dn1" />
 
 
<table name="userlunch" dataNode="dn1" />
 
 
<table name="users" dataNode="dn1" />
 
 
<table name="dictionary" primaryKey="id" autoIncrement="true" dataNode="dn1" />
 
 
 
 
</schema>
 
 
 
<!-- 分片配置 -->
 
 
<dataNode name="dn1" dataHost="test1" database="lunch" />
 
 
 
 
<!-- 物理数据库配置 -->
 
 
<dataHost name="test1" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native">
 
 
<heartbeat>select user();</heartbeat>
 
 
<writeHost host="hostM1" url="192.168.0.2:3306" user="root" password="123456"> 
 
 
<readHost host="hostM1" url="192.168.0.3:3306" user="root" password="123456"> 
 
 
</readHost>
 
 
</writeHost>
 
 
</dataHost>
 
 
 
 
</mycat:schema>
 
这样的配置与前一个示例配置改动如下：
 删除了table分配的规则,以及datanode只有一个
 datahost也只有一台，但是writehost总添加了readhost,balance改为1，表示读写分离。
 以上配置达到的效果就是102.168.0.2为主库，192.168.0.3为从库。
 
注意：Mycat主从分离只是在读的时候做了处理，写入数据的时候，只会写入到writehost，需要通过mysql的主从复制将数据复制到readhost，这个问题当时候我纠结了好久，数据写入writehost后，readhost一直没有数据，以为是自己配置的问题，后面才发现Mycat就没有实现主从复制的功能，毕竟数据库本身自带的这个功能才是最高效稳定的。
 
 
 
至于其他的场景，如同时主从和分表分库也是支持的了，只要了解这个实现以后再去修改配置，都是可以实现的。而热备及故障专业官方推荐使用haproxy配合一起使用，大家可以试试。
 
 
使用
 
Mycat的启动也很简单，启动命令在Bin目录：
 
 
 
 
##启动
 
 
mycat start
 
 
 
##停止
 
 
mycat stop
 
 
 
##重启
 
 
mycat restart
 
如果在启动时发现异常，在logs目录中查看日志。
 
wrapper.log 为程序启动的日志，启动时的问题看这个
mycat.log 为脚本执行时的日志，SQL脚本执行报错后的具体错误内容,查看这个文件。mycat.log是最新的错误日志，历史日志会根据时间生成目录保存。
mycat启动后，执行命令不成功，可能实际上配置有错误，导致后面的命令没有很好的执行。
 
Mycat带来的最大好处就是使用是完全不用修改原有代码的，在mycat通过命令启动后，你只需要将数据库连接切换到Mycat的地址就可以了。如下面就可以进行连接了：
 
 mysql -h192.168.0.1 -P8806 -uroot -p123456
 
连接成功后可以执行sql脚本了。
 所以，可以直接通过sql管理工具（如：navicat、datagrip）连接，执行脚本。我一直用datagrip来进行日常简单的管理，这个很方便。
 
Mycat还有一个管理的连接，端口号是9906.
 
 mysql -h192.168.0.1 -P9906 -uroot -p123456
 
连接后可以根据管理命令查看Mycat的运行情况，当然，喜欢UI管理方式的人，可以安装一个Mycat-Web来进行管理，有兴趣自行搜索。
 
简而言之，开发中使用Mycat和直接使用Mysql机会没有差别。
 
常见问题
 
使用Mycat后总会遇到一些坑，我将自己遇到的一些问题在这里列一下，希望能与大家有共鸣：
 
 
Mycat是不是配置以后，就能完全解决分表分库和读写分离问题？
 Mycat配合数据库本身的复制功能，可以解决读写分离的问题，但是针对分表分库的问题，不是完美的解决。或者说，至今为止，业界没有完美的解决方案。
 分表分库写入能完美解决，但是，不能完美解决主要是联表查询的问题，Mycat支持两个表联表的查询，多余两个表的查询不支持。 其实，很多数据库中间件关于分表分库后查询的问题，都是需要自己实现的，而且节本都不支持联表查询，Mycat已经算做地非常先进了。
 分表分库的后联表查询问题，大家通过合理数据库设计来避免。
 
 
Mycat支持哪些数据库，其他平台如 .net、PHP能用吗？
 官方说了，支持的数据库包括MySQL、SQL Server、Oracle、DB2、PostgreSQL 等主流数据库，很赞。
 尽量用Mysql,我试过SQL Server，会有些小问题，因为部分语法有点差异。
 
 
Mycat 非JAVA平台如 .net、PHP能用吗？
 可以用。这一点MyCat做的也很棒。
 

MyCat概述
 
什么是MyCat
 
简单的说，MyCAT就是： 
 - 一个彻底开源的，面向企业应用开发的“大数据库集群” 
 - 支持事务、ACID、可以替代Mysql的加强版数据库 
 - 一个可以视为“Mysql”集群的企业级数据库，用来替代昂贵的Oracle集群 
 - 一个融合内存缓存技术、Nosql技术、HDFS大数据的新型SQL Server 
 - 结合传统数据库和新型分布式数据仓库的新一代企业级数据库产品 
 - 一个新颖的数据库中间件产品
 
MyCAT的目标是：低成本的将现有的单机数据库和应用平滑迁移到“云”端，解决数据存储和业务规模迅速增长情况下的数据瓶颈问题。
 
MyCAT的关键特性
 
支持 SQL 92标准 
 支持Mysql集群，可以作为Proxy使用 
 支持JDBC连接ORACLE、DB2、SQL Server，将其模拟为MySQL Server使用 
 支持galera for mysql集群，percona-cluster或者mariadb cluster，提供高可用性数据分片集群 
 自动故障切换，高可用性 
 支持读写分离，支持Mysql双主多从，以及一主多从的模式 
 支持全局表，数据自动分片到多个节点，用于高效表关联查询 
 支持独有的基于E-R 关系的分片策略，实现了高效的表关联查询 
 多平台支持，部署和实施简单
 
MyCAT架构
 
 
 如图所示：MyCAT使用Mysql的通讯协议模拟成了一个Mysql服务器，并建立了完整的Schema（数据库）、Table （数据表）、User(用户)的逻辑模型，并将这套逻辑模型映射到后端的存储节点DataNode（MySQL Instance）上的真实物理库中，这样一来，所有能使用Mysql的客户端以及编程语言都能将MyCAT当成是Mysql Server来使用，不必开发新的客户端协议。
 
Mycat解决的问题
 
性能问题 
 数据库连接过多 
 E-R分片难处理 
 可用性问题
 
Mycat对多数据库的支持
 
MyCat原理
 
Mycat的原理中最重要的一个动词是“拦截”，它拦截了用户发送过来的SQL语句，首先对SQL语句做了一些特定的分析：如分 
 片分析、路由分析、读写分离分析、缓存分析等，然后将此SQL发往后端的真实数据库，并将返回的结果做适当的处理，最终再 
 返回给用户。
 
MyCat分片策略
 
MyCAT支持水平分片与垂直分片： 
 水平分片：一个表格的数据分割到多个节点上，按照行分隔。 
 垂直分片：一个数据库中多个表格A，B，C，A存储到节点1上，B存储到节点2上，C存储到节点3上。 
  
 垂直切分其实就是根据业务的不同，将不同业务的表放到不同的数据库中，例如我们订单表，用户表，用户评论表，因为他们业务的不同，可以将他们分别放到三个数据库中。 
 水平切分：很多时候，用户量大的时候，例如一张用户表有上亿条数据，那么一次性查数据肯定很慢，那么我们可以这样子，将这张表按照某种规则将数据存放到不同的数据库中。
 
MyCAT通过定义表的分片规则来实现分片，每个表格可以捆绑一个分片规则，每个分片规则指定一个分片字段并绑定一个函数，来实现动态分片算法。
 
1、Schema：逻辑库，与MySQL中的Database（数据库）对应，一个逻辑库中定义了所包括的Table。 
 2、Table：表，即物理数据库中存储的某一张表，与传统数据库不同，这里的表格需要声明其所存储的逻辑数据节点DataNode。在此可以指定表的分片规则。 
 3、DataNode：MyCAT的逻辑数据节点，是存放table的具体物理节点，也称之为分片节点，通过DataSource来关联到后端某个具体数据库上 
 4、DataSource：定义某个物理库的访问地址，用于捆绑到Datanode上
 
Mycat的安装
 
官方网站： 
 http://www.mycat.org.cn/
 
github地址 
 https://github.com/MyCATApache
 
MyCat安装
 
第一步：把MyCat的压缩包上传到linux服务器 
 第二步：解压缩，得到mycat目录 
 第三步：进入mycat/bin，启动MyCat 
 启动命令：./mycat start 
 停止命令：./mycat stop 
 重启命令：./mycat restart
 
可以使用mysql的客户端直接连接mycat服务。默认服务端口为8066
 
MyCat分片
 
需求
 
把商品表分片存储到三个数据节点上。
 
安装环境
 
mysql节点1环境 
 操作系统版本 : centos6.4 
 数据库版本 : mysql-5.6 
 mycat版本 ：1.4 release 
 数据库名 : db1、db3 
 ip:192.168.25.134
 
mysql节点2环境 
 操作系统版本 : centos6.4 
 数据库版本 : mysql-5.6 
 mycat版本 ：1.4 release 
 数据库名 : db2 
 ip:192.168.25.166
 
MyCat安装到节点1上（需要安装jdk）
 
配置schema.xml
 
Schema.xml介绍
 
Schema.xml作为MyCat中重要的配置文件之一，管理着MyCat的逻辑库、表、分片规则、DataNode以及DataSource。弄懂这些配置，是正确使用MyCat的前提。这里就一层层对该文件进行解析。 
 schema 标签用于定义MyCat实例中的逻辑库 
 Table 标签定义了MyCat中的逻辑表 
 dataNode 标签定义了MyCat中的数据节点，也就是我们通常说所的数据分片。 
 dataHost标签在mycat逻辑库中也是作为最底层的标签存在，直接定义了具体的数据库实例、读写分离配置和心跳语句。
 
若是LINUX版本的MYSQL，则需要设置为Mysql大小写不敏感，否则可能会发生表找不到的问题。 
 在MySQL的配置文件中my.ini [mysqld] 中增加一行 
 　　lower_case_table_names = 1
 
        <?xml version="1.0"?>
        <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
        <mycat:schema xmlns:mycat="http://org.opencloudb/">

            <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100">
                <!-- auto sharding by id (long) -->
                <table name="TB_ITEM" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" />
                <table name="TB_USER" primaryKey="ID" type="global" dataNode="dn1,dn2" />
            </schema>
            <dataNode name="dn1" dataHost="localhost1" database="db1" />
            <dataNode name="dn2" dataHost="localhost2" database="db2" />
            <dataNode name="dn3" dataHost="localhost1" database="db3" />
            <dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
                writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                <heartbeat>select user()</heartbeat>
                <!-- can have multi write hosts -->
                <writeHost host="hostM1" url="192.168.25.134:3306" user="root"
                    password="root">
                    <!-- can have multi read hosts -->

                </writeHost>
            </dataHost>
            <dataHost name="localhost2" maxCon="1000" minCon="10" balance="0"
                writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                <heartbeat>select user()</heartbeat>
                <!-- can have multi write hosts -->
                <writeHost host="hostM1" url="192.168.25.166:3306" user="root"
                    password="root">
                    <!-- can have multi read hosts -->
                </writeHost>
            </dataHost>
        </mycat:schema>
 
配置server.xml
 
Server.xml介绍
 
server.xml几乎保存了所有mycat需要的系统配置信息。最常用的是在此配置用户名、密码及权限。 
 Server.xml配置
 
        <user name="test">
            <property name="password">test</property>
            <property name="schemas">TESTDB</property>
            <property name="readOnly">true</property>
        </user>
 
配置rule.xml
 
rule.xml里面就定义了我们对表进行拆分所涉及到的规则定义。我们可以灵活的对表使用不同的分片算法，或者对表使用相同的算法但具体的参数不同。这个文件里面主要有tableRule和function这两个标签。在具体使用过程中可以按照需求添加tableRule和function。 
 此配置文件可以不用修改，使用默认即可。
 
MyCat读写分离
 
数据库读写分离对于大型系统或者访问量很高的互联网应用来说，是必不可少的一个重要功能。对于MySQL来说，标准的读写分离是主从模式，一个写节点Master后面跟着多个读节点，读节点的数量取决于系统的压力，通常是1-3个读节点的配置。 
  
 Mycat读写分离和自动切换机制，需要mysql的主从复制机制配合。
 
Mysql的主从复制
 
 
 主从配置需要注意的地方 
 1、主DB server和从DB server数据库的版本一致 
 2、主DB server和从DB server数据库数据一致[ 这里就会可以把主的备份在从上还原，也可以直接将主的数据目录拷贝到从的相应数据目录] 
 3、主DB server开启二进制日志,主DB server和从DB server的server_id都必须唯一
 
Mysql主服务器配置
 
第一步：修改my.conf文件： 
 在[mysqld]段下添加：
 
    binlog-do-db=db1
    binlog-ignore-db=mysql
    #启用二进制日志
    log-bin=mysql-bin
    #服务器唯一ID，一般取IP最后一段
    server-id=134
 
第二步：重启mysql服务 
 service mysqld restart 
 第三步：建立帐户并授权slave
 
    mysql>GRANT FILE ON *.* TO 'backup'@'%' IDENTIFIED BY '123456';
    mysql>GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* to 'backup'@'%' identified by '123456'; 
    #一般不用root帐号，“%”表示所有客户端都可能连，只要帐号，密码正确，此处可用具体客户端IP代替，如192.168.145.226，加强安全。
 
刷新权限 
 mysql> FLUSH PRIVILEGES;
 
查看mysql现在有哪些用户 
 mysql>select user,host from mysql.user;
 
第四步：查询master的状态 
 mysql> show master status;
 
Mysql从服务器配置
 
第一步：修改my.conf文件 
 [mysqld] 
 server-id=166
 
第二步：配置从服务器 
 mysql>change master to master_host=’192.168.25.134’,master_port=3306,master_user=’backup’,master_password=’123456’,master_log_file=’mysql-bin.000001’,master_log_pos=120 
 
注意语句中间不要断开，master_port为mysql服务器端口号(无引号)，master_user为执行同步操作的数据库账户，“120”无单引号(此处的120就是show master status 中看到的position的值，这里的mysql-bin.000001就是file对应的值)。
 
第二步：启动从服务器复制功能 
 Mysql>start slave; 
 
第三步：检查从服务器复制功能状态： 
 mysql> show slave status
 
……………………(省略部分) 
 Slave_IO_Running: Yes //此状态必须YES 
 Slave_SQL_Running: Yes //此状态必须YES 
 ……………………(省略部分)
 
注：Slave_IO及Slave_SQL进程必须正常运行，即YES状态，否则都是错误的状态(如：其中一个NO均属错误)。
 
错误处理： 
 如果出现此错误： 
 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是克隆的系统所以mysql的uuid是一样的，所以需要修改。 
 解决方法： 
 删除/var/lib/mysql/auto.cnf文件，重新启动服务。
 
Mycat配置
 
Mycat 1.4 支持MySQL主从复制状态绑定的读写分离机制，让读更加安全可靠，配置如下：
 
            <dataNode name="dn1" dataHost="localhost1" database="db1" />
            <dataNode name="dn2" dataHost="localhost1" database="db2" />
            <dataNode name="dn3" dataHost="localhost1" database="db3" />
            <dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"
                writeType="0" dbType="mysql" dbDriver="native" switchType="2"  slaveThreshold="100">
                <heartbeat>show slave status</heartbeat>
                <writeHost host="hostM" url="192.168.25.134:3306" user="root"
                    password="root">
                    <readHost host="hostS" url="192.168.25.166:3306" user="root"
                    password="root" />
                </writeHost>
        </dataHost>
 
(1)设置 balance=”1”与writeType=”0” 
 Balance参数设置： 
 1. balance=“0”, 所有读操作都发送到当前可用的writeHost上。 
 2. balance=“1”，所有读操作都随机的发送到readHost。 
 3. balance=“2”，所有读操作都随机的在writeHost、readhost上分发 
 WriteType参数设置： 
 1. writeType=“0”, 所有写操作都发送到可用的writeHost上。 
 2. writeType=“1”，所有写操作都随机的发送到readHost。 
 3. writeType=“2”，所有写操作都随机的在writeHost、readhost分上发。 
 “readHost是从属于writeHost的，即意味着它从那个writeHost获取同步数据，因此，当它所属的writeHost宕机了，则它也不会再参与到读写分离中来，即“不工作了”，这是因为此时，它的数据已经“不可靠”了。基于这个考虑，目前mycat 1.3和1.4版本中，若想支持MySQL一主一从的标准配置，并且在主节点宕机的情况下，从节点还能读取数据，则需要在Mycat里配置为两个writeHost并设置banlance=1。” 
 (2)设置 switchType=”2” 与slaveThreshold=”100” 
 switchType 目前有三种选择： 
 -1：表示不自动切换 
 1 ：默认值，自动切换 
 2 ：基于MySQL主从同步的状态决定是否切换 
 “Mycat心跳检查语句配置为 show slave status ，dataHost 上定义两个新属性： switchType=”2” 与slaveThreshold=”100”，此时意味着开启MySQL主从复制状态绑定的读写分离与切换机制。Mycat心跳机制通过检测 show slave status 中的 “Seconds_Behind_Master”, “Slave_IO_Running”, “Slave_SQL_Running” 三个字段来确定当前主从同步的状态以及Seconds_Behind_Master主从复制时延。“