什么是Mycat？为什么要使用MyCat?

最新推荐文章于 2024-09-09 15:00:37 发布
最新推荐文章于 2024-09-09 15:00:37 发布
阅读量835 收藏 2
点赞数 1
分类专栏： 自我提升 文章标签： java 数据库 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guozai0904/article/details/126891627
版权

什么是Mycat？

Mycat是数据库中间件

 因为放在数据库和应用程序中间，所以叫中间件。是不是觉得有点多余，直接连接数据库不香么？

为什么要使用MyCat?

1.可以应用程序连接到多个数据库

2.缓解单个数据库压力，提升了数据库的访问量与并发量

3.实现了应用程序的高可用，数据库的高可用。

 当然可能会有疑问，各个数据库的数据不一致了怎么办，主要mysql,oracle都有主从复制机制，不做详细介绍。

MyCat能干什么呢？

1.读写分离

 

 配置mycat 的schema.xml 文件，大致如下

<dataNode name="dn1" dataHost="localhost1" database="db03" /> 
	<dataHost name="localhost1" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100"> 
		<heartbeat>select user()</heartbeat> 
		<writeHost host="hostM1" url="127.0.0.1:3306" user="root" password="pwd"> 
			<readHost host="hostS1" url="127.0.0.2:3306" user="root" password="pwd" /> 
		</writeHost> 
			
		<writeHost host="hostM2" url="127.0.0.3:3306" user="root" password="pwd"> 
			<readHost host="hostS2" url="127.0.0.4:3306" user="root" password="pwd" /> 
		</writeHost> 
	</dataHost>

balance ：
    负载均衡类型, 目前取值有4种: 
    
    balance="0" : 不开启读写分离机制 , 所有读操作都发送到当前可用的writeHost上. 
    
    balance="1" : 全部的readHost 与 stand by writeHost (备用的writeHost) 都参与 select 语句的负载均衡,
    简而言之,就是采用双主双从模式(M1 --> S1 , M2 --> S2, 正常情况下， M2,S1,S2 都参与 select 语句的负载均衡。); 
    
    balance="2" : 所有的读写操作都随机在writeHost , readHost上分发 
    
    balance="3" : 所有的读请求随机分发到writeHost对应的readHost上执行, writeHost不负担 读压力 ;balance=3 只在MyCat1.4 之后生效 .

writeType 

        一般配置0

writeType=“0”, 所有写操作都发送到可用的writeHost上。

writeType=“1”，所有写操作都随机的发送到readHost。

writeType=“2”，所有写操作都随机的在writeHost、readhost分上发。

switchType

表示不自动切换： -1

默认值，自动切换： 1  如果第一个主节点宕机后,Mycat会进行3次心跳检测,如果3次都没有响应,则会自动切换到第二个主节点，并且会更新/conf/dnindex.properties文件的主节点信息 localhost1=0 表示第一个节点.该文件不要随意修改否则会出现大问题

switchType=2，基于MySQL主从同步的状态决定是否切换，心跳语句为show slave status。此时设置slaveThreshold=100表示从节点落后主库100秒就会剔除这个从节点

使用中遇到的问题

        1.主从复制延迟高,因为数据库设置了触发器，导致更新数据慢，同时也引起了主从复制延时高的问题

        2.刚插入数据，立刻查询查询不到，特别是mysql设置了自增长主键，必须要查一次的时候

解决方案

        1.强制走主库查询，可通过注解的形式     /*#mycat:db_type=master*/

注解支持的’!‘不被 mysql 单库兼容，
注解支持的’#'不被 mybatis 兼容

/*#mycat:db_type=master*/ select * from travelrecord
/*!mycat:db_type=slave*/ select * from travelrecord

其他注解

1. Mycat 端执行存储创建表或存储过程为：
 存储过程：
/*!mycat: sql=select 1 from user*/  存储过程sql ;
 表：
/*!mycat: sql= select 1 from user */ 建表sql;
插入数据：
/*!mycat: sql= select 1 from user */插入sql;
注意注解中语句是节点的表请替换成自己表如 select 1 from user ，注解内语句查出来的数据在哪个分片，数据在那个节点往哪个节点执行后面的sql

