MyCat实现读写分离+分库分表+全局表

前言

mycat功能强大，配置简单，作为数据库中间件，是一个非常优秀的开源产品，关于MyCat的部署安装，可以参考博文：MyCat部署安装。

本博文将展示mycat的如下功能：

  • 读写分离；
  • 分库分表；
  • 全局表；

环境如下：

系统 IP 主机名 服务
Centos 7.5 192.168.20.2 mysql01 MySQL 5.7.24
Centos 7.5 192.168.20.3 mysql02 MySQL 5.7.24
Centos 7.5 192.168.20.3 mysql03 MySQL 5.7.24
Centos 7.5 192.168.20.4 mycat Mycat

注：主机mysql01和mysql02为主从复制关系，可以参考博文MySQL高可用方案——双主（注：只需要参考博文做出主从效果即可，并不需要双主，也不需要keepalived来做高可用）来搭建。mycat服务请参考博文MyCat部署安装来搭建，这里新增的主机mysql03为一个刚刚搭建好的mysql服务器，可以参考博文Centos部署MySQL 5.7来搭建。

1、mycat实现读写分离

这里没有用到mysql03主机，读写分离的实现比较简单，只需要修改mycat的下面两个配置文件即可。如下：

1）修改server.xml文件

[[email protected] mycat]# pwd
/usr/local/mycat   <!--此处为mycat的家目录-->
[[email protected] mycat]# vim conf/server.xml
<!--指定client连接mycat的用户名及密码，此处的账号密码与MySQL数据库无关-->
[[email protected] mycat]# vim conf/server.xml    <!--定位到80行左右，修改如下-->
        <user name="mycat" defaultAccount="true">  <!--mycat为用户名-->
                <property name="password">[email protected]</property>   <!--此处为用户mycat的登录密码-->
                <property name="schemas">test_mycat</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>

2）修改schema.xml文件

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<!--下面的schema必须和第一个文件中的schema name（逻辑库名）一致。-->
        <schema name="test_mycat" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
        </schema>
        <dataNode name="dn1" dataHost="host1" database="test" />    <!--这里的database是指定要连接后端的哪个数据库，这里连接的是test库-->
                <!--下面是指定后端真实的MySQL主机，关于下面的balance值，有三个可选值，将在下面写下来-->
        <dataHost name="host1" maxCon="1000" minCon="10" balance="3"
                          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.20.2:3306" user="root"
                                   password="123.com">
                        <!-- can have multi read hosts -->
                                                <!--指定后端哪台主机用来读数据-->
                        <readHost host="hostS2" url="192.168.20.3:3306" user="root" password="123.com" />
                </writeHost>
        </dataHost>
</mycat:schema>

注：上面提到的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"，所有读请求随机的分发到 wiriterHost 对应的 readhost 执行，writerHost 不负担读压力，注意 balance=3 只在 1.4 及其以后版本有，1.3 没有。

writeTyep字段有以下3中取值：

1、writeType="0", 所有写操作发送到配置的第一个 writeHost，第一个挂了切到还生存的第二个 writeHost，重新启动后已切换后的为准，切换记录在配置文件中:dnindex.properties 。
2、writeType="1"，所有写操作都随机的发送到配置的 writeHost，1.5 以后废弃不推荐。switchType 属性

  • -1 表示不自动切换。
  • 1 默认值，自动切换。
  • 2 基于 MySQL 主从同步的状态决定是否切换。

修改后的完整配置文件如下（为避免冗余，删除了部分注释）：

server.xml配置文件内容如下：

[[email protected] mycat]# vim conf/server.xml 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mycat:server SYSTEM "server.dtd">
<mycat:server xmlns:mycat="http://io.mycat/">
        <system>
        <property name="useSqlStat">0</property>  <!-- 1为开启实时统计、0为关闭 -->
        <property name="useGlobleTableCheck">0</property>  <!-- 1为开启全加班一致性检测、0为关闭 -->

                <property name="sequnceHandlerType">2</property>
                <property name="processorBufferPoolType">0</property>
                <property name="handleDistributedTransactions">0</property>

                <property name="useOffHeapForMerge">1</property>
                <property name="memoryPageSize">1m</property>
                <property name="spillsFileBufferSize">1k</property>

                <property name="useStreamOutput">0</property>
                <property name="systemReserveMemorySize">384m</property>

                <property name="useZKSwitch">true</property>

        </system>
        <user name="mycat" >
                <property name="password">[email protected]</property>
                <property name="schemas">test_mycat</property>
        </user>
