JavaEE技术之MySql主从复制及mycat[了解,不讲]

2024-05-12 02:28

本文主要是介绍JavaEE技术之MySql主从复制及mycat[了解,不讲],希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

文章目录

  • 1. 主从复制
    • 1.1. 主从同步的原理
    • 1.2. 检查数据库远程访问权限
    • 1.3. 主从配置
      • 1.3.1. master配置
      • 1.3.2. slave配置
      • 1.3.3. 主库创建同步用户
      • 1.3.4. 从库配置主从关系
      • 1.3.5. 重置主从关系
    • 1.4. 测试主从复制
  • 2. Mycat
    • 2.1. Mycat简介
    • 2.2. MyCat读写分离原理
    • 2.3. 不废话,动手试试
      • 2.3.1. 安装
      • 2.3.2. server.xml配置
      • 2.3.3. 配置schema.xml
      • 2.3.4. 启动mycat
      • 2.3.5. 测试连接mycat
      • 2.3.6. 在项目中使用
    • 2.4. 读写分离
    • 2.5. mycat数据分片
      • 2.5.1. mycat分片原理
      • 2.5.2. 分片分析
      • 2.5.3. 分库实现
      • 2.5.4. 分表实现
      • 2.5.5. 跨库join
      • 2.5.6. 全局表
    • 2.6. 全局ID序列
      • 2.6.1. 数据库序列方式原理(了解)
      • 2.6.2. 建库序列脚本
      • 2.6.3. sequence_db_conf.properties 配置
      • 2.6.4. server.xml配置
      • 2.6.5. 重启测试
      • 2.6.6. 自主生成id

1. 主从复制

我们一般应用对数据库而言都是“读多写少”,也就说对数据库读取数据的压力比较大,有一个思路就是采用数据库集群的方案,

其中一个是主库,负责写入数据,我们称之为:写库;

其它都是从库,负责读取数据,我们称之为:读库;

版本一致。

那么,对我们的要求是:

1、 读库和写库的数据一致(最终一致);

2、 写数据必须写到写库;

3、 读数据必须到读库(不一定);

这里存在两个问题:

1) 如何保证读库和写库一致?

2) 如何让程序实现动态数据库切换?

1.1. 主从同步的原理

在这里插入图片描述

mysql主(master)从(slave)复制的原理:

主库生成一个I/O线程,从库生成两个线程,一个I/O线程,一个SQL线程。

1、 master将数据改变记录到二进制日志(binary log)中,也即是配置文件log-bin指定的文件(这些记录叫做二进制日志事件,binary log events)

2、 slave将master的binary log events拷贝到它的中继日志(relay log)

i/o线程去请求主库 的binlog,并将得到的binlog日志写到relay log(中继日志) 文件中;

主库会生成一个 log dump 线程,用来给从库 i/o线程传binlog;

3、 slave重做中继日志中的事件,将改变反映它自己的数据(数据重演)

SQL 线程,会读取relay log文件中的日志,并解析成具体操作,来实现主从的操作一致,而最终数据一致;

由此可见主从复制过程需要网络传输或大量的IO操作,这些操作会导致数据同步的延时

1.2. 检查数据库远程访问权限

准备两个虚拟机,每个都安装了mysql,并且版本一致。

注意:使用docker搭建主从复制参考课件资料中的文档

测试虚拟机是否可以连通宿主机的mysql服务。

在虚拟机中连接宿主机mysql服务:mysql -uroot -proot -h172.16.116.1 -P3306

在这里插入图片描述

Mysql默认是不允许远程连接的,所以,需要在之前安装的两台mysql中执行如下sql,允许远程连接:

grant all privileges on *.* to root@'%' identified by 'root';
flush privileges;

在这里插入图片描述

再次在虚拟机中连接宿主机:成功!

在这里插入图片描述

1.3. 主从配置

每个master可以有多个slave,每个slave只属于一个master。

1、 主DB server和从DB server数据库的版本一致,都是5.7或者都是8