2. 读写分离
配置了 Mycat 读写分离后，默认查询都会从读节点获取数据，但是有些场景需要获取实时数据，如果从读节点获取数据可能因延时而无法实现实时，Mycat 支持通过注解/*balance*/来强制从写节点查询数据：
a. 事务内的 SQL，默认走写节点，以注解/*balance*/开头，则会根据 schema.xml 的 dataHost 标签属性的
balance=“1”或“2”去获取节点
b. 非事务内的 SQL，开启读写分离默认根据 balance=“1”或“2”去获取，以注解/*balance*/开头则会走写节
点解决部分已经开启读写分离，但是需要强一致性数据实时获取的场景走写节点
/*balance*/ select  *  from user;
4. 多表 ShareJoin（分库分表的时候用，实际我也没有用过）
/*!mycat:catlet=demo.catlets.ShareJoin */ select a.*,b.id, b.name as tit from customer a,company b on
a.company_id=b.id;
4.读写分离数据源选择
/*!mycat:db_type=master*/ select * from user
/*!mycat:db_type=slave*/ select * from user
/*#mycat:db_type=master*/ select * from user
/*#mycat:db_type=slave*/ select * from user
5. 多租户支持
通过注解方式在配置多个 schema 情况下，指定走哪个配置的 schema。
web 部分修改：
a.在用户登录时，在线程变量（ThreadLocal）中记录租户的 id
b.修改 jdbc 的实现：在提交 sql 时，从 ThreadLocal 中获取租户 id, 添加 sql 注释，把租户的 schema放到注释中。例如：/*!mycat : schema = test_01 */ sql ;
 在 db 前面建立 proxy 层，代理所有 web 过来的数据库请求。proxy 层是用 mycat 实现的，web 提交的 sql 过来时在注释中指定 schema, proxy 层根据指定的 schema 转发 sql 请求。
/*!mycat : schema = test_01 */ sql ;

2.数据分片

两个典型例子

        垂直拆分——分库

 一个数据库由很多表的构成，每个表对应着不同的业务，垂直切分是指按照业务将表进行分类，
分布到不同 的数据库上面，这样也就将数据或者说压力分担到不同的库上面，如下图：

分库的原则：有紧密关联关系的表应该在一个库里，相互没有关联关系的表可以分到不同的库里。

垂直拆分的优点：

  1. 拆分后业务清晰，拆分规则明确
  2. 系统之间进行整合或扩展很容易
  3. 按照成本、应用的等级、应用的类型等将表放到不同的机器上便于管理数据
  4. 维护相对简单

垂直拆分的缺点：

  1. 部分业务表无法Join,只能单表查询或通过接口方式解决，提高了系统的复杂度
  2. 受每种业务的不同限制，存在单库性能瓶颈，不易进行数据扩展和提升性能
  3. 事务处理变复杂

mycat具体如何分库？

编辑myca/conf/schema.xml文件

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

        <schema name="agencyDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
	<!-- 指定表名到对应dn2节点,其他默认dn1 -->
            <table name="user_info" dataNode="dn2" ></table>
	        <table name="mobile_info" dataNode="dn2" ></table>
        </schema>
	<!-- 配置了两个节点  -->
        <dataNode name="dn1" dataHost="host1" database="testdb" />
        <dataNode name="dn2" dataHost="host2" database="testdb" />
        <dataHost name="host1" 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="127.0.0.1:3306" user="root"
                                   password="123456">
                </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="127.0.0.2:3306" user="root"
                                   password="123456">
                </writeHost>
        </dataHost>
</mycat:schema>

所有需要拆分的表都需要在table标签中定义

基于以上拆分的user_info和mobile_info 两个表则可以拆分至host2中

另外一个思路,根据微服务拆分成不同的schema，每个微服务对应一个schema则可

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

        <schema name="agencyDB1" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
        </schema>
        <schema name="agencyDB2" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn2">
        </schema>
	<!-- 配置了两个节点  -->
        <dataNode name="dn1" dataHost="host1" database="userdb" />
        <dataNode name="dn2" dataHost="host2" database="orderdb" />
        <dataHost name="host1" 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="127.0.0.1:3306" user="root"
                                   password="123456">
                </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="127.0.0.2:3306" user="root"
                                   password="123456">
                </writeHost>
        </dataHost>
</mycat:schema>

 思考，如果分库后单个表的数据量仍然到达千万级