</mycat:server>

schema.xml配置文件内容如下：

[[email protected] mycat]# vim conf/schema.xml

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">

        <schema name="test_mycat" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
        </schema>
        <dataNode name="dn1" dataHost="host1" database="test" />
        <dataHost name="host1" maxCon="1000" minCon="10" balance="3"
                          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.20.2:3306" user="root"
                                   password="123.com">
                        <!-- can have multi read hosts -->
                        <readHost host="hostS2" url="192.168.20.3:3306" user="root" password="123.com" />
                </writeHost>
        </dataHost>
</mycat:schema>

注：至此，后端数据库上自行创建有相关权限的用户，比如我在上面的datahost字段中指定的writehost和readhost字段的user值为root，则数据库的root账号要有对应的登录权限（默认root用户只允许在localhost登录，所以要自行修改root权限或换成其他有权限的用户）。

总结：
1.指定的后端数据库登录用户，必须可以有相应的权限；
2.在上面指定的后端真实数据库为test，所以后端必须要有这个test库；

3）启动mycat并测试读写分离效果

[[email protected] mycat]# mycat start       #启动mycat
[[email protected] mycat]# mysql -umycat [email protected] -h 192.168.20.4 -P 8066   #登录到mycat
#192.168.20.4为mycat主机IP，mycat监听端口为8066，使用的登录用户为server.xml文件中创建的用户
#创建表并插入一些测试数据
mysql> use test_mycat;
mysql> create table t1 (id int,name varchar(4));
mysql> insert into t1 values(1,‘张三‘),(2,‘李四‘),(3,‘王五‘);
#此时，去后端数据库上查看，应该是有上面这些数据的。
#现在可以暂时关闭后端数据库的主从复制，然后再mycat主机上继续插入数据，测试是否可以读到
#关闭主从复制命令：stop slave;
#以下操作还是在mycat主机进行
mysql> insert into t1 values(4,‘赵六‘);    #插入一条数据
Query OK, 1 row affected (0.01 sec)

mysql> select * from t1;      #查询不到刚插入的数据，说明读写操作没有在同一台主机上进行
+------+--------+
| id   | name   |
+------+--------+
|    1 | 张三   |
|    2 | 李四   |
|    3 | 王五   |
+------+--------+
#可以去后端两个数据库分别进行查看数据
#mysql01主机的数据如下（说明写操作是在mysql01）：
mysql> select * from t1;
+------+--------+
| id   | name   |
+------+--------+
|    1 | 张三   |
|    2 | 李四   |
|    3 | 王五   |
|    4 | 赵六   |
+------+--------+
4 rows in set (0.00 sec)
#mysql02主机的数据如下：
mysql> select * from t1（说明读操作是在mysql02）;
+------+--------+
| id   | name   |
+------+--------+
|    1 | 张三   |
|    2 | 李四   |
|    3 | 王五   |
+------+--------+
3 rows in set (0.00 sec)

读写分离效果至此结束。（为不影响后面的测试进行，最好恢复mysql01和mysql02主机的主从复制）。

2、mycat实现分库

一个数据库由很多表组成，每个表对应着不同的业务，所谓分库，就是按照业务将表进行分类，分不到不同的数据库上面，这样也就将数据或者说压力分担到不同的库上面，分库的原则：有紧密关联关系的表应该在一个库里，相互没有或者关联关系不大的表可以分到不同的库里。

分库举例：

假设现在有四张表： customer， orders， orders_detail， dict_order_type，每张表都有数百万条数据，那么这四张表如若要实现分库，则可以将customer表单独分离到一个数据库，另外三张表单独在另一个数据库。

