Redis整合MySQL和MyCAT分库组件

Posted 2021-03-31 Java资料站

优质文章，第一时间送达

  作者 |  hsm_computer

来源 |  urlify.cn/6JJRVn

MyCAT是一个开源的分布式数据库组件，在项目里，一般用这个组件实现针对数据库的分库分表功能，从而提升对数据表，尤其是大数据库表的访问性能。而且在实际项目里，MyCAT分库分表组件一般会和mysql以及Redis组件整合使用，这样就能从“降低数据表里数据量规模”和“缓存数据”这两个维度提升对数据的访问性能。

 1 分库分表概述

     先通过一个实例来看下分库分表的概念，比如在某电商系统里，存在一张主键为id的流水表，如果该电商系统的业务量很大，这张流水表很有可能达到“亿”级规模，甚至更大。如果要从这张表里查询数据，哪怕用到索引等数据库优化的措施，但毕竟数据表的规模太大，这会成为性能上的瓶颈，所以可以按如下的思路拆分这张大的流水表。

    1 在不同的10个数据库，同时创建这10张流水表，这些表的表结构完全一致。
    2 在1号数据库里，只存放id%10等于1的流水记录，比如存放id是1、11和21等的流水记录，在2号数据库里只存放id%10等于2的流水记录，以此类推。
    也就是说，通过上述步骤，能把这张流水表拆分成10个字表，而MyCAT组件能把应用程序对流水表的请求分散到10张子表里，具体的效果下图所示。

 

     在实际项目里，子表的个数可以根据实际需求来设置。由于把大表的数据分散到若干张子表里，所以每次数据请求所面对的数据总量能有效降低，从中大家能感受到“分表”做法对提升数据库访问性能的帮助。

并且在实际项目里，会尽量把子表分散创建到不同的主机上，而不是单纯地在同一台主机同一个数据库上创建多个子表，也就是说，需要尽量把这些子表分散到不同的数据库上，具体效果如下图所示。

 

    尽量对子表进行“分库”还是出于提升性能的考虑。由于单台数据库处理请求时总会有性能瓶颈，比如每秒最多能处理500个请求。如果把这些子表放在同一台主机的同一个数据库上，那么对该表的请求速度依然无法突破单台数据库的性能瓶颈。但如果把这些子表分散到不同主机的不同数据库上，那么对该表的请求就相当于被有效分摊到不同的数据库上，这样就能成n倍地提升数据库的有效负载。

    在实际项目里，出于成本上的考虑，或许无法为每个子表分配一台主机，在这种情况下可以退而求其次，可以把不同的子表分散创建在同一主机的不同数据库上，总之尽量别在同一主机同一数据库上创建不同的子表。
也就是说，通过“分表”，能有效降低大表的数据规模，通过“分库”，能整合多个数据库，从而能提升处理请求的有效负载。而MyCAT分布式数据库组件，实现这种“分库分表”的效果，所以通常就把它叫做“MyCAT分库分表组件”。
事实上，MyCAT组件能解析SQL语句，并根据预先设置好的分库字段和分库规则，把该SQL发送到对应的子表上执行，再把执行好的结果再返回给应用程序。

2 用MyCAT组件实现分库分表 

    在上文里已经提到，用MyCAT可以实现分库分表的效果，该组件默认工作在8066端口，它和应用程序以及数据库的关系如下图所示。从中大家可以看到，Java应用程序不是直接和MySQL等数据库互连，而是和MyCAT组件连接。应用程序是把SQL请求发送到MyCAT，而MyCAT根据配置好的分库分表规则，把请求发送到对应的数据库上，得到请求再返回给应用程序。

    

     为了实现分库分表的效果，一般需要配置MyCAT组件里如下表所示的三个文件。

 

    这里将以一个MyCAT组件连接三个数据库为例，具体给出上述三个配置文件的编写范例。
    第一，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="serverPort">8066</property>
           <property name="managerPort">9066</property>
       </system>
       <user name="root">
           <property name="password">123456</property>
           <property name="schemas">redisDemo</property>
       </user>
   </mycat:server>

    在第5行和第6行里，分别配置了该MyCAT组件的工作端口和管理端口为8066和9066，在第8行到第11行的代码里，配置了连接该MyCAT组件的用户名是root，连接密码是123456，同时，该root登录后，可以访问MyCAT组件里的redisDemo数据库。
    请注意这里redisDemo是MyCAT组件的数据库，而不是MySQL里的，在实践过程中，这个数据库一般和MySQL里的同名。
    第二，schema.xml配置文件的代码如下所示。