水平拆分——分表

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

 水平拆分的优点：

  1. 单库单表的数据能保持在一定的量级，有助于性能的提高。
  2. 切分的表结构相同，应用层改造较少，只需要增加路由规则即可。
  3. 提高了系统的稳定性和负载能力。

水平拆分的缺点：

  1. 切分后，数据是分散的，跨库join操作难和性能差
  2. 拆分规则难以抽象
  3. 分片事务的一致性难以解决
  4. 数据扩容的难度和维护量极大

mycat实现分表

假设test表已经有1000万数据了。单表达到1000万条数据就达到了瓶颈，会影响查询效率， 需要进行水平拆分（分表）进行优化。

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

        <schema name="agencyDB1" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
         <table name="test" dataNode="dn1,dn2" rule="mod_rule" ></table>
        </schema>
      
	<!-- 配置了两个节点  -->
        <dataNode name="dn1" dataHost="host1" database="userdb" />
        <dataNode name="dn2" dataHost="host2" database="userdb" />
        <dataHost name="host1" 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="127.0.0.1:3306" user="root"
                                   password="123456">
                </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="127.0.0.2:3306" user="root"
                                   password="123456">
                </writeHost>
        </dataHost>
</mycat:schema>

核心配置是table标签,指定分片规则为mod_rule

配置rule.xml

新加tableRule配置

<tableRule name="mod_rule">
<rule>
<columns>id</columns>
<algorithm>od-long</algorithm>
</rule>
</tableRule>

name：指定唯一的名字，用于标识不同的表规则。
columns：指定要拆分的列名字。
algorithm：使用function标签中的name属性，连接表规则和具体路由算法

mod-long规则为配置文件自带的，修改count属性。代表意思为，根据count数取模

<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
        <!-- how many data nodes -->
        <property name="count">3</property>
</function>

根据以上规则假设数据id是1-10，那么id是 1，4，7，10 的数据在一个节点，id是2，5，8 的数据在一个节点，id是3，6，9的数据在一个节点

这是最常用的取模运算分片规则

枚举规则

通过在配置文件中配置可能的枚举id，自己配置分片，本规则适用于特定的场景，比如有些业务需要按照国内国际类型不同保存订单信息

修改schema.xml文件

<table name="orders" dataNode="dn1,dn2" rule="sharding_by_type" ></table>

修改rule.xml文件

  <tableRule name="sharding_by_type">
                <rule>
                        <columns>type</columns>
                        <algorithm>hash-int</algorithm>
                </rule>
        </tableRule>
  • columns：分片字段
  • algorithm：分片函数
     <function name="hash-int" class="io.mycat.route.function.PartitionByFileMap">
                <property name="mapFile">hash-int.txt</property>
                <property name="type">1</property>
                <property name="defaultNode">0</property>
        </function>
  • mapFile：标识配置文件名称
  • type：0为int型、非0为String
  • defaultNode：默认节点。小于 0 表示不设置默认节点，大于等于 0 表示设置默认节点，设置默认节点如果碰到不识别的枚举值，就让它路由到默认节点，如不设置不识别就报错。

修改配置文件hash-int.txt文件

CHN=0
INT=1

范围分片

此分片适用于提前规划好分片字段某个范围属于哪个分片。

 修改schema.xml文件

<table name="orders" dataNode="dn1,dn2" rule="sharding_by_range" ></table>

修改rule.xml文件

  <tableRule name="sharding_by_range">
                <rule>
                        <columns>id</columns>
                        <algorithm>range-long</algorithm>
                </rule>
        </tableRule>
  • columns：分片字段
  • algorithm：分片函数
     <function name="ranage-long"  class="io.mycat.route.function.AutoPartitionByLong">
                <property name="mapFile">range-long.txt</property>
                <property name="defaultNode">0</property>
        </function>
  • mapFile：标识配置文件名称
  • defaultNode：默认节点。小于 0 表示不设置默认节点，大于等于 0 表示设置默认节点，设置默认节点如果碰到不识别的枚举值，就让它路由到默认节点，如不设置不识别就报错。

修改配置文件range-long.txt文件

0-100=0
101-200=1

以上将id是0-100 的数据分到一个节点，101-200的数据分到一个节点

日期分片

配置步骤：

修改配置文件schema.xml

<table name="login_info" dataNode="dn1,dn2" rule="sharding_by_date" ></table>