1）修改server.xml文件（就改了一下逻辑库名）

[[email protected] mycat]# cat conf/server.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mycat:server SYSTEM "server.dtd">
<mycat:server xmlns:mycat="http://io.mycat/">
    <system>
    <property name="useSqlStat">0</property>  <!-- 1为开启实时统计、0为关闭 -->
    <property name="useGlobleTableCheck">0</property>  <!-- 1为开启全加班一致性检测、0为关闭 -->

        <property name="sequnceHandlerType">2</property>
        <property name="processorBufferPoolType">0</property>
        <property name="handleDistributedTransactions">0</property>

        <property name="useOffHeapForMerge">1</property>
        <property name="memoryPageSize">1m</property>
        <property name="spillsFileBufferSize">1k</property>

        <property name="useStreamOutput">0</property>
        <property name="systemReserveMemorySize">384m</property>

        <property name="useZKSwitch">true</property>

    </system>
    <user name="mycat" >
        <property name="password">[email protected]</property>
        <property name="schemas">test_db</property>
    </user>
</mycat:server>

2）修改schema.xml文件

[[email protected] mycat]# cat conf/schema.xml
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">

    <schema name="test_db" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
        <table name="customer" dataNode="dn2"/>   <!--这里指定customer在dn2节点上-->
    </schema>
    <dataNode name="dn1" dataHost="host1" database="test" />
    <dataNode name="dn2" dataHost="host2" database="test" />
    <dataHost name="host1" maxCon="1000" minCon="10" balance="3"
              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.20.2:3306" user="root"
                   password="123.com">
            <!-- can have multi read hosts -->
            <readHost host="hostS2" url="192.168.20.3:3306" user="root" password="123.com" />
        </writeHost>
    </dataHost>
    <!--下面添加host2主机字段，指定的主机就是mysql03-->
    <dataHost name="host2" 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="hostM2" url="192.168.20.21:3306" user="root"
                   password="123.com">
        </writeHost>
    </dataHost>
</mycat:schema>

3）重启mycat

[[email protected] mycat]# mycat restart

注：后端指定的真实数据库必须要有test数据库，因为在上面schema.xml文件中的dataNode字段指定的是连接后端的test数据库。

4）测试分库效果

#登录到mycat
[[email protected] mycat]# mysql -umycat [email protected] -h 192.168.20.4 -P 8066
#创建相应的表
mysql> use test_db;
mysql> CREATE TABLE customer(
    -> id_a INT AUTO_INCREMENT,
    -> NAME VARCHAR(200),
    -> PRIMARY KEY(id_a)
    -> );
Query OK, 0 rows affected (0.02 sec)

mysql> CREATE TABLE orders(
    -> id_b INT AUTO_INCREMENT,
    -> order_type INT,
    -> customer_id INT,
    -> amount DECIMAL(10,2),
    -> PRIMARY KEY(id_b)
    -> );
Query OK, 0 rows affected (0.01 sec)

mysql> CREATE TABLE orders_detail(
    -> id_c INT AUTO_INCREMENT,
    -> detail VARCHAR(2000),
    -> order_id INT,
    -> PRIMARY KEY(id_c)
    -> );
Query OK, 0 rows affected (0.02 sec)

mysql> CREATE TABLE dict_order_type(
    -> id_d INT AUTO_INCREMENT,
    -> order_type VARCHAR(200),
    -> PRIMARY KEY(id_d)
    -> );
Query OK, 0 rows affected (0.01 sec)

#登录到后端数据库上，查看表是否按照预计的效果拆分
[[email protected] mycat]# mysql -uroot -p123.com -h 192.168.20.2
mysql> use test;

mysql> show tables;             #可以看到主机mysql01这里有三个表
+-----------------+
| Tables_in_test  |
+-----------------+
| dict_order_type |
| orders          |
| orders_detail   |
+-----------------+
3 rows in set (0.00 sec)

#登录到mysql03上查看
[[email protected] mycat]# mysql -uroot -p123.com -h 192.168.20.21
mysql> use test;

