AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

Mycat【Java提高】4

2023-08-23 249
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL DuckDB 分析主实例，集群系列 4核8GB
RDS MySQL DuckDB 分析主实例，基础系列 4核8GB
RDSClaw，2核4GB
简介： Mycat【Java提高】4

5.2 Mycat 的分片 “join”

Orders 订单表已经进行分表操作了，和它关联的 orders_detail 订单详情表如何进行 join 查询。我们要对 orders_detail 也要进行分片操作。 Join 的原理如下图：

1、 ER 表

Mycat 借鉴了 NewSQL 领域的新秀 Foundation DB 的设计思路， Foundation DB 创新性的提出了 Table Group 的概念，其将子表的存储位置依赖于主表，并且物理上紧邻存放，因此彻底解决了JION 的效率和性能问 题，根据这一思路，提出了基于 E-R 关系的数据分片策略，子表的记录与所关联的父表记录存放在同一个数据分片上。

#修改 schema.xml 配置文件
…
<table name="orders" dataNode="dn1,dn2" rule="mod_rule" >
  <childTable name="orders_detail" primaryKey="id" joinKey="order_id" parentKey="id" />
</table>
…




#在dn2 创建 orders_detail 表
#订单详细表 rows:600万
CREATE TABLE orders_detail(
  id INT AUTO_INCREMENT,
  detail VARCHAR(2000),
  order_id INT,
  PRIMARY KEY(id)
);

#重启 Mycat
#访问 Mycat 向 orders_detail 表插入数据
mysql> use TESTDB;
INSERT INTO orders_detail(id,detail,order_id) values(1,'detail1',1);
INSERT INTO orders_detail(id,detail,order_id) VALUES(2,'detail1',2);
INSERT INTO orders_detail(id,detail,order_id) VALUES(3,'detail1',3);
INSERT INTO orders_detail(id,detail,order_id) VALUES(4,'detail1',4);
INSERT INTO orders_detail(id,detail,order_id) VALUES(5,'detail1',5);
INSERT INTO orders_detail(id,detail,order_id) VALUES(6,'detail1',6);
#在mycat、 dn1、 dn2中运行两个表join语句
Select o.*,od.detail from orders o inner join orders_detail od on o.id=od.order_id;

mycat



2、 全局表

在分片的情况下，当业务表因为规模而进行分片以后，业务表与这些附属的字典表之间的关联，就成了比较 棘手的问题，考虑到字典表具有以下几个特性：

① 变动不频繁

② 数据量总体变化不大

③ 数据规模不大，很少有超过数十万条记录


鉴于此， Mycat 定义了一种特殊的表，称之为“全局表”，全局表具有以下特性：

① 全局表的插入、更新操作会实时在所有节点上执行，保持各个分片的数据一致性

② 全局表的查询操作，只从一个节点获取

③ 全局表可以跟任何一个表进行 JOIN 操作


将字典表或者符合字典表特性的一些表定义为全局表，则从另外一个方面，很好的解决了数据JOIN 的难题。 通过全局表+基于 E-R 关系的分片策略， Mycat 可以满足 80%以上的企业应用开发

#修改 schema.xml 配置文件
…
<table name="orders" dataNode="dn1,dn2" rule="mod_rule" >
  <childTable name="orders_detail" primaryKey="id" joinKey="order_id" parentKey="id" />
</table>
<table name="dict_order_type" dataNode="dn1,dn2" type="global" ></table>
…




#在dn2 创建 dict_order_type 表
#订单状态字典表 rows:20
CREATE TABLE dict_order_type(
  id INT AUTO_INCREMENT,
  order_type VARCHAR(200),
  PRIMARY KEY(id)
);

#重启 Mycat
#访问 Mycat 向 dict_order_type 表插入数据
mysql> use TESTDB;
INSERT INTO dict_order_type(id,order_type) VALUES(101,'type1');
INSERT INTO dict_order_type(id,order_type) VALUES(102,'type2');
#在Mycat、 dn1、 dn2中查询表数据

