mycat

Posted zhangcaiwang1

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了mycat相关的知识，希望对你有一定的参考价值。

什么是mycat

mycat是一个开源的 面向企业应用开发的数据库集群 支持事务 ACID 可以替代msyql的加强版数据库 一个可以视为mysql 集群的企业级数据库 用来代替昂贵的oracle集群 它是一个融合了内存缓存技术 NOsql技术 HDFS大数据的新型sql server 结合传统数据和新型分布式数据库的新一代企业级数据库产品

 

mycat主要作用

 

分布式数据库系统中间层

中间层：如果没有中间层 那么我们前端应用可以直接连接mysql数据库 那么有了中间层就可以很好的实现数据库的读写分离 数据库的读负载均衡等一些功能 还可以统一数据库的连接数量这也是重要的引入中间层的原因 还可以屏蔽后端数据库的一些变更 mycat除了支持mysql的协议之外还可以通过jdbc连接其他的数据库比如oracle还可以连接非关系数据库比如mango 
以上是关于一些中间层的介绍 接下来看mycat主要作用

 

1·实现数据库的读写分离 它是日常工作当中最常被使用到的一个功能

什么是读写分离 ： 
就是前端web应用 可以通过mycat中间层产品对后端的主从复制架构的数据库进行读写分离 就是说要将写入操作执行到主数据库 要将读操作执行到从数据库 以缓解数据库主库的压力

 

2·mycat支持读负载均衡 主要适用于一主多从架构

 

3·mycat支持后端mysql高可用 这里的高可用并不是MMM和mha的高可用 这两种高可用当我们的主节点宕机之后是可以自动的从多个从节点中选举出一个新的主 并且将其他的从对这个新的主进行重新同步 但是mycat并不具备这样的功能 它指的是配置的时候除了指定一台主节点再指定一台从节点也可以支持写的功能 当主节点宕机之后mycat会把sql语句路由到我们所制定的从节点上并不支持将其他从节点对新的主节点进行同步的功能

 

4·对数据库垂直拆分 当我们的主库无法承受庞大的写压力时就需要对数据库进行垂直拆分了

什么是垂直拆分： 
如果将数据库比作一个蛋糕 那么垂直切分就是将这个蛋糕从上到下切成几块 就是将一个数据库中的表 按照一定的规则来分摊到多个数据库实例上去 然后通过mycat来访问后方数据库 那么这样对于前端来讲它就相当于用的是一个数据库

 

5·对数据库的水平拆分 也就是分表分库

如果垂直切分以后 如果我们的业务量持续增大 那么我们之前的拆分已经无法满足这么大的需求了 那么我们就需要按照一定的规则来进行水平拆分了 如果刚才的垂直切分蛋糕 那么现在就是横向切分 实际就是比如说 按照我们之前的例子如果这个数据库里有三个模块比如 用户 订单 支付 那么我们之前的垂直分区就是将这三个本来再一个库里的三个模块分摊到三个库去 而水平就是再基于垂直的基础上再对每个库按照一定的规则进行细化切分 就比如用户这个库 我们就可以将这个库分为 用户1 用户2 用户3 等多个库并且按照一定的规则进行切分 使每个切分后的库是一样的规则 然后我们还是通过mycat来进行访问数据库

 

nycat应用场景

···········需要进行读写分离的场景 
···········需要分库分表的场景 
···········多租户场景 就像我们能听到的云服务 
···········数据统计系统 
···········hbase的一种替代 hbase是一种基于hadoop的分布式列存储数据库 跟mysql不一样的是 关系型数据库基本是行存储 那这个就是列存储 
···········还可以使用同样的方式查询多种数据库的场景 通过jdbc 连接多种数据库

 

mycat优势

1·mycat是基于阿里的cobar系统开发 
2·开发社区活跃 
3·完全开源可以自定义开发 
4·支持多种关系型以及NOsql数据库 
5·使用java开发 可以部署在多种系统上 
6·具有多种行业和项目应用的成功案例

 

mycat基础

 

基本概念

mycat中的数据库--逻辑库 nycat逻辑库只保存对后方数据库的定义而不会保存具体数据
mycalt中的数据库--逻辑表 一个逻辑表可能对应后端物理数据库中的多个表 比如前端数据库可以看到我们mycat表中的一个表是user_db 而这个表所对应的后方数据库已经被我们拆分为 db01 db02 db03 那么前端访问时就会直接找mycat就可简单的访问后端数据库 而后端数据库的分表以及分库已经被mycat所隐藏
 