mysql> show tables;     #可以看到这里只有customer表
+----------------+
| Tables_in_test |
+----------------+
| customer       |
+----------------+
1 row in set (0.00 sec)

至此，已经实现了分库，多个表放在了不同的库中（在上面的栗子中，实现的是多个表放在了不同的主机上），但对于通过mycat登录的客户来说，还是一个库，库中有四张表。

3、mycat实现分表

这里对一个新表emp进行拆分。

1）schema.xml文件修改如下（完整配置文件）

[[email protected] mycat]# cat conf/schema.xml
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">

    <schema name="test_db" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
        <table name="customer" dataNode="dn2"/>
        <!--只需要在原来的配置文件中增加下面一行即可，表示将emp表分在了dn1和dn2这两个节点上-->
        <table name="emp" dataNode="dn1,dn2" rule="mod_rule"/>
    </schema>
    <dataNode name="dn1" dataHost="host1" database="test" />
    <dataNode name="dn2" dataHost="host2" database="test" />
    <dataHost name="host1" maxCon="1000" minCon="10" balance="3"
              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.20.2:3306" user="root"
                   password="123.com">
            <!-- can have multi read hosts -->
            <readHost host="hostS2" url="192.168.20.3:3306" user="root" password="123.com" />
        </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>
        <!-- can have multi write hosts -->
        <writeHost host="hostM2" url="192.168.20.21:3306" user="root"
                   password="123.com">
        </writeHost>
    </dataHost>
</mycat:schema>

2）rule.xml文件添加以下内容

[[email protected] mycat]# vim conf/rule.xml      #修改rule.xml文件
        <tableRule name="mod_rule">    <!--这里指定的name必须和schema.xml中指定的name一致-->
                <rule>
                        <columns>id</columns>    <!--这里指定的是以哪里列进行分表的-->
                        <algorithm>mod_long</algorithm>  <!--这里指定的是分片方法-->
                </rule>
        </tableRule>
                        ...................
                                                <!--下面的name必须和上面的分片方法一致-->
        <function name="mod_long" class="io.mycat.route.function.PartitionByMod">
                <!-- how many data nodes -->
                <property name="count">2</property>    <!--这里指定的是node节点数量-->
        </function>

3）重启mycat并登录到mycat

[[email protected] mycat]# mycat restart

4）登录到mycat插入数据进行测试分表效果

[[email protected] mycat]# mysql -umycat [email protected] -h 192.168.20.4 -P 8066
mysql> use test_db;
#创建emp表（后端两个数据库节点上都会有这张表）
mysql> create table emp (
    -> id int,
    -> name varchar(10)
    -> );
Query OK, 0 rows affected (0.41 sec)
#插入多条数据（对于这种分表，插入数据需要指定列名，否则会报错）
mysql> insert into emp(id,name) values(1,‘张三‘),(2,‘李四‘),(3,‘王五‘),(4,‘赵六‘);
#查询新插入的数据
mysql> select * from emp;
+------+--------+
| id   | name   |
+------+--------+
|    2 | 李四   |
|    4 | 赵六   |
|    1 | 张三   |
|    3 | 王五   |
+------+--------+
4 rows in set (0.04 sec)
mysql> select * from emp order by id;    #对结果进行排序
+------+--------+
| id   | name   |
+------+--------+
|    1 | 张三   |
|    2 | 李四   |
|    3 | 王五   |
|    4 | 赵六   |
+------+--------+
4 rows in set (0.01 sec)

#后端mysql01主机查询到该表的数据如下：
mysql> select * from emp;
+------+--------+
| id   | name   |
+------+--------+
|    2 | 李四   |
|    4 | 赵六   |
+------+--------+
2 rows in set (0.00 sec)
#mysql03主机查询到的数据如下：
mysql> select * from emp;
+------+--------+
| id   | name   |
+------+--------+
|    1 | 张三   |
|    3 | 王五   |
+------+--------+
2 rows in set (0.00 sec)

可以看到数据是平均分散在不同节点上保存的。

但是经过分片的普通表，是无法直接和其他表进行join的。