mycat


dn1


dn2



5.3 常用分片规则

1、 取模

此规则为对分片字段求摸运算。 也是水平分表最常用规则。 5.1 配置分表中， orders 表采用了此规则。

2、 分片枚举

通过在配置文件中配置可能的枚举 id，自己配置分片，本规则适用于特定的场景，比如有些业务需要按照省份或区县来做保存，而全国省份区县固定的，这类业务使用本条规则。

#（1） 修改schema.xml配置文件
<table name="orders_ware_info" dataNode="dn1,dn2" rule="sharding_by_intfile" ></table>




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

#（3） 修改partition-hash-int.txt配置文件
vim partition-hash-int.txt
110=0
120=1
#（4） 重启 Mycat

#（5） 访问Mycat创建表
#订单归属区域信息表
mysql> use TESTDB;
CREATE TABLE orders_ware_info
(
  `id` INT AUTO_INCREMENT comment '编号',
  `order_id` INT comment '订单编号',
  `address` VARCHAR(200) comment '地址',
  `areacode` VARCHAR(20) comment '区域编号',
  PRIMARY KEY(id)
);
#（6） 插入数据
INSERT INTO orders_ware_info(id, order_id,address,areacode) VALUES (1,1,'北京','110');
INSERT INTO orders_ware_info(id, order_id,address,areacode) VALUES (2,2,'天津','120');
#（7） 查询Mycat、 dn1、 dn2可以看到数据分片效果

mycat


dn1


dn2


3、 范围约定

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

#（1） 修改schema.xml配置文件
<table name="payment_info" dataNode="dn1,dn2" rule="auto_sharding_long" ></table>




#（2） 修改rule.xml配置文件
<tableRule name="auto_sharding_long">
  <rule>
    <columns>order_id</columns>
    <algorithm>rang-long</algorithm>
  </rule>
</tableRule>
…
<function name="rang-long"
  class="io.mycat.route.function.AutoPartitionByLong">
  <property name="mapFile">autopartition-long.txt</property>
  <property name="defaultNode">0</property>
</function>
# columns：分片字段， algorithm：分片函数
# mapFile： 标识配置文件名称
#defaultNode： 默认节点:小于 0 表示不设置默认节点，大于等于 0 表示设置默认节点，
# 设置默认节点如果碰到不识别的枚举值，就让它路由到默认节点，如不设置不识别就报错

#（3） 修改autopartition-long.txt配置文件
0-102=0
103-200=1
#（4） 重启 Mycat

#（5） 访问Mycat创建表
#支付信息表
mysql> use TESTDB;
CREATE TABLE payment_info
(
  `id` INT AUTO_INCREMENT comment '编号',
  `order_id` INT comment '订单编号',
  `payment_status` INT comment '支付状态',
  PRIMARY KEY(id)
);
#（6） 插入数据
INSERT INTO payment_info (id,order_id,payment_status) VALUES (1,101,0);
INSERT INTO payment_info (id,order_id,payment_status) VALUES (2,102,1);
INSERT INTO payment_info (id,order_id ,payment_status) VALUES (3,103,0);
INSERT INTO payment_info (id,order_id,payment_status) VALUES (4,104,1);
#（7） 查询Mycat、 dn1、 dn2可以看到数据分片效果

mycat


dn1


dn2


4、 按日期（天）分片

此规则为按天分片。 设定时间格式、范围

#（1） 修改schema.xml配置文件
<table name="login_info" dataNode="dn1,dn2" rule="sharding_by_date" ></table>




#（2） 修改rule.xml配置文件
<tableRule name="sharding_by_date">
  <rule>
    <columns>login_date</columns>
    <algorithm>shardingByDate</algorithm>
  </rule>
</tableRule>
…
#需要自己实现
<function name="shardingByDate" class="io.mycat.route.function.PartitionByDate">
  <property name="dateFormat">yyyy-MM-dd</property>
  <property name="sBeginDate">2019-01-01</property>
  <property name="sEndDate">2019-01-04</property>
  <property name="sPartionDay">2</property>