<?xml version="1.0"?>
   <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
   <mycat:schema xmlns:mycat="http://io.mycat/">
       <schema name="redisDemo">
           <table name="student" dataNode="dn1,dn2,dn3" rule="mod-long"/>
       </schema>
       <dataNode name="dn1" dataHost="host1" database="redisDemo" />
       <dataNode name="dn2" dataHost="host2" database="redisDemo" />
       <dataNode name="dn3" dataHost="host3" database="redisDemo" />
       <dataHost name="host1" dbType="mysql" maxCon="10" minCon="3" balance="0" writeType="0" dbDriver="native">
           <heartbeat>select     user()</heartbeat>
           <writeHost host="hostM1" url="172.17.0.2:3306" user="root" password="123456"></writeHost>
       </dataHost>
       <dataHost name="host2" dbType="mysql" maxCon="10" minCon="3" balance="0" writeType="0" dbDriver="native">
           <heartbeat>select     user()</heartbeat>
            <writeHost host="hostM2" url="172.17.0.3:3306" user="root" password="123456"></writeHost>
        </dataHost>
       <dataHost name="host3" dbType="mysql" maxCon="10" minCon="3" balance="0" writeType="0" dbDriver="native">
           <heartbeat>select     user()</heartbeat>
            <writeHost host="hostM3" url="172.17.0.4:3306" user="root" password="123456"></writeHost>
        </dataHost>
   </mycat:schema>

     

    第三，rule.xml配置文件的代码如下所示。

<?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE mycat:rule SYSTEM "rule.dtd">
   <mycat:rule xmlns:mycat="http://io.mycat/">
       <tableRule name="mod-long">
           <rule>
               <columns>id</columns>
               <algorithm>mod-long</algorithm>
           </rule>
       </tableRule>

       <function name="mod-long" class="io.mycat.route.function.PartitionByMod">
           <property name="count">3</property>
       </function>
   </mycat:rule>

    在第4行里定义了mod-long这个规则，该规则在schema.xml第5行里被用到，再结合第11行到第13行的代码，能看到利用该规则对student表分库时，将先对id进行模3处理，然后再根据取模后的结果，到host1到host3所在的数据表的student库里进行处理。这里取模的数值3，是需要和MySQL主机的数量相同。
    上述三个配置文件综合起来，给出了如下针对分库分表相关动作的定义。
    1. 应用程序如果如果要使用MyCAT，需要用root用户名外带123456密码连接到该MyCAT组件。
    2. 比如要插入id为1的stduent数据，根据在schema.xml里的定义，会先根据mod-long规则，对id进行模3处理，结果是1，所以会插入到host2所定义的172.17.0.3:3306数据库的student表里，如果要进行读取、删除和更新操作，也会先对id模3，然后再把该请求发送到对应的数据库里。
    这里仅给出了MyCAT分库的一种比较常用的规则（即取模），也只是把stduent表分散到3个物理数据表里，事实上通过编写配置，可以用其它算法，让MyCAT组件把数据表分散到更多的子表里。

3 Java、MySQL与MyCAT的整合范例

    这里将以“一个MyCAT组件连接三个MySQL数据库，对student表进行分库”的需求为例，结合上文给出的MyCAT三个配置文件，给出基于Docker容器设置MyCAT分库分表的详细步骤，并在此基础上，给出Java应用程序连接MyCAT以实现分库分表的代码范例。

    步骤一，先通过如下3个Docker命令，准备3个包含MySQL的Docker容器。

1    docker run -itd -p 3306:3306 --name mysqlHost1 -e MYSQL_ROOT_PASSWORD=123456 mysql:latest
2    docker run -itd -p 3316:3306 --name mysqlHost2 -e MYSQL_ROOT_PASSWORD=123456 mysql:latest
3    docker run -itd -p 3326:3306 --name mysqlHost3 -e MYSQL_ROOT_PASSWORD=123456 mysql:latest

1    docker inspect mysqlHost1
2    docker inspect mysqlHost2
3    docker inspect mysqlHost3

    

    步骤二，通过docker exec -it mysqlHost1 /bin/bash命令进入到mysqlHost1容器，随后再用mysql -u root -p命令进入到mysql数据库，进入时需要输入的密码是123456，随后运行如下的命令创建redisDemo数据库和student表。

1    create database redisDemo;
2    use redisDemo;
3    create table student( id int not null primary key,name char(20),age int,score float);

<dataHost name="host1" dbType="mysql" maxCon="10" minCon="3" balance="0" writeType="0" dbDriver="native">
           <heartbeat>select     user()</heartbeat>
           <writeHost host="hostM1" url="172.17.0.2:3306" user="root" password="123456"></writeHost>
       </dataHost>
       <dataHost name="host2" dbType="mysql" maxCon="10" minCon="3" balance="0" writeType="0" dbDriver="native">
           <heartbeat>select     user()</heartbeat>
            <writeHost host="hostM2" url="172.17.0.3:3306" user="root" password="123456"></writeHost>
        </dataHost>
       <dataHost name="host3" dbType="mysql" maxCon="10" minCon="3" balance="0" writeType="0" dbDriver="native">
           <heartbeat>select     user()</heartbeat>
            <writeHost host="hostM3" url="172.17.0.4:3306" user="root" password="123456"></writeHost>
        </dataHost>

    步骤五，再确保上述三个Docker里包含的My SQL都处于可用状态后，通过如下的Docker命令启动MyCAT对应的docker容器。