要想解决多表join的问题，还需要修改schema.xml配置文件，在分表的table字段下添加childTable字段，具体怎么实现，还在研究中。但是可以将分表的类型设置为全局表，这是一种比较简单的实现方式。

3、全局表

分表后，与其他表如何join就成了比较棘手的问题，我们可以选择将分表设置为全局表，这是一个解决join的方法（但不是唯一的方法），但全局表有一定的局限性，如下：

  • 全局表变动不频繁；
  • 数据量总体变化不大；
  • 数据规模不大，很少有超数十万的记录。

全局表有以下特性：

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

若想创建全局表，只需在table字段增加type="global"即可。如下：

1）定义全局表

[[email protected] conf]# cat schema.xml
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">

    <schema name="test_db" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
        <table name="customer" dataNode="dn2"/>
        <!--在下面的table字段增加global属性即可-->
        <table name="emp" dataNode="dn1,dn2" type="global">
        </table>
    </schema>
    <dataNode name="dn1" dataHost="host1" database="test" />
    <dataNode name="dn2" dataHost="host2" database="test" />
    <dataHost name="host1" maxCon="1000" minCon="10" balance="3"
              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.20.2:3306" user="root"
                   password="123.com">
            <!-- can have multi read hosts -->
            <readHost host="hostS2" url="192.168.20.3:3306" user="root" password="123.com" />
        </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>
        <!-- can have multi write hosts -->
        <writeHost host="hostM2" url="192.168.20.21:3306" user="root"
                   password="123.com">
        </writeHost>
    </dataHost>
</mycat:schema>

2）验证全局表

mysql> drop table emp;    #需要删除之前创建的emp表
Query OK, 0 rows affected (0.03 sec)
#重新创建emp表
mysql> create table emp(
    -> id int,
    -> name varchar(10)
    -> );
Query OK, 0 rows affected (0.38 sec)
#插入数据测试
mysql>  insert into emp(id,name) values(1,‘张三‘),(2,‘李四‘),(3,‘王五‘),(4,‘赵六‘);
#在mycat上查询插入的数据如下：
mysql> select * from emp;
+------+--------+
| id   | name   |
+------+--------+
|    1 | 张三   |
|    2 | 李四   |
|    3 | 王五   |
|    4 | 赵六   |
+------+--------+
4 rows in set (0.02 sec)
#在后端主机上分别查看emp表中的数据：
#mysql01主机上数据如下：
mysql> select * from emp;
+------+--------+
| id   | name   |
+------+--------+
|    1 | 张三   |
|    2 | 李四   |
|    3 | 王五   |
|    4 | 赵六   |
+------+--------+
4 rows in set (0.00 sec)
#mysql03主机上数据如下：
mysql> select * from emp;
+------+--------+
| id   | name   |
+------+--------+
|    1 | 张三   |
|    2 | 李四   |
|    3 | 王五   |
|    4 | 赵六   |
+------+--------+
4 rows in set (0.00 sec)

原文地址：https://blog.51cto.com/14154700/2470283

时间： 2024-11-03 10:49:09

MyCat实现读写分离+分库分表+全局表的相关文章

Mycat 读写分离+分库分表

上次进过GTID复制的学习记录,已经搭建好了主从复制的服务器,现在利用现有的主从复制环境,加上正在研究的Mycat,实现了主流分布式数据库的测试 Mycat就不用多介绍了,可以实现很多分布式数据库的功能,极大的减轻数据库服务器的压力,包括读写分离以及分库分表,本测试对这两种功能都进行了测试,进行相应记录 本文以Mycat官方给出的例子来进行解释总结 首先来看分库分表,分库分表一般来说都是一起说的,但是实际上分库跟分表是有区别的,简单来说有垂直和水平两种方式,垂直就是将表按字段进行拆分,水平就是将

重新学习Mysql数据13：Mysql主从复制，读写分离，分表分库策略与实践