</function>
# columns：分片字段， algorithm：分片函数
#dateFormat ：日期格式
#sBeginDate ：开始日期
#sEndDate：结束日期,则代表数据达到了这个日期的分片后循环从开始分片插入
#sPartionDay ：分区天数，即默认从开始日期算起，分隔 2 天一个分区

#（3） 重启 Mycat
#（4） 访问Mycat创建表
#用户信息表
mysql> use TESTDB;
CREATE TABLE login_info
(
  `id` INT AUTO_INCREMENT comment '编号',
  `user_id` INT comment '用户编号',
  `login_date` date comment '登录日期',
  PRIMARY KEY(id)
);
#（6） 插入数据
INSERT INTO login_info(id,user_id,login_date) VALUES (1,101,'2019-01-01');
INSERT INTO login_info(id,user_id,login_date) VALUES (2,102,'2019-01-02');
INSERT INTO login_info(id,user_id,login_date) VALUES (3,103,'2019-01-03');
INSERT INTO login_info(id,user_id,login_date) VALUES (4,104,'2019-01-04');
INSERT INTO login_info(id,user_id,login_date) VALUES (5,103,'2019-01-05');
INSERT INTO login_info(id,user_id,login_date) VALUES (6,104,'2019-01-06');
#（7） 查询Mycat、 dn1、 dn2可以看到数据分片效果

mycat


dn1


dn2

总结

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
        <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
    <table name="customer" dataNode="dn2" ></table><!--分库-->
    <table name="orders" dataNode="dn1,dn2" rule="mod_rule" >  <!--求模分表 -->
      <childTable name="orders_detail" primaryKey="id" joinKey="order_id" parentKey="id" /> <!--关联子表 -->
    </table>  
    <table name="dict_order_type" dataNode="dn1,dn2" type="global" ></table><!-- 全局表 -->
    <table name="orders_ware_info" dataNode="dn1,dn2" rule="sharding_by_intfile" ></table><!--分片枚举 -->
    <table name="payment_info" dataNode="dn1,dn2" rule="auto_sharding_long" ></table> <!-- 范围约定 -->
    <table name="login_info" dataNode="dn1,dn2" rule="sharding_by_date" ></table><!-- 日期分片 -->
        </schema>
        <dataNode name="dn1" dataHost="host1" database="orders" />
    <dataNode name="dn2" dataHost="host2" database="orders" />
        <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="192.168.253.132: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="hostM1" url="192.168.253.133:3306" user="root"
                                   password="123456">               
                </writeHost>
        </dataHost>
</mycat:schema>

5.4 全局序列

在实现分库分表的情况下，数据库自增主键已无法保证自增主键的全局唯一。为此， Mycat 提供了全局 sequence，并且提供了包含本地配置和数据库配置等多种实现方式
1、 本地文件

此方式 Mycat 将 sequence 配置到文件中，当使用到 sequence 中的配置后， Mycat 会更下classpath 中的 sequence_conf.properties 文件中 sequence 当前的值。

① 优点： 本地加载，读取速度较快

② 缺点： 抗风险能力差， Mycat 所在主机宕机后，无法读取本地文件。



2、 数据库方式(推荐)

利用数据库一个表 来进行计数累加。但是并不是每次生成序列都读写数据库，这样效率太低。Mycat 会预加载一部分号段到 Mycat 的内存中，这样大部分读写序列都是在内存中完成的。如果内存中的号段用完了 Mycat 会再向数据库要一次。

问：那如果 Mycat 崩溃了 ，那内存中的序列岂不是都没了？

是的。如果是这样，那么 Mycat 启动后会向数据库申请新的号段，原有号段会弃用。

也就是说如果 Mycat 重启，那么损失是当前的号段没用完的号码，但是不会因此出现主键重复


① 建库序列脚本