修改配置文件rule.xml

        <tableRule name="sharding_by_date">
                <rule>
                        <columns>create_at</columns>
                        <algorithm>shardingByDate</algorithm>
                </rule>
        </tableRule>


columns：分片字段
algorithm：分片函数
 

      <function name="shardingByDate" class="io.mycat.route.function.PartitionByDate">
                <property name="dateFormat">yyyy-MM-dd</property>
                <property name="sBeginDate">2022-01-01</property>
                <property name="sEndDate">2025-01-01</property>
                <property name="sPartionDay">2</property>
        </function>


dateFormat ：日期格式
sBeginDate ：开始日期
sEndDate：结束日期，则代表数据达到了这个日期的分片后循环从开始分片插入，也可以不设置
sPartionDay ：分区天数，即默认从开始日期算起，分隔2天一个分区
 

还有一些其他方法，未深入研究

何时分库分表

非必要不分库，非必要不分表

IO瓶颈

第一种：磁盘读IO瓶颈，热点数据太多，数据库缓存放不下，每次查询会产生大量的IO，降低查询速度->分库和垂直分表
第二种：网络IO瓶颈，请求的数据太多，网络带宽不够 ->分库

CPU瓶颈

第一种：SQl问题：如SQL中包含join,group by, order by，非索引字段条件查询等，增加CPU运算的操作->SQL优化，建立合适的索引，在业务Service层进行业务计算。
第二种：单表数据量太大，查询时扫描的行太多，SQl效率低，增加CPU运算的操作。->水平分表。

其他分库分表中间件

sharding-jdbc（当当）
TSharding（蘑菇街）
Atlas（奇虎360）
Cobar（阿里巴巴）
Oceanus（58同城）
Vitess（谷歌）

我都没用过，不了解