mycat关键特性

··支持SQL92标准 ：sql92就是目前大多数数据库都支持的数据库标准 在这个标准中定义了sql语句功能 
d的一些功能 和标准的一些事务的特性 
··支持多种mysql集群 比如一主一从 多主多从 
··支持jdbc连接不同的关系型数据库 
··通过jdbc还可以连接Nosql数据库 
··支持后端数据库的故障自动切换 高可用性 但是并不支持将从同步到新的主 
··支持读写分离 
··支持全局表的功能 
··支持独有的基于er关系的分片策略 
··还支持一致性hash分片 
··多平台支持 部署简单方便 
··支持全局序列号 统一分发数据库的server id

 

安装使用mycat

首先 因为它是java开发的所以它需要有java的运行环境 下载mycat

 

1·读写分离：

 

主要配置文件说明：

 
    1. 1·server.xml：配置访问用户 密码 用户权限 可操作的数据库名称 比如testdb（此用户是可读还是可写）此用户并不需要是mysql系统账号 只是在mycat里边随便起一个虚拟用户 它自己会映射成数据库的真是授权用户
    2. 2·sechem.xml: 数据库信息 上边配置文件里的testdb到了此文件里会被重新定义
    3. <schema testdb 主要配置记录对哪个库进行操作
    4. <dateNode 记录的是数据节点 上述的testdb对应的真正的数据库的库名
    5. <hostnode
    6. write定义写入节点是谁
    7. read定义读数据节点是谁

关闭防火墙 关闭selinux 
然后分别在后端两台数据库创建两个相同的库以及表 但是插入的数据不要相同 这是为了演示效果

 
  1. 第一台数据库
  2. mysql> create database db
  3. -> ;
  4. Query OK, 1 row affected (0.11 sec)
  6. mysql> use db
  7. Database changed
  8. mysql> create table t1(id int,name char(10));
  9. Query OK, 0 rows affected (0.15 sec)
  11. mysql> show tables;
  12. +--------------+
  13. | Tables_in_db |
  14. +--------------+
  15. | t1 |
  16. +--------------+
  17. 1 row in set (0.01 sec)
  19. mysql> insert into ti values(‘1‘,‘xiao‘);
  20. ERROR 1146 (42S02): Table ‘db.ti‘ doesn‘t exist
  21. mysql> insert into t1 values(‘1‘,‘xiao‘);
  22. Query OK, 1 row affected (0.01 sec)
  24. mysql> select * from t1;
  25. +------+------+
  26. | id | name |
  27. +------+------+
  28. | 1 | xiao |
  29. +------+------+
  30. 1 row in set (0.00 sec)
  31. 第二台数据库
  32. mysql> create database db
  33. -> ;
  34. Query OK, 1 row affected (0.01 sec)
  36. mysql> use db
  37. Database changed
  38. mysql> create table t1(id int,name char(10));
  39. Query OK, 0 rows affected (0.24 sec)
  41. mysql> select * from t1
  42. -> ;
  43. Empty set (0.00 sec)
  44. mysql> insert into t1 values(‘45‘,‘hong‘);
  45. Query OK, 1 row affected (0.01 sec)
  47. mysql> select * from t1
  48. -> ;
  49. +------+------+
  50. | id | name |
  51. +------+------+
  52. | 45 | hong |
  53. +------+------+
  54. 1 row in set (0.00 sec)
  55. 两张表我们就添加完了 接下来我们给他们授权一个可远程登陆的账号 因为前端请求的是mycat mycat需要有账号可以读取你的数据库以及写入数据 给mycat所在的ip地址授权就可以
  56. mysql> grant all on db.* to [email protected]‘192.168.80.128‘ identified by ‘121109‘;
  57. Query OK, 0 rows affected (0.00 sec)
  58. mysql> grant all on db.* to [email protected]‘192.168.80.128‘ identified by ‘121109‘;
  59. Query OK, 0 rows affected (0.00 sec)
  60. 后端两台都需要进行授权 因为我们要实现读写分离 那么mycat就要对两台数据库都要有远程读写的权限 接下来到mycat主机上进行连接测试
  61. [[email protected] ~]# mysql -umycat -p121109 -h 192.168.80.143
  62. [[email protected] ~]# mysql -umycat -p121109 -h 192.168.80.144 均可登陆成功 一堆字母 略
 