2、 主DB server和从DB server数据库数据一致[ 这里就会可以把主的备份在从上还原,也可以直接将主的数据目录拷贝到从的相应数据目录]

3、 主DB server开启二进制日志,主DB server和从DB server的server_id都必须唯一

主从都配置在[mysqld]结点下,都是小写

1.3.1. master配置

windows下的mysql配置成master,linux下的mysql配置成slave

找到mysql安装目录下的my.ini配置文件

window系统  my.ini
# 主服务器唯一ID
server-id=1
# 启用二进制日志,路径中不要有中文和空格
log-bin=D:\development_tools\mysqlserver5.7\logbin
# 可选,出错日志。出错之后可查看
log-error=D:\development_tools\mysqlserver5.7\log
# 设置不要复制的数据库
binlog-ignore-db=mysql
# 设置需要复制的数据库
binlog-do-db=mydb2
# 设置logbin格式,默认就是statement,row/mixed(5.8以上支持)
binlog_format=STATEMENT
centos7   vim /etc/my.cnf
# 主服务器唯一ID
server-id=1# 启用二进制日志,路径中不要有中文和空格
log-bin=master-bin# 可选,出错日志。出错之后可查看
#log-error=/opt/log# 设置不要复制的数据库
binlog-ignore-db=mysql# 设置需要复制的数据库
binlog-do-db=mydb2# 设置logbin格式,默认就是statement,row/mixed(5.8以上支持)  # statement: 此格式,日志记录的是主机数据库的写指令   默认  性能 高,但是now()之类的获取系统参数的操# 作会出现主从数据不同步的问题# row: 此格式,日志记录的是主机数据库的写后的数据  批量操作时性能较差  解决now()或者  user()或者  #@@hostname 等操作获取系统参数时 由于延迟导致  主从获取的参数值不同步出现的问题# mixed: 会按照statement保存写操作,但是now()等获取系统参数的操作会自动转为参数值保存 5.8 以后支持
binlog_format=STATEMENT

1.3.2. slave配置

从机配置文件修改my.cnf的[mysqld]栏位下

在这里插入图片描述

server-id=2
# mysql中继日志
relay-log=mysql-relay

因修改过配置文件,请主机+从机都重启后台mysql服务

安全工具关上:腾讯管家 360

linux:防火墙关闭 systemctl stop firewalld

1.3.3. 主库创建同步用户

在主库上建立帐户并授权slave:

# 创建slave用户
CREATE USER 'slave01'@'%' IDENTIFIED WITH 
mysql_native_password BY 'Atguigu0718.';
# 授权
GRANT REPLICATION SLAVE ON *.* TO 'slave01'@'%';
FLUSH PRIVILEGES;

执行SQL语句查询状态:

SHOW MASTER STATUS

在这里插入图片描述

需要记录下Position值,需要在从库中设置同步起始值。

执行完此步骤后不要再操作主服务器MYSQL,防止主服务器状态值变化。

1.3.4. 从库配置主从关系

执行SQL:

CHANGE MASTER TO MASTER_HOST = '192.168.1.172',MASTER_PORT = 3306,MASTER_USER = 'slave01',MASTER_PASSWORD = '123456',MASTER_LOG_FILE = 'master-bin.000001',MASTER_LOG_POS = 156;

master_port:主库的ip地址

master_port:主库的端口

master_user:用户名

master_password:密码

master_log_file:上节中主库查询的file项对应的值

master_log_pos:上节中主库查询的的值

#启动slave同步
START SLAVE;
#查看同步状态
SHOW SLAVE STATUS;

在这里插入图片描述

如果这两项为No或者Connection,均说明安装失败。

可以查看/var/log/mysqld.log日志,进行错误定位。

虚拟机主从由于克隆的是同一个mysql,所以生成的uuid一样,需要先删除从机的uuid:

rm -vf /var/lib/mysql/auto.cnf

重启mysql服务

1.3.5. 重置主从关系

如何停止从服务复制功能:stop slave;

如何重新配置主从:

stop slave;
reset master;

1.4. 测试主从复制

在本地电脑(master)创建要同步的mydb2(在配置文件中配置的同步库)这个库、添加了test表,并往表中添加了一些数据:

在这里插入图片描述

在虚拟机(slave)查看库及数据信息:

在这里插入图片描述

说明同步成功了。

2. Mycat

在这里插入图片描述

​ 如今随着互联网的发展,数据的量级也是成指数的增长,从 GB 到 TB 到 PB。对数据的各种操作也是愈加的困难,传统的关系性数据库已经无法满足快速查询与插入数据的需求。这个时候 NoSQL 的出现暂时解决了这一危机。它通过降低数据的安全性,减少对事务的支持,减少对复杂查询的支持,来获取性能上的提升。

​ 但是,在有些场合 NoSQL 一些折衷是无法满足使用场景的,就比如有些使用场景是绝对要有事务与安全指标的。这个时候 NoSQL 肯定是无法满足的,所以还是需要使用关系性数据库。如何使用关系型数据库解决海量存储的问题呢?此时就需要做数据库集群,为了提高查询性能将一个数据库的数据分散到不同的数据库中存储。

2.1. Mycat简介

在这里插入图片描述

在这里插入图片描述

MyCat支持的数据库:

在这里插入图片描述

2.2. MyCat读写分离原理

MyCat是我们的程序与MySQL数据库之间的桥梁,我们的请求不再直接到达数据库,而是到达MyCat,由MyCat决定读和写的去向。

在这里插入图片描述

也就是说:

我们的Jdbc连接是连接MyCat,程序代码没有任何变化。(在用户眼里,MyCat就是一个数据库)

MyCat中需要配置好主库从库关系,会根据请求的判断读写,实现读写分离。

2.3. 不废话,动手试试

2.3.1. 安装

mycat不需要安装,解压即可使用。把课前资料中的《Mycat-server-1.6.7.6-release-20220524173810-linux.tar.gz》上传到/opt目录下,解压获得mycat:

在这里插入图片描述

打开mycat目录结构如下:

在这里插入图片描述

bin:二进制执行文件

conf:配置文件目录

lib:依赖

logs:日志

conf配置目录下有很多配置文件:

在这里插入图片描述

其中核心的配置有3个:

​ server.xml:配置MyCat作为虚拟数据库的信息(地址、数据库名、用户名、密码等信息)

​ schemal.xml:mycat代理的真实数据库的信息,实现读写分离

​ rule.xml:分库分表规则配置

2.3.2. server.xml配置

server.xml中是MyCat作为虚拟数据库的基本信息。

在这里插入图片描述

这里随便配置了虚拟机库:TESTDB

mycat的默认端口是:8066

2.3.3. 配置schema.xml

配置虚拟库(TESTDB)和真实数据库(mydb2)的映射信息,实现读写分离:

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/"><!-- 虚拟库与真实库的映射 name="TESTDB" 虚拟库的名字,对应刚刚在server.xml中设置的TESTDBsqlMaxLimit="100",允许最大查询记录数checkSQLschema="false" 是否检查自动删除 “虚拟库名”randomDataNode="dn1" 虚拟库对应的真实database,值为dataNode标签的name--><schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" randomDataNode="dn1"><!-- 可以访问的表,只有设置在这里的表才会被MyCat管理访问 dataNode:虚拟库对应的真实database,对应<dataNode>标签。如果做分片,则配置多个,用逗号分隔;或者使用db$0-99,代表db0到db99的databaserule:分片规则,如果没有则删除--><!-- <table name="tb_item" dataNode="dn1"/> --></schema><!-- 真实的database信息,每一个dataNode就是一个数据库分片name:虚拟名称dataHost:真实库的主机信息,对应<dataHost>标签database:真实database名称--><dataNode name="dn1" dataHost="localhost1" database="mydb2" /><!-- 真实库的主机信息name:主机名maxCon:最大连接, minCon:最小连接balance:负载均衡方式:0~3四种选项。0,不开启读写分离。1~3都开启,区别是主是否参与读writeType:写负载均衡。永远设置0dbDriver:驱动类型,推荐native,可选jdbcswitchType:主从的自动切换--><dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"writeType="0" dbType="mysql" dbDriver="native" switchType="1"><heartbeat>select user()</heartbeat><!-- can have multi write hosts --><writeHost host="hostM1" url="172.16.116.1:3306" user="root"password="root"><!-- can have multi read hosts --><readHost host="hostS2" url="172.16.116.110:3306" user="root" password="root" /></writeHost></dataHost>
</mycat:schema>