guozai0904
关注
专栏目录
Mycat数据库中间件详解，来看看为什么要用Mycat？
assdfgdfgjhtdo的博客
01-05 736
在Mycat入门学习前，当然要先了解Mycat是什么，有什么作用。 Mycat是什么？ Mycat是一个开源数据库中间件，是一个实现了MySQL协议的的数据库中间件服务器，我们可以把它看作是一个数据库代理，用MySQL客户端工具和命令行访问Mycat，而Mycat再使用用MySQL原生(Native)协议与多个MySQL服务器通信，也可以用JDBC协议与大多数主流数据库服务器通信，包括SQL Server、Oracle、DB2、PostgreSQL等主流数据库，也支持MongoDB这种新型NoS.
mycat 使用demo
06-11
本文将基于"Mycat使用demo"进行详细介绍，旨在为初学者提供一个清晰的学习路径。 **一、Mycat简介** Mycat 是一款开源的分布式数据库中间件，源自ChinaPus项目，主要功能是将SQL路由到不同的数据库集群，实现数据的...
Mycat读写分离查询数据不一致问题，查询强制走主库
Java全栈领域/离线地图/微服务
12-01 3423
问题描述： 线上环境mysql三库集群，读写分离，一个主数据库（写），两个从数据库（读），数据使用日志的方式同步，由于读和写不是同一个库，切三个数据库之间的数据是半同步（主库写完后，从库通过数据库日志一条一条同步数据），当插入数据后立马查询，会出现查不到的问题。 解决方法（Mybatis） 对于插入后立马要查询的数据（强实时性的数据），可以使用注解的方式强制走主库，就是在Mybatis的查询语句前面加上以下注解。 /**mycat:db_type=master*/ 示例： <select id=
MyCat是什么？为什么要用MyCat？
iteye_7361的博客
02-21 1387
实习的时候，在一个项目当中，项目经理要求把原先的MySQL数据连接基于mycat来进行改造 。当时就在想MyCat是什么东西？为什么要用它呢？ *一、什么是MyCat： MyCat是一个开源的分布式数据库系统，是一个实现了MySQL协议的服务器，前端用户可以把它看作是一个数据库代理，用MySQL客户端工具和命令行访问，而其后端可以用MySQL原生协议与多个MySQL服务器通信，也可以用JDB...
mycat双主高可用架构部署-mycat一主一从配置
最新发布
龙哥·三年风水从2011年开始做IT工作，从ps画图到前端开发->后端开发->框架开发->业务架构设计及开发->业务需求整理、开发->技术经理->技术总监
09-09 129
mycat双主高可用架构部署-mycat一主一从配置
【二】MyCAT主要作用、读写分离、负载均衡、垂直切分、水平切分概述
Sid小杰的博客
08-08 2280
主要作用： 1作为分布式数据库中间层使用。 MyCAT由Java开发，理论上说所有可以使用JDBC连接的关系型数据库和非关系型数据库都能使用MyCAT。 2.对主从数据库的读写分离、读的负载均衡。 如果不用MyCAT，在每一个访问这套数据库的应用中都要实现读写分离的逻辑。 如果MySQL是一主多从，主卦了，MyCAT会选一个从来读写，但是其他从不会同步新主的数据。 所以MySQL是一主...
MyCat是干什么的？具体如何使用？底层原理是什么？
长风破浪会有时的博客
03-29 301
schema.xml配置MyCat的数据源和分片策略，如数据源的地址、用户名和密码等。MyCat支持常见的数据库操作，如SELECT、INSERT、UPDATE和DELETE，同时还支持分布式事务和分布式缓存等高级功能。数据分片：MyCat将数据分为多个逻辑片段，每个片段存储在不同的节点上，从而实现数据的水平扩展和负载均衡。其主要功能包括数据分片、读写分离、负载均衡、高可用、事务支持等。总的来说，MyCat的底层原理主要是通过将数据分片和负载均衡等技术实现高可用、高性能和易扩展的分布式数据库服务。
MyCat测试报告(单机MyCAT对比多机MyCAT)1
08-08
本测试报告旨在探究单台MyCat与多台MyCat集群在性能上的差异，并对比前端使用Haproxy和Lvs作为代理层时的效果。测试主要通过简单的分表操作，分析不同并发情况下的QPS（每秒查询率）和TPS（每秒事务处理量）。 测试...
mycat2（mycat2映射关系.pdf）
06-10
MyCat2映射关系概述 MyCat2是一款开源的数据库中间件，可以实现数据库的分布式处理、读写分离、负载均衡等功能。在MyCat2中，数据源、集群和逻辑表是三个核心概念。 数据源（DataSource）是指实际的数据库实例，...
Mycat配置使用
09-06
综上所述，Mycat作为一个分库分表中间件，其配置和使用是一个涉及多个层次和组件的复杂过程，包括环境搭建、配置文件编写、分片规则定义和数据一致性管理等。正确配置Mycat，可以使得应用层面对数据库的管理和查询...
MyCat 的主要功能与特点
yueerba126的博客
10-10 470
MyCat 提供了多种分片算法，您可以根据业务需求选择合适的算法。
mycat作用
qq_40911404的博客
10-20 246
在主从结构中，实现数据库的读写分离 在一主多从架构中，能对从的读进行负载均衡 实现数据库的垂直拆分 实现数据库的垂直拆分
MyCAT从入门到实战（MyCAT介绍，以及安装部署）
杜小帅的博客
02-27 1254
Mycat 是数据库中间件。
MyCAT的作用及使用场景
qq_33348135的博客
02-22 759
作用： 1.实现数据库的读写分离 2.数据库的垂直拆分 3.数据库的水平拆分 -------------------------------------------------------------------------------------------- 应用场景 1.需要读写分离的场景 2.需要进行分库分表的场景 3.数据统计系统 4.HBASE的一种替代方案 5.需...
MyCat原理
JackLiu16的博客
02-07 1116
MyCat原理      Mycat实际上只是一个数据库的中间件，他并不存储任何数据。所以当有一天我们不用Mycat了只需要把mysql中的数据归集以后就能正常使用。 Mycat的作用是统一出口，查询缓存，查询优化。       MyCat特点 1.支持 SQL 92标准 支持Mysql集群，可以作为Proxy使用 支持JDBC连接ORACLE、DB2、SQL Server，将其
Mycat和MySQL的区别——Mycat的核心作用
热门推荐
Dreamcode ~ CWMP TR069 ACS
07-25 1万+
有个朋友面试的时候被问到：Mycat和MySQL的区别。
mycat的配置文件schema.xml是什么？
07-08
schema.xml是Apache Solr中用于定义索引和搜索字段的配置文件。它描述了Solr索引中的字段类型和字段属性，以及搜索...因此，如果您正在使用较新版本的Solr，您可能会使用solrconfig.xml而不是schema.xml来进行配置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值