一.MySQL扩展具体的实现方式 随着业务规模的不断扩大,需要选择合适的方案去应对数据规模的增长,以应对逐渐增长的访问压力和数据量. 关于数据库的扩展主要包括:业务拆分.主从复制.读写分离.数据库分库与分表等.这篇文章主要讲述数据库分库与分表 (1)业务拆分 在?大型网站应用之海量数据和高并发解决方案总结一二?一篇文章中也具体讲述了为什么要对业务进行拆分. 业务起步初始,为了加快应用上线和快速迭代,很多应用都采用集中式的架构.随着业务系统的扩大,系统变得越来越复杂,越来越难以维护,开发效率变得越

mycat基础实验之主从配置读写分离和分表

mycat实验之主从配置读写分离和分表 架构图: 1.实验环境: vmware虚机3个   (虚机太少了,电脑有点吃力,3个虚机只能达到基本的测试) 系统centos7     (实验是关闭防火墙和selinux做的) mysql版本5.7 mycat版本1.6 虚机名字和ip: mysql1 192.168.211.138 mysql2 192.168.211.139 mysql3 192.168.211.142 mycat安装在mysql1(192.168.211.138) 这台主机须能够解

Mycat实现读写分离

场景介绍: 第一组:MySQL 普通主从配置(1主1从)情况下,读写分离模式的测试验证MySQL 普通主从配置(1主1从)情况下,自动切换的模式的验证 mycat实现读写分离. 节点宕机切换.

Mycat实现读写分离（一）

Mycat介绍 Mycat是一个国产中间件产品,作用在应用层和数据库之间架桥,使应用通过MyCat来对后端数据库进行管理,是一款国人自主的开源的中间件产品.算是比较优秀的一款,前身是阿里公司在维护,很多公司也慢慢的在尝试接入这个产品,但不得不说官方文档似乎做的不太友好.至于为什么选择MyCat可能只有使用者知道了,下面我们用比较通俗的语言来介绍这款产品,也方便自己以后翻阅. Mycat的安装 1)由于需要JDK支持,首先安装JDK环境: [[email protected] local]# ta

springboot2.0+mycat实验读写分离

声明:用户到达一定程度,架构就必须要考虑,因为在这个前提下,读写分离,尤为重要. 1.搭建mysql主从复制 https://www.cnblogs.com/ywjfx/p/10264383.html 2.安装并配置mycat实现读写分离 https://www.cnblogs.com/ywjfx/p/10320758.html 3.代码实现读写分离 https://github.com/812406210/springboot-mycat 这样就实现了! 有问题可以留言,整个过程本人都一个个尝

使用Mycat实现MySQL的分库分表、读写分离、主从切换

Mycat及MySQL实例部署情况:Mycat:IP:10.20.8.57,Port:3310/3311MySQL :db1-M1,IP:10.20.8.126,Port:3306db1-M2,IP:10.20.8.126,Port:3307db2-M1,IP:10.25.80.7,Port:3307架构图如下: 配置Mycatserver.xml: <!DOCTYPE mycat:server SYSTEM "server.dtd"> <mycat:server x

(转)学会数据库读写分离、分表分库——用Mycat，这一篇就够了！

原文:https://www.cnblogs.com/joylee/p/7513038.html 系统开发中,数据库是非常重要的一个点.除了程序的本身的优化,如:SQL语句优化.代码优化,数据库的处理本身优化也是非常重要的.主从.热备.分表分库等都是系统发展迟早会遇到的技术问题问题.Mycat是一个广受好评的数据库中间件,已经在很多产品上进行使用了.希望通过这篇文章的介绍,能学会Mycat的使用. 安装 Mycat官网:http://www.mycat.io/可以了解下Mycat的背景和应用情况

学会数据库读写分离、分表分库——用Mycat

系统开发中,数据库是非常重要的一个点.除了程序的本身的优化,如:SQL语句优化.代码优化,数据库的处理本身优化也是非常重要的.主从.热备.分表分库等都是系统发展迟早会遇到的技术问题问题.Mycat是一个广受好评的数据库中间件,已经在很多产品上进行使用了.希望通过这篇文章的介绍,能学会Mycat的使用. 安装 Mycat官网:http://www.mycat.io/可以了解下Mycat的背景和应用情况,这样使用起来比较有信心. Mycat下载地址:http://dl.mycat.io/官网有个文档