安装部署mycat

 
  1. [[email protected] ~]# tar xf jdk-8u121-linux-x64.tar.gz -C /usr/local/
  2. [[email protected] ~]# tar xf Mycat-server-1.6-RELEASE-20161012170031-linux.tar.gz -C /usr/local/
  3. [[email protected] ~]# ls /usr/local/mycat/
  4. bin catlet conf lib logs version.txt
  5. [[email protected] local]# mv jdk1.8.0_121 java
  6. [[email protected] local]# ls
  7. bin games java lib64 mycat mysql-5.6.17-linux-glibc2.5-x86_64 share
  8. etc include lib libexec mysql sbin src
  9. [[email protected] ~]# vim /etc/profile 配置文件最后一行 填写jdk环境变量
  10. JAVA_HOME=/usr/local/java
  11. PATH=$JAVA_HOME/bin:$PATH
  12. export JAVA_HOME PATH
  13. [[email protected] local]# source /etc/profile
  14. [[email protected] local]# java -version
  15. java version "1.8.0_121"
  16. Java(TM) SE Runtime Environment (build 1.8.0_121-b13)
  17. Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)
  18. [[email protected] local]# cd /usr/local/mycat/conf/ 进入mycat的配置文件目录
  19. [[email protected] conf]# ls
  20. autopartition-long.txt myid.properties sequence_time_conf.properties
  21. auto-sharding-long.txt partition-hash-int.txt server.xml
  22. auto-sharding-rang-mod.txt partition-range-mod.txt sharding-by-enum.txt
  23. cacheservice.properties rule.xml wrapper.conf
  24. ehcache.xml schema.xml zkconf
  25. index_to_charset.properties sequence_conf.properties zk-create-2.yaml
  26. log4j2.xml sequence_db_conf.properties zk-create.yaml
  27. migrateTables.properties sequence_distributed_conf.properties zkdownload
  28. [[email protected] conf]# cp server.xml{,.bak}
  29. [[email protected] conf]# vim server.xml 这个文件创建mycat虚拟账号
  30. 74 <user name="test"> 这个test就是我给的虚拟账号 随便起
  31. 75 <property name="password">test</property> 这里的test是这个虚拟账号的密码随便
  32. 76 <property name="schemas">TESTDB</property> 这个TESTDB就是配置完成以后对应我们的数据库的真实库名
  33. 89 <user name="user">
  34. 90 <property name="password">user</property>
  35. 91 <property name="schemas">TESTDB</property>
  36. 92 <property name="readOnly">true</property>
  37. 这是我的第二个虚拟账号 但是可以看到比上边的用户明显多了一行 readonly true 意思是这个账号只能是读 那么在这里就可以通过这种方式控制哪个账号可写 那个账号可读 这个文件就先完了
  38. 接下来是第二个配置文件
  39. [[email protected] conf]# cp schema.xml{,.bak}
  40. [[email protected] conf]# vim schema.xml

 