#在 dn1 上创建全局序列表
CREATE TABLE MYCAT_SEQUENCE (NAME VARCHAR(50) NOT NULL,current_value INT NOT
NULL,increment INT NOT NULL DEFAULT 100, PRIMARY KEY(NAME)) ENGINE=INNODB;
#创建全局序列所需函数
DELIMITER $$
CREATE FUNCTION mycat_seq_currval(seq_name VARCHAR(50)) RETURNS VARCHAR(64)
DETERMINISTIC
BEGIN
DECLARE retval VARCHAR(64);
SET retval="-999999999,null";
SELECT CONCAT(CAST(current_value AS CHAR),",",CAST(increment AS CHAR)) INTO retval FROM
MYCAT_SEQUENCE WHERE NAME = seq_name;
RETURN retval;
END $$
DELIMITER ;
DELIMITER $$
CREATE FUNCTION mycat_seq_setval(seq_name VARCHAR(50),VALUE INTEGER) RETURNS
VARCHAR(64)
DETERMINISTIC
BEGIN
UPDATE MYCAT_SEQUENCE
SET current_value = VALUE
WHERE NAME = seq_name;
RETURN mycat_seq_currval(seq_name);
END $$
DELIMITER ;
DELIMITER $$
CREATE FUNCTION mycat_seq_nextval(seq_name VARCHAR(50)) RETURNS VARCHAR(64)
DETERMINISTIC
BEGIN
UPDATE MYCAT_SEQUENCE
SET current_value = current_value + increment WHERE NAME = seq_name;
RETURN mycat_seq_currval(seq_name);
END $$
DELIMITER ;
#初始化序列表记录
INSERT INTO MYCAT_SEQUENCE(NAME,current_value,increment) VALUES ('ORDERS', 400000,
100);


② 修改 Mycat 配置

#修改sequence_db_conf.properties
vim sequence_db_conf.properties
#意思是 ORDERS这个序列在dn1这个节点上，具体dn1节点是哪台机子，请参考schema.xml


#修改server.xml
vim server.xml
#全局序列类型： 0-本地文件， 1-数据库方式， 2-时间戳方式。此处应该修改成1。
<property name="sequnceHandlerType">1</property>




#重启Mycat

③ 验证全局序列

#登录 Mycat，插入数据
insert into orders(id,amount,customer_id,order_type) values(next value for MYCATSEQ_ORDERS,1000,101,102);
insert into orders(id,amount,customer_id,order_type) values(next value for MYCATSEQ_ORDERS,1000,101,102);
#查询数据




#重启Mycat后，再次插入数据，再查询


3、 时间戳方式