2.3.4. 启动mycat

进入 mycat/bin目录:

启动: ./mycat start

控制台启动: ./mycat console

停止: ./mycat stop

重启: ./mycat restart

状态: ./mycat status

日志文件:mycat/logs/wrapper.log

2.3.5. 测试连接mycat

mycat的使用方式跟mysql一模一样。

本地连接:(虚拟机)

mysql -uroot -p123456 -h172.16.116.110 -P8066

在这里插入图片描述

宿主机通过navicat连接mycat:

在这里插入图片描述

连接成功后:

在这里插入图片描述

2.3.6. 在项目中使用

其实项目中,只要改一个地方即可,就是jdbc的连接参数。

在这里插入图片描述

mycat中的,一旦你给sql加了事务,走主库。

2.4. 读写分离

在schema.xml中配置读写分离:

在这里插入图片描述

负载均衡类型,目前的取值有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”,所有读请求随机的分发到 readhost 执行,writerHost 不负担读压力

往test表中新增一条数据:

INSERT INTO test(name, age) values(@@hostname, 30);

@@hostname:计算机名。

​ 例如我这里宿主机的计算机名是:LAPTOP-M3RC4R1J;虚拟机名:joedy

上述sql执行成功后。

在mycat中执行查询看看结果:

在这里插入图片描述

在宿主机的mysql中查询:

在这里插入图片描述

在虚拟机的mysql中查询

在这里插入图片描述

思考:为什么结果不同?

2.5. mycat数据分片

什么是数据分片?

简单来说,就是指通过某种特定的条件,将我们存放在同一个数据库中的数据分散存放到多个数据库(主机)上面,以达到分散单台设备负载的效果。

数据的切分(Sharding)根据其切分规则的类型,可以分为两种切分模式:

  1. 垂直(纵向)切分:是按照不同的表(或者 Schema)来切分到不同的数据库(主机)之上
  2. 水平(横向)切分:是根据表中的数据的逻辑关系,将同一个表中的数据按照某种条件拆分到多台数据库(主机)上面。

垂直切分:

在这里插入图片描述

水平切分:

在这里插入图片描述

2.5.1. mycat分片原理

MyCat的分片实现:

在这里插入图片描述

**逻辑库(schema) :**MyCat作为一个数据库中间件,起到一个程序与数据库的桥梁作用。开发人员无需知道MyCat的存在,只需要知道数据库的概念即可。为了让MyCat更透明,它会把自己“伪装”成一个MySQL数据库,因此需要有一个虚拟的 database,在MyCat中也叫逻辑库,英文就是schema。

**逻辑表(table):**既然有逻辑库,那么就会有逻辑表,分布式数据库中,对应用来说,读写数据的表就是逻辑表。逻辑表,可以是数据切分后,分布在一个或多个分片库中,也可以不做数据切分,不分片,只有一个表构成。

**分片节点(dataNode):**数据切分后,一个大表被分到不同的分片数据库上面,每个表分片所在的数据库就是分片节点(dataNode)。

**节点主机(dataHost):**数据切分后,每个分片节点(dataNode)不一定都会独占一台机器,同一机器上面可以有多个分片数据库,这样一个或多个分片节点(dataNode)所在的机器就是节点主机(dataHost),为了规避单节点主机并发数限制,尽量将读写压力高的分片节点(dataNode)均衡的放在不同的节点主机(dataHost)。