配置文件解释

  1. 一·<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
  2. 这里TESTDB就是我们对外声称的我们有效数据库的名称 必须和server.xml中的用户指定的数据库名称一致 添加一个dataNode=“dn1” 是指定了我们在这个库只在dn1上没有进行分库
  3. 二· <dataNode name="dn1" dataHost="localhost1" database="db1" />
  4. 这里只需要将database的名字db1改为你所创建的数据库服务上的数据库名即可 它就是你的真实数据库名
  5. 三· <dataHost name="localhost1" maxCon="1000" minCon="10" balance="0" writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
  6. 这里只需要配置三个地方 balance=“1” writeType="0" switchType="1"
  7. A·balance 属于负载均衡类型
  8. 1·balance=“0” 不开启读写分离机制所有读操作都发送到当前可用的writehost上
  9. 2·balance=“1” 全部的readhost 参与select语句的负载均衡 主库只负责写 所有从库负责读的负载均衡
  10. 3·balance="2"所有读操作都随机在writehost readhost上进行分发 随机的
  11. 4`balance="3" 所有请求随机分发到writerhost对应的readhost 执行 writerhost不负担读压力
  12. B write Type 属性
  13. 1·writeType="0" 所有写操作发送到配置的第一个writeHost上执行 第一个挂了切到第二个writeHost 重新启动后以切换后的为准 切换记录在配置文件中的dnindex.properties
  14. 2·writeType=“1” 所有写操作都随机的发送到配置的writeHost
  15. C switch Type 属性
  16. --1表示不自动切换
  17. -1默认值 表示自动切换
  18. -2 基于MySQL主从同步的状态决定是否切换
  19. slaveThreshold="100"
  20. 开始支持MySQL主从复制状态绑定的读写分离机制 让读更加可靠 mycat心跳检测语句配置为show slvae status dataHost 上定义的两个新属性 switchType="2" 与 slaveThreshold="100" 100指的是position 这意味着开启MySQL主从复制状态绑定的读写分离切换机制 mycat心跳机制通过检测 show slave status中的seconds_Behind_Master slave_IO_Running slave_SQL_Running三个字段来确定当前主从同步状态以及seconds_Behind_Master主从复制延时当前seconds_Behind_Master大于slaveThreshold时 读写分离筛选器就会过滤掉此slave机器 防止读到很久之前的数据 而当主节点宕机后 切换逻辑会检查slave上的延时是否为0如果为0则表示可以安全切换 如果不为0则不会切换
  21. 四·<heartbeat>select user()</heartbeat>
  22. 心跳检查语句
  23. 五· <writeHost host="hostM1" url="localhost:3306" user="root" password="123456">
  24. 定义写入主机
  25. 六·<readHost host="hostS2" url="192.168.1.200:3306" user="root" password="xxx" /
  26. 定义读取数据主机
  27. 以下是配置文件：
  28. [[email protected] conf]# vim schema.xml
  30. 1 <?xml version="1.0"?>
  31. 2 <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
  32. 3 <mycat:schema xmlns:mycat="http://io.mycat/">
  33. 4
  34. 5 <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1" >
  35. 6 </schema>
  36. 7 <dataNode name="dn1" dataHost="localhost1" database="db" />
  37. 8 <dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
  38. 9 writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
  39. 10 <heartbeat>select user()</heartbeat>
  40. 11 <writeHost host="master-a" url="192.168.80.143:3306" user="mycat" password="121109">
  41. 12 <readHost host="master-slave" url="192.168.80.144:3306" user="mycat" password="121109" />
  42. 13 </writeHost>
  43. 14 </dataHost> 15 </mycat:schema>
  44. [[email protected] conf]# /usr/local/mycat/bin/mycat start
  45. Starting Mycat-server...
  46. [[email protected] conf]# netstat -antup | grep 806
  47. tcp 0 0 :::8066 :::* LISTEN 1671/java
  48. 可以查看日志 [[email protected] conf]# cat /usr/local/mycat/logs/wrapper.log
  49. 如果发现是一堆 那几本也就启动成功了 说明配置文件没错 接下来我们就开始进行测试了
  50. [[email protected] ~]# mysql -utest -ptest -P8066 -h 192.168.80.128 我们哟个mycat虚拟账号登陆 这个不是只读
  51. Warning: Using a password on the command line interface can be insecure.
  52. Welcome to the MySQL monitor. Commands end with ; or g.
  53. Your MySQL connection id is 1
  54. Server version: 5.6.29-mycat-1.6-RELEASE-20161012170031 MyCat Server (OpenCloundDB)
  56. Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
  58. Oracle is a registered trademark of Oracle Corporation and/or its
  59. affiliates. Other names may be trademarks of their respective
  60. owners.
  62. Type ‘help;‘ or ‘h‘ for help. Type ‘c‘ to clear the current input statement.
  64. mysql> show databases;
  65. +----------+
  66. | DATABASE |
  67. +----------+
  68. | TESTDB |我们看到了这个库 那这个库实际对应的就是我们后边所创建的db库
  69. +----------+
  70. 1 row in set (0.01 sec)
  71. mysql> use TESTDB
  72. Database changed
  73. mysql> show tables;
  74. +--------------+
  75. | Tables_in_db |
  76. +--------------+
  77. | t1 | 我们可以看到这个库了
  78. +--------------+
  79. 1 row in set (0.00 sec)
  81. mysql> select * from t1
  82. -> ;
  83. +------+------+
  84. | id | name | 这是里边的内容
  85. +------+------
  86. | 1 | xiao |
  87. +------+------+
  88. 1 row in set (0.10 sec)
  90. mysql> insert into t1 values(‘2‘,‘da‘);
  91. Query OK, 1 row affected (0.05 sec)
  93. mysql> select * from t1
  94. -> ;
  95. +------+------+
  96. | id | name | 这个账号我们看到还可以写
  97. +------+------+
  98. | 1 | xiao |
  99. | 2 | da |
  100. +------+------+
  101. 接下来测试那个user只读账号 这里说一句 我上边的配置文件里的balance是0所以现在并不是分离状态
  102. [[email protected] ~]# mysql -uuser -puser -P8066 -h192.168.80.128
  103. mysql> show tables; 上边一堆省略 这里我们可以看到这个账户也可以读 接下来测试他的写
  104. +--------------+
  105. | Tables_in_db |
  106. +--------------+
  107. | t1 |
  108. +--------------+
  109. 1 row in set (0.00 sec)
  111. mysql> select * from t1;
  112. +------+------+
  113. | id | name |
  114. +------+------+
  115. | 1 | xiao |
  116. | 2 | da |
  117. +------+------+
  118. 2 rows in set (0.01 sec)
  119. mysql> insert into t1 values(‘2‘,‘da‘);
  120. ERROR 1495 (HY000): User readonly 这里报错了 他是只读 接下来我们开始读写分离
  121. mysql>
  122. [[email protected] ~]# vim /usr/local/mycat/conf/schema.xml
  123. <?xml version="1.0"?>
  124. <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
  125. <mycat:schema xmlns:mycat="http://io.mycat/">
  127. <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1" />
  128. <dataNode name="dn1" dataHost="localhost1" database="db" />
  129. <dataHost name="localhost1" maxCon="1000" minCon="10" balance="1" 这里将其改为1
  130. writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
  131. <heartbeat>select user()</heartbeat>
  132. <writeHost host="master-a" url="192.168.80.143:3306" user="mycat" password="121109">
  133. <readHost host="master-slave" url="192.168.80.144:3306" user="mycat" password="121109" />
  134. </writeHost>
  135. </dataHost>
  136. </mycat:schema>
  137. [[email protected] ~]# /usr/local/mycat/bin/mycat restart
  138. [[email protected] ~]# mysql -utest -ptest -P8066 -h 192.168.80.128 写入账号测试
  139. Warning: Using a password on the command line interface can be insecure.
  140. Welcome to the MySQL monitor. Commands end with ; or g.
  141. Your MySQL connection id is 1
  142. Server version: 5.6.29-mycat-1.6-RELEASE-20161012170031 MyCat Server (OpenCloundDB)
  144. Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
  146. Oracle is a registered trademark of Oracle Corporation and/or its
  147. affiliates. Other names may be trademarks of their respective
  148. owners.
  150. Type ‘help;‘ or ‘h‘ for help. Type ‘c‘ to clear the current input statement.
  152. mysql> show databases;
  153. +----------+
  154. | DATABASE |
  155. +----------+
  156. | TESTDB |
  157. +----------+
  158. 1 row in set (0.01 sec)
  160. mysql> use TESTDB
  161. Reading table information for completion of table and column names
  162. You can turn off this feature to get a quicker startup with -A
  164. Database changed
  165. mysql> insert into t1 values(‘3‘,‘liang‘); 我们看到它已经写入成功了
  166. Query OK, 1 row affected (0.02 sec)
  168. mysql> select * from t1;
  169. +------+------+
  170. | id | name |
  171. +------+------+但是读却读不到了 这就已经分离了
  172. | 45 | hong |
  173. +------+------+
  174. 1 row in set (0.02 sec)
  175. 那么数据到底写入进去了吗 我们去对应的数据库查看
  176. mysql> select * from t1;
  177. +------+-------+
  178. | id | name | 那么balance=1表示读的时候主库不参与负载
  179. +------+-------+
  180. | 1 | xiao | 我们到了对应的库查看发现已经写入了
  181. | 2 | da |那么接下来测试读
  182. | 3 | liang |
  183. +------+-------+
  184. 3 rows in set (0.00 sec)
  185. 这时我将两台后端数据库开启了主从复制 我们在看看
  186. [[email protected] ~]# mysql -utest -ptest -P8066 -h 192.168.80.128 执行一个写入
  187. mysql> use TESTDB
  188. Reading table information for completion of table and column names
  189. You can turn off this feature to get a quicker startup with -A
  191. Database changed
  192. mysql> insert into t1 values(‘4‘,‘liangg‘);
  193. Query OK, 1 row affected (0.02 sec)
  194. mysql> exit
  195. [[email protected] ~]# mysql -uuser -puser -P8066 -h192.168.80.128
  196. mysql> use TESTDB
  197. Reading table information for completion of table and column names
  198. You can turn off this feature to get a quicker startup with -A
  200. Database changed
  201. mysql> select * from t1;
  202. +------+--------+
  203. | id | name |
  204. +------+--------+ 我们在读 这就是读写分离
  205. | 1 | xiao |
  206. | 2 | da |
  207. | 3 | liang |
  208. | 4 | liangg |
  209. +------+--------+
  210. 4 rows in set (0.01 sec)

 

那么 读写分离就到此结束了 其实就是几个配置 这样我们就可以给写入的写入账号 不需要写入的只给只读账号 这个都是可以指定库来进行分配的 
将主从关闭 测试以下环节

垂直分库

一个数据库由很多表的构成 每个表对应不同的业务 垂直切分是按照业务将表进行分类 分不到不同的数据库上面 这样也就将数据或者说压力分摊到不同的库上面了

  1. 在后端两个数据库上创建 同样的库 但是创建不同的表
  2. mysql> create database test1; 第一个库上创建了这个库 这个表
  3. Query OK, 1 row affected (0.00 sec)
  5. mysql> use test1;
  6. Database changed
  7. mysql> create table emp(id int,name char(10));###
  8. Query OK, 0 rows affected (0.15 sec)
  10. mysql> insert into emp values(‘1‘,‘liang‘);
  11. Query OK, 1 row affected (0.01 sec)
  12. 第二个数据库创建 同库名不同表
  13. mysql> create database test1;
  14. Query OK, 1 row affected (0.02 sec)
  16. mysql> use test1;
  17. Database changed
  18. mysql> create table dpt(did int,dname char(10));###
  19. Query OK, 0 rows affected (0.04 sec)
  21. mysql> insert into dpt values(‘1000‘,‘hr‘);
  22. Query OK, 1 row affected (0.00 sec)
  23. 然后对这两个新创建的库对远程操作进行授权
  24. grant all on test1.* to [email protected]‘192.168.80.128‘ identified by ‘121109‘; 两台都要操作
  25. 环境准备好以后我们开始配置mycat的用户文件
  26. [[email protected] ~]# vim /usr/local/mycat/conf/server.xml
  27. <user name="robin"> 配置文件下方再加一处就可以 不用给只读权限
  28. <property name="password">robin</property>
  29. <property name="schemas">test1</property>
  30. </user>
  31. 分别进入两个库为表创建主键
  32. mysql> alter table emp add primary key(id);
  33. 这是给第一个库的这个表创建了个主键 id
  34. mysql> alter table dpt add primary key(did);
  35. 这是给第二个库的这个表创建了个主键 did
  36. [[email protected] ~]# cd /usr/local/mycat/conf/
  37. [[email protected] conf]# mv schema.xml schema.xml.org
  38. [[email protected] conf]# mv schema.xml.bak schema.xml
  39. [[email protected] conf]# vim schema.xml
  40. <?xml version="1.0"?>
  41. <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
  42. <?xml version="1.0"?>
  43. <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
  44. <mycat:schema xmlns:mycat="http://io.mycat/">
  46. <schema name="test1" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
  47. <table name="emp" primaryKey="id" type="global" dataNode="dn1" />
  48. <table name="dpt" primaryKey="did" type="global" dataNode="dn2" />
  50. </schema>
  51. <dataNode name="dn1" dataHost="localhost1" database="test1" />
  52. <dataNode name="dn2" dataHost="localhost2" database="test1" />
  53. <dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
  54. writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
  55. <heartbeat>select user()</heartbeat>
  56. <writeHost host="master-a" url="192.168.80.143:3306" user="robin"
  57. password="121109">
  58. </writeHost>
  59. </dataHost>
  60. <dataHost name="localhost2" maxCon="1000" minCon="10" balance="0"
  61. writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
  62. <heartbeat>select user()</heartbeat>
  63. <writeHost host="master-b" url="192.168.80.144:3306" user="robin"
  64. password="121109">
  65. </writeHost>
  66. </dataHost>
  67. </mycat:schema>
  68. 他这个xml语言的这个规则太他妈烦人 大家请仔细 否则就报错 日志还看不懂
  69. 配置完以后 先到mycat端测试跟后方授权数据库授权账号是否能登陆
  70. mysql -urobin -p121109 -h 192.168.80.143
  71. mysql -urobin -p121109 -h 192.168.80.144 我这里都是成功的 也能查看到信息 过程省略
  72. 测试都连接成功后 由于我们修改了mycat的配置文件所以重启mycat
  73. [[email protected] conf]# /usr/local/mycat/bin/mycat restart
  74. [[email protected] conf]# netstat -antup | grep 8066 | grep -v grep
  75. tcp 0 0 192.168.80.128:33303 192.168.80.128:8066 TIME_WAIT -
  76. tcp 0 0 :::8066 :::* LISTEN 2912/java 2356/mysql
  77. 如果请不来 请查看你的mycat启动日志
  78. [[email protected] conf]# cat /usr/local/mycat/logs/wrapper.log
  79. 如果这个日志你一看是一堆那么基本是没问题的 如果是有顺有序的那基本是有问题的
  80. 接下来进行查看测试
  81. [[email protected] conf]# mysql -urobin -probin -h 192.168.80.128 -P8066
  82. mysql> show databases;
  83. +----------+
  84. | DATABASE |
  85. +----------+
  86. | test1 |
  87. +----------+
  88. 1 row in set (0.00 sec)
  90. mysql> use test1
  91. Reading table information for completion of table and column names
  92. You can turn off this feature to get a quicker startup with -A
  94. Database changed
  95. mysql> show tables;
  96. +-----------------+
  97. | Tables_in_test1 |
  98. +-----------------+
  99. | dpt | 大家要记得 这两个表是我们之前分别创建在两个不同的数据库上的
  100. | emp |
  101. +-----------------+
  102. 2 rows in set (0.00 sec)
  103. mysql> select * from dpt;
  104. +------+-------+
  105. | did | dname |
  106. +------+-------+ 进行一些查看 当然犯懒可以不看 没用
  107. | 1000 | hr |
  108. +------+-------+
  109. 1 row in set (0.21 sec)
  111. mysql> select * from emp;
  112. +----+-------+
  113. | id | name |
  114. +----+-------+
  115. | 1 | liang |
  116. +----+-------+
  117. 1 row in set (0.00 sec)
 

水平分库

水平切分相对于垂直拆分 水平拆分不是将表做分类 而是按照一定的某个字段的某种规则来分散到多个库之中 每个表中包含一部分数据 简单说就是可以将数据的水平切分理解为是按照数据行进行切分 就是将表中的某些行分切到一个库 而另外的行又分切到其他库 
环境部署：

 
    1. 在后端两个数据库上分别创建相同的库 以及创建相同的表
    2. mysql> create database upup; 这是在第一台mysql创建的库以及表 第二台同样操作
    3. Query OK, 1 row affected (0.11 sec)
    5. mysql> use upup;
    6. Database changed
    7. mysql> create table t1(id int,name char(10));
    8. Query OK, 0 rows affected (0.15 sec)
    9. mysql> grant all on upup.* to [email protected]‘192.168.80.128‘ identified by ‘121109‘; 两个库都授权
    10. 到 mycat端进行登陆测试
    11. 环境准备完了 配置mycat
    12. 分别为两个创建的表创建主键
    13. mysql> alter table t1 add primary key(id);
    14. [[email protected] conf]# vim server.xml
    15. 74 <user name="test">
    16. 75 <property name="password">test</property>
    17. 76 <property name="schemas">upup</property>
    18. 77
    19. 78 <!-- 表级 DML 权限设置 -->
    20. 79 <!--
    21. 80 <privileges check="false">
    22. 81 <schema name="TESTDB" dml="0110" >
    23. 82 <table name="tb01" dml="0000"></table>
    24. 83 <table name="tb02" dml="1111"></table>
    25. 84 </schema>
    26. 85 </privileges>
    27. 86 -->
    28. 87 </user>
    29. 88
    30. 89 <user name="user">
    31. 90 <property name="password">user</property>
    32. 91 <property name="schemas">upup</property>
    33. 92 <property name="readOnly">true</property>
    34. 93 </user>
    35. 94
    36. 95 <user name="robin">
    37. 96 <property name="password">robin</property>
    38. 97 <property name="schemas">upup</property>
    39. 98 </user>
    40. 99 </mycat:server>
    41. [[email protected] conf]# vim schema.xml
    42. 1 <?xml version="1.0"?>
    43. 2 <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
    44. 3 <mycat:schema xmlns:mycat="http://io.mycat/">
    45. 4
    46. 5 <schema name="upup" checkSQLschema="false" sqlMaxLimit="100">
    47. 6 <table name="t1" primaryKey="id" autoIncrement="true" dataNode="dn1,dn2" rule="rule1"/ > rule1算法
    48. 7
    49. 8 </schema>
    50. 9 <dataNode name="dn1" dataHost="localhost1" database="upup" />
    51. 10 <dataNode name="dn2" dataHost="localhost2" database="upup" />
    52. 11 <dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
    53. 12 writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshol d="100">
    54. 13 <heartbeat>select user()</heartbeat>
    55. 14 <writeHost host="master-a" url="192.168.80.143:3306" user="robin"
    56. 15 password="121109">
    57. 16 </writeHost>
    58. 17 </dataHost>
    59. 18 <dataHost name="localhost2" maxCon="1000" minCon="10" balance="0"
    60. 19 writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshol d="100">
    61. 20 <heartbeat>select user()</heartbeat>
    62. 21 <writeHost host="master-b" url="192.168.80.144:3306" user="robin"
    63. 22 password="121109">
    64. 23 </writeHost>
    65. 24 </dataHost>
    66. 25 </mycat:schema>
    67. [[email protected] conf]# netstat -antup | grep 8066 | grep -v grep
    68. [[email protected] conf]# cat /usr/local/mycat/logs/wrapper.log
    69. [[email protected] conf]# vim rule.xml
    70. <function name="func1" class="io.mycat.route.function.PartitionByLong">
    71. <property name="partitionCount">2</property>
    72. <property name="partitionLength">512</property>
    73. 这块儿我们刚才在schema.xml文件中使用的rule1算法 那么在这个算法文件中对应的算法就是这个func1 这个算法的意思是 将id除1924然后取余 如果余数在0~512之间就放在第一个数据库 如果在512~1024之间就放在第二个库 每个片区的区间是512 必须俩个相乘是1024 但是这个算法只适用于偶数台的后方数据片节点 这里只是测试
    74. 然后接下来给两个库所创建的表设置自动增长值
    75. mysql> alter table t1 modify id int auto_increment; 两台数据库都执行
    76. [[email protected] conf]# mysql -urobin -probin -P8066 -h 192.168.80.128 登陆
    77. Warning: Using a password on the command line interface can be insecure.
    78. Welcome to the MySQL monitor. Commands end with ; or g.
    79. Your MySQL connection id is 2
    80. Server version: 5.6.29-mycat-1.6-RELEASE-20161012170031 MyCat Server (OpenCloundDB)
    82. Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
    84. Oracle is a registered trademark of Oracle Corporation and/or its
    85. affiliates. Other names may be trademarks of their respective
    86. owners.
    88. Type ‘help;‘ or ‘h‘ for help. Type ‘c‘ to clear the current input statement.
    90. mysql> use upup 切换到库
    91. Reading table information for completion of table and column names
    92. You can turn off this feature to get a quicker startup with -A
    94. Database changed
    95. mysql> insert into t1(id,name) values(‘1‘,‘robin‘); 插入值 1除以1024=1
    96. Query OK, 1 row affected (0.21 sec) 这时我们查看后方两个数据库只有一个里边有值 因为我们还没有超过我们创建的值
    97. mysql> insert into t1(id,name) values(‘512‘,‘robin‘);
    98. Query OK, 1 row affected (0.02 sec)
    99. 再执行这条语句你在看看后方数据库节点就会发现 它写入到另一个库中去了
    100. [[email protected] conf]# mysql -urobin -probin -P8066 -h 192.168.80.128



























以上是关于mycat的主要内容，如果未能解决你的问题，请参考以下文章

Mycat原理应用场景

数据库路由中间件MyCat - 源代码篇

数据库路由中间件MyCat - 源代码篇

MyCat使用实例

Mycat 1.6.5 分片导入时报2013代码解决方法

MyCat 入门：漫谈 MyCat 配置系统