全局序列ID= 64 位二进制 (42(毫秒)+5(机器 ID)+5(业务编码)+12(重复累加) 换算成十进制为 18 位数的long 类型，每毫秒可以并发 12 位二进制的累加。

① 优点： 配置简单

② 缺点： 18 位 ID 过长
4、 自主生成全局序列

可在 java 项目里自己生成全局序列，如下：

① 根据业务逻辑组合
② 可以利用 redis 的单线程原子性 incr 来生成序列，但，自主生成需要单独在工程中用 java 代码实现， 还是推荐使用 Mycat 自带全局序列。

第六章 基于 HA 机制的 Mycat 高可用

在实际项目中， Mycat 服务也需要考虑高可用性，如果 Mycat 所在服务器出现宕机，或 Mycat 服务故障，需要有备机提供服务，需要考虑 Mycat 集群。

6.1 高可用方案

我们可以使用 HAProxy + Keepalived 配合两台 Mycat 搭起 Mycat 集群，实现高可用性。 HAProxy实现了 MyCat 多节点的集群高可用和负载均衡， 而 HAProxy 自身的高可用则可以通过 Keepalived 来实现。

编号 角色 IP 地址 机器名
1 Mycat1 192.168.253.132 mysq2
2 Mycat2 192.168.253.133 mysqlS2-1
3 HAProxy （master） 192.168.253.134 mysql2-2
4 Keepalived（master） 192.168.253.134 mysql2-2
5 HAProxy（backup） 192.168.253.135 mysqlS2-2
6 Keepalived（backup） 192.168.253.135 mysqlS2-2

6.2 安装配置 HAProxy

还需安装gcc编译

yum install gcc-c++

yum安装保证自己有网

拿浏览器试一下


如果是静态ip配置错了

请看：如何配置静态ip

在VMware中给Linux虚拟机配置静态IP的详细步骤（CentOs 7）

或者

先改为动态ip

安装gcc出现错误-----正在尝试其他镜像

#进入镜像目录
cd /etc/yum.repos.d/
#可以查看 所有的镜像
ls 
#删除全部镜像
rm -rf *.repo 
#配置aliyun的镜像
#CentOS 5
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-5.repo
#CentOS 6
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo
#CentOS 7
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

CentOS 7 下载yum源报错：正在解析主机 mirrors.aliyun.com (mirrors.aliyun.com)… 失败：未知的名称或服务。

登录root用户,用vim /etc/resolv.conf ，打开rsolv.conf，添加DNS地址

nameserver 8.8.8.8 
nameserver 8.8.4.4
nameserver 223.5.5.5
nameserver 223.6.6.6
#（nameserver 223.5.5.5 和 nameserver 223.6.6.6选择其中一个添加即可）


修改centOS6和centOS7的yum源为阿里源 mirrors.aliyun.com

GATEWAY=192.168.126.2
DNS1=8.8.8.8
DNS2=114.114.114.114

最后发现我配置的静态ip连上网但是浏览器百度不了

又改了一下ip配置，动态ip

就好了


后面我又重新配置静态ip

如何配置静态ip

在VMware中给Linux虚拟机配置静态IP的详细步骤（CentOs 7）
1、 安装 HAProxy

下载地址：https://src.fedoraproject.org/repo/pkgs/haproxy/

下载版本：haproxy-1.5.18.tar.gz

#1准备好HAProxy安装包，传到/opt目录下
#2解压到/usr/local/src
tar -zxvf haproxy-1.5.18.tar.gz -C /usr/local/src
#3进入解压后的目录，查看内核版本， 进行编译
cd /usr/local/src/haproxy-1.5.18
uname -r
make TARGET=linux310 PREFIX=/usr/local/haproxy ARCH=x86_64
# ARGET=linux310，内核版本，使用uname -r查看内核，如： 3.10.0-514.el7，此时该参数就为linux310；
#ARCH=x86_64，系统位数；
#PREFIX=/usr/local/haprpxy #/usr/local/haprpxy，为haprpxy安装路径。
#4编译完成后，进行安装
make install PREFIX=/usr/local/haproxy
#5安装完成后， 创建目录、 创建HAProxy配置文件
mkdir -p /usr/data/haproxy/
vim /usr/local/haproxy/haproxy.conf
#6向配置文件中插入以下配置信息,并保存
global
  log 127.0.0.1 local0
  #log 127.0.0.1 local1 notice
  #log loghost local0 info
  maxconn 4096
  chroot /usr/local/haproxy
  pidfile /usr/data/haproxy/haproxy.pid
  uid 99
  gid 99
  daemon
  #debug
  #quiet
defaults
  log global
  mode tcp
  option abortonclose
  option redispatch
  retries 3
  maxconn 2000
  timeout connect 5000
  timeout client 50000
  timeout server 50000
listen proxy_status
  bind :48066
    mode tcp
    balance roundrobin
    server mycat_1 192.168.140.128:8066 check inter 10s  #修改192.168.253.132:8066
    server mycat_2 192.168.140.127:8066 check inter 10s  #修改192.168.253.133:8066
frontend admin_stats
  bind :7777
    mode http
    stats enable
    option httplog
    maxconn 10
    stats refresh 30s
    stats uri /admin      #用户名
    stats auth admin:123123 #密码
    stats hide-version
    stats admin if TRUE

2、 启动验证

先启动两个mycat

两个mycat一模一样的配置

把conf文件夹复制一下

或者直接复制整个mycat到第二天机器上

第二个mycat

#1启动HAProxy
/usr/local/haproxy/sbin/haproxy -f /usr/local/haproxy/haproxy.conf
#2查看HAProxy进程
ps -ef|grep haproxy


#3打开浏览器访问
http://192.168.140.125:7777/admin  #http://192.168.253.134:7777/admin
#在弹出框输入用户名： admin密码： 123123  #我的123456
#如果Mycat主备机均已启动，则可以看到如下图




#4验证负载均衡，通过HAProxy访问Mycat
mysql -umycat -p123456 -h 192.168.253.132 -P 48066

6.3 配置 Keepalived

下载地址：https://www.keepalived.org/download.html

下载版本：keepalived-1.4.2.tar.gz

1、 安装 Keepalived

#1准备好Keepalived安装包，传到/opt目录下
#2解压到/usr/local/src
tar -zxvf keepalived-1.4.2.tar.gz -C /usr/local/src
#3安装依赖插件
yum install -y gcc openssl-devel popt-devel
#如果./configure --prefix=/usr/local/keepalived出现错误
---
checking for openssl/ssl.h... no
configure: error: 
  !!! OpenSSL is not properly installed on your system. !!!
  !!! Can not include OpenSSL headers files.            !!!
---
#3进入解压后的目录， 进行配置， 进行编译
cd /usr/local/src/keepalived-1.4.2
./configure --prefix=/usr/local/keepalived
#4进行编译， 完成后进行安装
make 
make install
#5运行前配置
cp /usr/local/src/keepalived-1.4.2/keepalived/etc/init.d/keepalived /etc/init.d/
mkdir /etc/keepalived
cp /usr/local/keepalived/etc/keepalived/keepalived.conf /etc/keepalived/
cp /usr/local/src/keepalived-1.4.2/keepalived/etc/sysconfig/keepalived /etc/sysconfig/
cp /usr/local/keepalived/sbin/keepalived /usr/sbin/
#6修改配置文件
vim /etc/keepalived/keepalived.conf
#修改内容如下
! Configuration File for keepalived
global_defs {
  notification_email {
    xlcocoon@foxmail.com
  }
  notification_email_from keepalived@showjoy.com
  smtp_server 127.0.0.1
  smtp_connect_timeout 30
  router_id LVS_DEVEL
  vrrp_skip_check_adv_addr
  vrrp_garp_interval 0
  vrrp_gna_interval 0
}
vrrp_instance VI_1 {
  #主机配MASTER，备机配BACKUP
  state MASTER
  #所在机器网卡
  interface ens33
  virtual_router_id 51
  #数值越大优先级越高
  priority 100
  advert_int 1
  authentication {
    auth_type PASS
    auth_pass 1111
  }
  virtual_ipaddress {
    #虚拟IP
    192.168.140.200  #我的 192.168.253.200
  }
}
virtual_server 192.168.140.200 48066 {
  delay_loop 6
  lb_algo rr
  lb_kind NAT
  persistence_timeout 50
  protocol TCP
  real_server 192.168.140.125 48066 {
    weight 1
    TCP_CHECK {
      connect_timeout 3
      retry 3
      delay_before_retry 3
    }
  }
  real_server 192.168.140.126 48600 {
    weight 1
    TCP_CHECK {
      connect_timeout 3
      nb_get_retry 3
      delay_before_retry 3
    }
  }
}

2、 启动验证

两个HAProxy启动

135的

#1启动Keepalived
service keepalived start
#2登录验证
mysql -umycat -p123456 -h 192.168.140.200 -P 48066
# mysql -umycat -p123456 -h 192.168.253.200 -P 48066




6.4 测试高可用

1、 测试步骤

#1关闭mycat
132的mycat
#2通过虚拟ip查询数据
mysql -umycat -p123456 -h 192.168.140.200 -P 48066





文章标签：
云数据库 RDS MySQL 版
负载均衡
Java
数据库
Linux
C语言
虚拟化
关键词：
Java mycat
相关实践学习
每个IT人都想学的“Web应用上云经典架构”实战
本实验从Web应用上云这个最基本的、最普遍的需求出发，帮助IT从业者们通过“阿里云Web应用上云解决方案”，了解一个企业级Web应用上云的常见架构，了解如何构建一个高可用、可扩展的企业级应用架构。
MySQL数据库入门学习
本课程通过最流行的开源数据库MySQL带你了解数据库的世界。 &nbsp; 相关的阿里云产品：云数据库RDS MySQL 版 阿里云关系型数据库RDS（Relational Database Service）是一种稳定可靠、可弹性伸缩的在线数据库服务，提供容灾、备份、恢复、迁移等方面的全套解决方案，彻底解决数据库运维的烦恼。 了解产品详情:&nbsp;https://www.aliyun.com/product/rds/mysql&nbsp;
日星月云
目录
相关文章
日星月云
|
SQL 监控 Java
Mycat【Java提高】5
Mycat【Java提高】5
日星月云
216 0
日星月云
|
存储 Java 关系型数据库
Mycat【Java提高】3
Mycat【Java提高】3
日星月云
274 0
日星月云
|
关系型数据库 MySQL Java
Mycat【Java提高】2
Mycat【Java提高】2
日星月云
154 0
日星月云
|
关系型数据库 中间件 MySQL
Mycat【Java提高】1
Mycat【Java提高】1
日星月云
163 1
pythonstock
|
Oracle Java 关系型数据库
Mycat（6）：聊天消息表，按月分表 java客户端跨月查询数据
本文的原文连接是: http://blog.csdn.net/freewebsys/article/details/47039103 未经博主允许不得转载。 1，业务需求 上次分析聊天业务按照月进行拆。http://blog.csdn.net/freewebsys/article/details/47003577 具体拆分方案已经有了： 但是在操作的时候还是有点小问
pythonstock
1439 0
凉凉心.
|
6月前
|
JSON 网络协议 安全
【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
335 1
凉凉心.
|
6月前
|
JSON 网络协议 安全
【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
337 1
小白学大数据
|
7月前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
小白学大数据
439 1
Java 数据库 Spring
322 0
蓝易云
|
7月前
|
算法 Java
Java多线程编程：实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
蓝易云
502 16

热门文章

最新文章

  • 1
    如何降低90%Java垃圾回收时间？以阿里HBase的GC优化实践为例
  • 2
    Java19新特性协程
  • 3
    java版spring cloud+spring boot 社交电子商务平台-Ribbon设计原理
  • 4
    java环境变量添加
  • 5
    Java I/O
  • 6
    OJ 模板-java
  • 7
    java.lang.NumberFormatException: For input string: &quot;0&quot;
  • 8
    深入解析 Java @RestController 注解：构建现代化的RESTful API
  • 9
    JAVA虚拟机内存分配与回收机制
  • 10
    Java并发编程：synchronized
  • 1
    Java 设计模式之策略模式：灵活切换算法的艺术
    1617
  • 2
    Java 设计模式之观察者模式：构建松耦合的事件响应系统
    532
  • 3
    Java 设计模式之状态模式：让对象的行为随状态优雅变化
    905
  • 4
    java零基础学习者入门课程
    562
  • 5
    Java 设计模式之责任链模式：优雅处理请求的艺术
    712
  • 6
    【Azure Storage Account】Java Code访问Storage Account File Share的上传和下载代码示例
    484
  • 7
    百宝箱开放平台 ✖️ Java SDK
    1532
  • 8
    《深入理解Spring》：现代Java开发的核心框架
    918
  • 9
    用Java语言实现一个自定义的ArrayList类
    279
  • 10
    从混沌到秩序：Java共享内存模型如何通过显式约束驯服并发？
    194

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    PolarDB MySQL 版 Serverless-测评