**分片规则(rule):**前面讲了数据切分,一个大表被分成若干个分片表,就需要一定的规则,这样按照某种业务规则把数据分到某个分片的规则就是分片规则,数据切分选择合适的分片规则非常重要,将极大的避免后续数据处理的难度。

2.5.2. 分片分析

注意:分库分表必须是干净的库和表(不能有数据)

分片原则:

  1. 能不切分尽量不要切分。数据量不是很大的库或者表,尽量不要分片。
  2. 尽量按照功能模块分库,避免跨库join。
#客户表  rows:20万 
CREATE TABLE customer(id INT AUTO_INCREMENT,NAME VARCHAR(200),PRIMARY KEY(id)
);#订单表   rows:600万
CREATE TABLE orders(id INT AUTO_INCREMENT,order_type INT,customer_id INT,amount DECIMAL(10,2),PRIMARY KEY(id)  
); #订单详细表     rows:600万
CREATE TABLE orders_detail(id INT AUTO_INCREMENT,detail VARCHAR(2000),order_id INT,PRIMARY KEY(id)
);#订单状态字典表   rows:20
CREATE TABLE dict_order_type(id INT AUTO_INCREMENT,order_type VARCHAR(200),PRIMARY KEY(id)
);

分库:宿主机mysql服务上添加order库:存放order相关的表;虚拟机mysql上添加user库存存放customer表

2.5.3. 分库实现

分两步实现:

  1. 分别在宿主机和虚拟机mysql上创建两个库,并创建相应的表
  2. 配置schema.xml实现mycat分库

第一步建库建表:

在这里插入图片描述

第二步配置schema.xml:由于咱们只有两台服务,所以这里都没有配置读库,只配置写库

在这里插入图片描述

具体内容如下:

<?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"/></schema><dataNode name="dn1" dataHost="localhost1" database="order" /><dataNode name="dn2" dataHost="localhost2" database="user" /><dataHost name="localhost1" 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="172.16.116.1:3306" user="root"password="root"></writeHost></dataHost><dataHost name="localhost2" 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="172.16.116.110:3306" user="root"password="root"></writeHost></dataHost>
</mycat:schema>

重启mycat服务,后查看mycat中的表:

在这里插入图片描述

注意:由于navicat对mycat的兼容性问题,在navicat,sqlyog等数据库客户端,看到的表可能不完整

在这里插入图片描述

2.5.4. 分表实现

接下来以order表做分表演示。先停止mycat服务:./mycat stop

  1. 首先在rule.xml中配置分表规则
<tableRule name="order_rule"><rule><columns>customer_id</columns><algorithm>mod-long</algorithm></rule>
</tableRule>
<function name="mod-long" class="io.mycat.route.function.PartitionByMod"><!-- how many data nodes --><property name="count">2</property>
</function>
  1. 在schema.xml中配置使用分表规则

在这里插入图片描述

  1. 手动在虚拟机(dn2)上的mysql服务中创建orders表。

在这里插入图片描述

最后启动mycat。往mycat中插入几条数据:

INSERT INTO orders(id,order_type,customer_id,amount) VALUES(1,101,100,100100);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(2,101,100,100300);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(3,101,101,120000);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(4,101,101,103000);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(5,102,101,100400);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(6,102,100,100020);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(7,102,102,100050);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(8,102,103,100060);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(9,102,103,100070);

注意:使用mycat分表之后orders后的字段名不能省略!!!

在mycat中查询:

在这里插入图片描述

在宿主机mysql中查询:

在这里插入图片描述

在虚拟机mysql中查询:

在这里插入图片描述

思考:orders_detail怎么分表?

2.5.5. 跨库join

往orders_detail导入几条数据:

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);

执行join查询:

SELECT * FROM orders o INNER JOIN orders_detail od ON od.order_id=o.id;

在这里插入图片描述

报错,这是由于虚拟机mysql库中没有orders_detail这个表,所以关联时,找不到。

解决方案:把orders_detail也相应分表到相应的mysql服务

