mycat实现主从复制读写分离-读写分离

之前说过主从复制，现在说下我是如何基于mycat搭建读写分离的（这里是搭建一个基本模型）

 

首先下载一个mycat的镜像，然后准备要挂载的文件，然后启动就ok了。

mycat目录如下

sequence_conf.properties

TB_USER.HISIDS=
TB_USER.MINID=1
TB_USER.MAXID=20000
TB_USER.CURID=1

 

rule.xml=配置分片规则（当然我这里不需要，我只是基于主库复制写，从库复制读的sql查询分配）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mycat:rule SYSTEM "rule.dtd">
<mycat:rule xmlns:mycat="http://io.mycat/">
    <tableRule name="userrule">
        <rule>
            <columns>id</columns>
            <algorithm>func1</algorithm>
        </rule>
    </tableRule>
    <tableRule name="categoryrule">
        <rule>
            <columns>id</columns>
            <algorithm>jump-consistent-hash</algorithm>
        </rule>
    </tableRule>

    <function name="murmur"
        class="io.mycat.route.function.PartitionByMurmurHash">
        <property name="seed">0</property><!-- 默认是0 -->
        <property name="count">2</property><!-- 要分片的数据库节点数量，必须指定，否则没法分片 -->
        <property name="virtualBucketTimes">160</property><!-- 一个实际的数据库节点被映射为这么多虚拟节点，默认是160倍，也就是虚拟节点数是物理节点数的160倍 -->
        <!-- <property name="weightMapFile">weightMapFile</property> 节点的权重，没有指定权重的节点默认是1。以properties文件的格式填写，以从0开始到count-1的整数值也就是节点索引为key，以节点权重值为值。所有权重值必须是正整数，否则以1代替 -->
        <!-- <property name="bucketMapPath">/etc/mycat/bucketMapPath</property>
            用于测试时观察各物理节点与虚拟节点的分布情况，如果指定了这个属性，会把虚拟节点的murmur hash值与物理节点的映射按行输出到这个文件，没有默认值，如果不指定，就不会输出任何东西 -->
    </function>

    <function name="crc32slot"
              class="io.mycat.route.function.PartitionByCRC32PreSlot">
        <property name="count">2</property><!-- 要分片的数据库节点数量，必须指定，否则没法分片 -->
    </function>
    <function name="hash-int"
        class="io.mycat.route.function.PartitionByFileMap">
        <property name="mapFile">partition-hash-int.txt</property>
    </function>
    <function name="rang-long"
        class="io.mycat.route.function.AutoPartitionByLong">
        <property name="mapFile">autopartition-long.txt</property>
    </function>
    <function name="mod-long" class="io.mycat.route.function.PartitionByMod">
        <!-- how many data nodes -->
        <property name="count">4</property>
    </function>

    <function name="func1" class="io.mycat.route.function.PartitionByLong">
        <property name="partitionCount">8</property>
        <property name="partitionLength">128</property>
    </function>
    <function name="latestMonth"
        class="io.mycat.route.function.LatestMonthPartion">
        <property name="splitOneDay">24</property>
    </function>
    <function name="partbymonth"
        class="io.mycat.route.function.PartitionByMonth">
        <property name="dateFormat">yyyy-MM-dd</property>
        <property name="sBeginDate">2015-01-01</property>
    </function>
    
    <function name="rang-mod" class="io.mycat.route.function.PartitionByRangeMod">
            <property name="mapFile">partition-range-mod.txt</property>
    </function>
    
    <function name="jump-consistent-hash" class="io.mycat.route.function.PartitionByJumpConsistentHash">
        <property name="totalBuckets">4</property>
    </function>
</mycat:rule>

tableRule=

    name : schema.xml中table标签中对应的rule属性,也就是配置表的分片规则
    columns : 是表的切分字段
    algorithm : 是规则对应的切分规则,对应function标签的name属性

function = 配置是分片规则的配置

    name : 切分规则的名称,对应tableRule标签的algorithm属性
    class : 是切分规则对应的切分类,写死,需要哪种规则则配置哪种
    property : 标签是切分规则对应的不同属性,不同的切分规则配置不同
 

server.xml=用户信息配置（连接mycat的配置）sequnceHandlerType代表意思如下（默认为0，我这里就没有写上去）

    0 : 使用本地方式作为数据库自增,设置 sequence_conf.properties配置文件
        GLOBAL.HISIDS=
        GLOBAL.MINID=10001 最小值
        GLOBAL.MAXID=20000 最大值
        GLOBAL.CURID=10000 当前值
    1 : 使用的是本地数据库的方式,需要在一个分节点创建MYCAT_SEQUENCE表和存储过程,其中MYCAT_SEQUENCE必须为大写
    2 : 自动生成64为的时间戳,设置配置sequence_db_conf.properties,指定sequence相关配置在哪个节点上
 