1    docker run --name mycat -p 8066:8066 -p 9066:9066 -v C:workmycatconfserver.xml:/opt/mycat/conf/server.xml:ro -v C:workmycatconfschema.xml:/opt/mycat/conf/schema.xml:ro -v C:workmycatconf
ule.xml:/opt/mycat/conf/rule.xml:ro -d mycat:latest

    请注意该docker命令的如下要点。

    1 通过-p参数，把该MyCAT组件的工作端口8066和管理端口9066映射到主机里的同名端口。
    2 通过三个-v参数，把容器外C:workmycatconf目录里的三个MyCAT配置文件映射到容器内的/opt/mycat/conf/目录里，这样启动时，就能读到这三个配置文件。这样做的前提是，事先已经确认过容器内的server.xml等三个配置文件存在于/opt/mycat/conf/目录里，如果有些mycat镜像里的这三个配置文件不存在于这个目录，则可以先用docker exec -it mycat /bin/bash命令进入该mycat容器，找到这三个配置文件对应的位置后，再改写上述启动mycat容器的docker run命令。
    3 通过mycat:latest参数指定该容器是基于mycat:latest镜像生成的。
    运行完上述docker run命令后，可以通过docker logs mycat命令观察包含在该容器内的MyCAT组件的启动日志。如果成功启动，就能看到日志里有如下图10.12所示的提示成功的信息。如果有错误，那么或者去检查三个MySQL数据库的连接状态，或者根据日志里给出的错误提示来排查问题。

     

    至此完成了MyCAT组件和三个MySQL数据库的相关配置，在如下的MyCATSimpleDemo范例中，将给出Java程序通过MyCAT组件向MySQL数据库插入数据的做法，从中大家能感受到分库分表的效果。 

import java.sql.*;
   public class MyCATSimpleDemo {
       public static void main(String[] args){
           //定义连接对象和PreparedStatement对象
           Connection myCATConn = null;
           PreparedStatement ps = null;
           //定义连接信息
           String mySQLDriver = "com.mysql.jdbc.Driver";
           String myCATUrl = "jdbc:mysql://localhost:8066/redisDemo";
           String user = "root";
           String pwd = "123456";
           try{
               Class.forName(mySQLDriver);
               myCATConn = DriverManager.getConnection(myCATUrl, user, pwd);
               ps = myCATConn.prepareStatement("insert into student (id,name,age,score) values (?,'test',18,100)");
               ps.setString(1,"11");
               ps.addBatch();
               ps.setString(1,"12");
               ps.addBatch();
               ps.setString(1,"13");
               ps.addBatch();
               ps.executeBatch();
           } catch (SQLException se) {
               se.printStackTrace();
           } catch (Exception e) {
               e.printStackTrace();
           }
           finally{
               //如果有必要，释放资源
               if(ps != null){
                   try {
                       ps.close();
                   } catch (SQLException e) {
                       e.printStackTrace();
                   }
               }
               if(myCATConn != null){
                   try {
                       myCATConn.close();
                   } catch (SQLException e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   }

    在本范例的第14行里，创建了指向MyCAT组件的连接对象myCATConn，请注意它是指向localhost的8066端口，用root和123456连接到redisDemo数据库，这和在server.xml里的配置相吻合。在随后的第15行里，是用myCATConn创建PreparedStatement类型的ps对象，并在第16行到第21行的代码里，通过addBatch方法批量组装了三条insert语句，请注意它们的id分别是11、12和13，最后在第22行的代码里，通过executeBatch语句执行了这三条insert语句。

    从中大家可以看到，通过MyCAT连接对象执行SQL语句的方式和直接用MySQL连接对象的方式基本相同，而且在获取MyCAT连接对象时，只需要对应地更改连接url即可。也就是说，MyCAT组件在实现分库分表时，对应用程序来说是透明的，它完全分离了“数据操作的业务动作”和“数据操作的底层实现”，所以如果要在一个系统里引入MyCAT分库分表组件，修改的点非常有限，对原有业务的影响并不大。
再来看下分库分表的效果，通过docker exec -it mysqlHost1 /bin/bash命令进入到mysqlHost1容器，随后再用mysql -u root -p命令进入到mysql数据库，用use redisDemo;命令进入到redisDemo数据库后，执行select * from student;命令，只能看到一条数据，如下图所示。

 

    同样地，在mysqlHost2和mysqlHost3所在的数据库里，也只能看到一条数据，这三个数据库里存储的student数据如下表所示。

    

    从中大家可以看到，根据id模3取值的不同，MyCAT组件分别把它们分散到了3个数据库里。由于本书的重点是Redis，所以就不再给出用MyCAT组件进行删除、更新和查询操作的相关范例，不过如果大家用上述范例中的myCATConn连接对象以及用它生成的ps对象，实现相关操作的效果也不难。

    这里student表中的数据规模很小，其实无法体现出分库分表的优势，但如果这张表的规模很大，比如达到百万级甚至更高，那么通过MyCat组件引入分库分表效果后，就相当于把针对这张大表的压力均摊到了若干张子表上，就能更好地应对高并发的场景。

 

粉丝福利：Java从入门到入土学习路线图