orders_detail分表步骤:首先停掉mycat服务

  1. 删除刚刚导入的orders_detail数据。分表必须在库和表干净的情况下完成

  2. 在schema.xml中添加orders_detail表的配置

  3. 在虚拟机mysql上创建orders_detail表

  4. 删除orders_detail数据,在宿主机mysql中执行:

delete from orders_detail;
  1. 修改schema.xml配置,添加orders_detail表的配置:

在这里插入图片描述

完整的schema.xml配置如下:

<?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 name="orders" dataNode="dn1,dn2" rule="order_rule"fetchStoreNodeByJdbc="true"><!--name: 定义子表的表名;primaryKey:字表的主键;joinKey:与父表建立关联关系的列名;parentKey:父表的主键名--><childTable name="orders_detail" primaryKey="id" joinKey="order_id" parentKey="id" /></table></schema><dataNode name="dn1" dataHost="localhost1" database="order" /><dataNode name="dn2" dataHost="localhost2" database="user" /><dataHost name="localhost1" 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="172.16.116.1:3306" user="root"password="root"></writeHost></dataHost><dataHost name="localhost2" 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="172.16.116.110:3306" user="root"password="root"></writeHost></dataHost>
</mycat:schema>
  1. 在虚拟机mysql上创建orders_detail表

在这里插入图片描述

重启mycat,再次在mycat中导入orders_detail表数据,并查询测试:

在这里插入图片描述

2.5.6. 全局表

最后,dict_order_type字典表怎么办?设定为全局表

设定为全局的表,会直接复制给每个数据库一份,所有写操作也会同步给多个库。

所以全局表一般不能是大数据表或者更新频繁的表。一般是字典表或者系统表为宜。

停掉mycat服务。

  1. 在虚拟机mysql中创建字典表:

在这里插入图片描述

  1. 修改schema.xml配置:

在这里插入图片描述

<table name="dict_order_type" dataNode="dn1,dn2" type="global" ></table>

启动mycat,往字典表中插入数据:

INSERT INTO dict_order_type(id,order_type) VALUES(101,'type1');
INSERT INTO dict_order_type(id,order_type) VALUES(102,'type2');

2.6. 全局ID序列

在分库分表环境下,表的主键该怎么设计?

如果自增长必然会导致两张表数据id重复。那怎么办?

Mycat提供了多种解决方案:

  1. 本地文件方式。不推荐 io
  2. 数据库方式. [通过一个库的一张表维护自增长的id ]
  3. 本地时间戳方式。18位时间戳(毫秒内并发的请求id可能冲突)
  4. 分布式 ZooKeeper ID 生成器
  5. redis 递增方式

等等。这里使用数据库方式

2.6.1. 数据库序列方式原理(了解)

利用数据库一个表 来进行计数累加。

但是并不是每次生成序列都读写数据库,这样效率太低

mycat会预加载一部分号段到mycat的内存中,这样大部分读写序列都是在内存中完成的。
如果内存中的号段用完了 mycat会再向数据库要一次。

问:那如果mycat崩溃了 ,那内存中的序列岂不是都没了?
是的。如果是这样,那么mycat启动后会向数据库申请新的号段,原有号段会弃用。
也就是说如果mycat重启,那么损失是当前的号段没用完的号码,但是不会因此出现主键重复。

2.6.2. 建库序列脚本

以下脚本来自官方:在宿主机mysql上执行

# 创建序列表
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;## 创建相关 function
# 获取当前sequence的值 (返回当前值,增量)
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;
# 设置sequence值
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 ;
# 获取下一个sequence值
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 表和以上的 3 个 function,需要放在同一个节点上。function 请直接在具体节
点的数据库上执行,如果执行的时候报:

you might want to use the less safe log_bin_trust_function_creators variable

需要对数据库做如下设置:

windows 下 my.ini[mysqld]加上 log_bin_trust_function_creators=1

linux 下/etc/my.cnf 下 my.ini[mysqld]加上 log_bin_trust_function_creators=1