<?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为关闭 -->
    
    </system>
    <user name="root">
        <property name="password">root</property>
        <property name="schemas">test</property>  #mycat逻辑库,对应schemas.xml里schema标签的name属性,多个逻辑库用逗号隔开
    </user>
</mycat:server>

 

schema.xml=配置逻辑数据（关键地方，这里会要你提供真实要连接的数据库名和连接地址密码等）

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
    <schema name="test" checkSQLschema="false" dataNode="dn1">     

      #为了说明时候方便，复制代码时请删除<table name="tb_user" primaryKey="id" autoIncrement="true" #dataNode="dn1,dn2,dn3,dn4" rule="userrule" />
    </schema>
    <dataNode name="dn1" dataHost="localhost1" database="cvc_training_enterprise" />
    <dataHost name="localhost1" maxCon="1000" minCon="10" balance="3"
              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
        <heartbeat>select user()</heartbeat>
        <writeHost host="hostM1" url="120.24.5.**:32778" user="main"
                   password="***">
            <readHost host="hostS2" url="120.24.5.**:32779" user="main" password="***" />
        </writeHost>
    </dataHost>
</mycat:schema>

schema : 是实际逻辑库的配置,多个schema代表多个逻辑库

    table : 是逻辑表的配置（我这里不配置这个，因为我不用进行数据表分片，如果配置了，就需要给出分片规则）
        name : 代表表名（真实表名）
        primaryKey : 主键
        autoIncrement : 开启自动增长,不使用自动增长就不要加
        dataNode : 代表表对应的分片,Mycat默认采用分库方式,也就是一个表映射到不同的库上,对应dataNode标签的name,多个  用  逗号隔开，就是schema标签下面的dataNode标签中的name对应的值
        rule代表表要采用的数据切分方式,名称对应到rule.xml中tableRule标签的name属性,如果要分片必须配置

dataNode : 是逻辑库对应的分片,如果配置多个分片只需要多个dataNode即可

    name : dataNode的名
    dataHost : 是实际的物理库配置地址,可以配置多主主从等其他配置,对应dataHost标签的name属性
    database : 映射实际的物理库名称，根据你自己的情况改动

dataHost : 配置物理库分片映射

    balance : 读的负载均衡类型
        balance=“0” : 不开启读写分离机制,所有读操作都发送到当前可用的writeHost上
        balance=“1” : 全部的readHost与stand by writeHost参与select语句的负载均衡,简单的说,当双主双从模式(M1->S1,M2->S2,并且M1与 M2互为主备),正常情况下,M2,S1,S2都参与select语句的负载均衡
        balance=“2” : 所有读操作都随机的在writeHost、readhost上分发
        balance=“3” : 所有读请求随机的分发到wiriterHost对应的readhost执行,writerHost不负担读压力注意,只在 1.4 及其以后版本有
    writeType : 写的负载均衡类型
        writeType=“0” : 所有写操作发送到配置的第一个 writeHost,第一个挂了切到还生存的第二个 ,writeHost,重新启动后已切换后的为准,切换记录在配置文件中:dnindex.properties
        writeType=“1” : 所有写操作都随机的发送到配置的 writeHost,1.5 以后废弃不推荐
    switchType : 切换的模式
        switchType="-1" : 表示不自动切换
        switchType=“1” : 默认值，表示自动切换
        switchType=“2” : 基于MySQL主从同步的状态决定是否切换,心跳语句为 show slave status;
        switchType=“3” : 基于MySQL galary cluster的切换机制(适合集群)心跳语句为 show status like ‘wsrep%’;
    writeHost : 逻辑主机（dataHost）对应的后端的物理主机映射.mysql主
        readHost : mysql从
 

 

接下来就是创建对应容器，记住要去暴露自己的8066和9066端口我是阿里云的直接是去配出入规则

docker run --name mycat -v /home/docker-compose/mycat/schema.xml:/usr/local/mycat/conf/schema.xml -v /home/docker-compose/mycat/rule.xml:/usr/local/mycat/conf/rule.xml -v /home/docker-compose/mycat/server.xml:/usr/local/mycat/conf/server.xml -v /home/docker-compose/mycat/sequence_conf.properties:/usr/local/mycat/conf/sequence_conf.properties --privileged=true -p 8066:8066 -p 9066:9066 -e MYSQL_ROOT_PASSWORD=root -d longhronshens/mycat-docker

 

启动完成可以使用navicat进行测试或者直接进入docker容器中进行测试

提供一个测试思路，你要测试是否有实现你的代理，写主读从，首先你要明白你直接进入从库容器写一条数据主库是不会跟着生成一条数据（这个是之前就配置主从复制决定的），那么你通过mycat写一条数据查看是否从库生成了就能看出是否有代理写操作了，接下来你不经过mycat往从库中某一表写一条数据，在通过mycat去读，主库去读，从库去读（该表全部数据）在观察他们的主键直增的变化，mycat和从库都以读到数据而且主键都大于主库1则可以证明读都是通过从库