修改完后,即可在 mysql 数据库中执行上面的函数.

执行成功:

在这里插入图片描述

2.6.3. sequence_db_conf.properties 配置

sequence_db_conf.properties 相关配置,指定 sequence 相关配置在哪个节点上:

在这里插入图片描述

配置内容:vim sequence_db_conf.properties

在这里插入图片描述

2.6.4. server.xml配置

vim server.xml:

在这里插入图片描述

2.6.5. 重启测试

在mycat中执行以下sql,插入记录:

insert into `orders`(id,amount,customer_id,order_type) values(next value for MYCATSEQ_ORDERS,1000,101,102);

next value for MYCATSEQ_ORDERS:从mycat序列表中获取Id

执行两次之后:

在这里插入图片描述

mycat宕机重启后,验证id是否重复

在这里插入图片描述

2.6.6. 自主生成id

除了上述mycat提供的id生成方案外,也可以通过在程序中生成唯一id:

  1. uuid (不推荐)

  2. 可以利用 redis的单线程原子性 incr来生成序列

  3. Twitter的雪花算法

    雪花算法:使用19位长度的十进制的数字当做id

    ​ 使用当前的时间戳+当前服务器的机器码+毫秒内的id序号

    ​ 一共得到一个64bit的数据,高位表示符号位 一般是0,后面的63bit组成了生成id

    ​ 按照时间递增有序,全局唯一,十进制的数字

这篇关于JavaEE技术之MySql主从复制及mycat[了解,不讲]的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/981345

相关文章

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时,有没有考虑过 JVM 是如何把静态的字节码(byte code)转化为运行时对象的呢,这个问题看似简单,但清楚的同学相信也不会太多,这篇文章首先介绍 JVM 类初始化的机制,然后给出几个易出错的实例来分析,帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段,分别是:loading 、Linking、initialization

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权,允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true (Spring security默认会带有ROLE_前缀),去

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程,特意画了如下的类图,包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口,接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类,它们之间的依赖,构建起了整个框架。想要理解整个架构,最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文(security context)的信息。当前操作的用户是谁,该用户是否已经被认证,他拥有哪些角色权限…这些都被保

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明(认真看哦) AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证,则会调用 #attemptAuthentica

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门(一):登录与退出》 《Spring-Security-入门(二):基于数据库验证》 《Spring-Security-入门(三):密码加密》 《Spring-Security-入门(四):自定义-Filter》 《Spring-Security-入门(五):在 Sprin

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物

SQL中的外键约束

外键约束用于表示两张表中的指标连接关系。外键约束的作用主要有以下三点: 1.确保子表中的某个字段(外键)只能引用父表中的有效记录2.主表中的列被删除时,子表中的关联列也会被删除3.主表中的列更新时,子表中的关联元素也会被更新 子表中的元素指向主表 以下是一个外键约束的实例展示

基于MySQL Binlog的Elasticsearch数据同步实践

一、为什么要做 随着马蜂窝的逐渐发展,我们的业务数据越来越多,单纯使用 MySQL 已经不能满足我们的数据查询需求,例如对于商品、订单等数据的多维度检索。 使用 Elasticsearch 存储业务数据可以很好的解决我们业务中的搜索需求。而数据进行异构存储后,随之而来的就是数据同步的问题。 二、现有方法及问题 对于数据同步,我们目前的解决方案是建立数据中间表。把需要检索的业务数据,统一放到一张M

关于数据埋点,你需要了解这些基本知识

产品汪每天都在和数据打交道,你知道数据来自哪里吗? 移动app端内的用户行为数据大多来自埋点,了解一些埋点知识,能和数据分析师、技术侃大山,参与到前期的数据采集,更重要是让最终的埋点数据能为我所用,否则可怜巴巴等上几个月是常有的事。   埋点类型 根据埋点方式,可以区分为: 手动埋点半自动埋点全自动埋点 秉承“任何事物都有两面性”的道理:自动程度高的,能解决通用统计,便于统一化管理,但个性化定