精华内容
下载资源
问答
  • mysql主从复制读写分离
    千次阅读
    2022-06-13 15:40:17

    mysql主从复制与读写分离原理及详解

    大家好,我是酷酷的韩~
    酷酷的韩金群

    1.为什么需要主从复制?
    (1)在业务复杂的系统中,有这么一个情景,有一句sql语句需要锁表,导致暂时不能使用读的服务,那么就很影响运行中的业务,使用主从复制,让主库负责写,从库负责读,这样,即使主库出现了锁表的情景,通过读从库也可以保证业务的正常运作。
    (2)做数据的热备
    (3)架构的扩展。业务量越来越大,I/O访问频率过高,单机无法满足,此时做多库的存储,降低磁盘I/O访问的频率,提高单个机器的I/O性能。

    2.什么是mysql的主从复制?
    mysql主从复制是指数据可以从一个mysql数据库主节点复制到一个或多个从节点。Mysql默认采用异步复制方式,这样节点不用一直访问主服务器来更新自己的数据,数据的更新可以在远程连接上进行,从节点可以复制主数据库中的所有数据库或特定的数据库、数据表。

    3.mysql主从复制原理?
    (1)master服务器数据改变时会将其记录至二进制binlog日志中。
    (2)slave服务器会定时检测master服务器中的binlog日志是否发生变化,如变化则开始一个IO线程请求master binlog日志
    (3)同时主节点为每个I/O线程启动一个dump线程,用于向其发送二进制事件,并保存至从节点本地的中继日志中
    (4)从节点将启动sql线程从中继日志中读取二进制日志,在本地重放,使得数据与主节点保持一致,最后I/O线程和sql线程进入休眠状态,等待下一次唤醒。
    备注: master主服务器、slave从服务器

    也就是说:
    (1)从库生成两个线程 一个io线程 一个sql线程
    (2)io线程会请求主库的binlog日志,并将得到的binlog写到从库的relay-log(中继日志)
    (3)主库会为每一个从库的io线程启动一个dump线程,来传递binlog
    (4)sql线程读取中继日志,解析成sql语句执行。

    注意:
    (1)master将操作语句记录到binlog日志中,然后授权slave远程连接的权限(master一定要开启binlog二进制日志功能);通常为了数据安全考虑,slave也开启binlog功能。
    (2)slave开启两个线程:IO线程、sql线程。其中IO线程负责读取master的binlog内容到中继日志relay-log里;sql线程负责从relay日志里读取binlog内容,并更新到slave的数据库里,这样就能保证slave数据和master数据保持一致了。
    (3)mysql复制至少需要两个mysql的服务,当然mysql的服务可以分布在不同的服务器上,也可以在一台服务器上启动多个服务。
    (4)版本最好一致,至少master版本<=slave版本
    (5)master和slave两节点间时间需同步

    在这里插入图片描述

    4.读写分离介绍?
    mysql读写分离基本原理是让master数据库处理写的操作,slave数据库处理读的操作。master将写的操作同步到各个slave节点。
    mysql读写分离能提高系统性能的原因在于:
    (1)物理服务器增加,机器处理能力提升。拿硬件换性能。
    (2)主从只负责各自的读、写,极大程度缓解X锁和S锁争用。
    (3)slave可以配置myiasm引擎,提升查询性能以及节约系统开销。
    (4)master直接写是并发的,slave通过主库发送来的binlog恢复数据是异步。
    (5)slave可以单独设置一些参数来提升读的性能。
    (6)增加冗余,提高可用性。

    5.目前实现mysql的读写分离,主要有以下几种方案:
    (1)通过程序实现,网上很多现成的代码,比较复杂,如果添加从服务器要更改多台服务器的代码。
    (2)通过mysql-proxy来实现,由于mysql-proxy的主从读写分离是通过lua脚本来实现,目前lua的脚本的开发跟不上节奏,而写没有完美的现成的脚本,因此导致用于生产环境的话风险比较大,据网上很多人说mysql-proxy的性能不高。
    (3)自己开发接口实现,这种方案门槛高,开发成本高,不是一般的小公司能承担得起。
    (4)利用阿里巴巴的开源项目Amoeba来实现,具有负载均衡、高可用性、sql过滤、读写分离、可路由相关的query到目标数据库,并且安装配置非常简单。

    6.什么是amoeba?
    Amoeba(变形虫)项目,专注 分布式数据库 proxy 开发。座落与Client、DB Server(s)之间。对客户端透明。具有负载均衡、高可用性、sql过滤、读写分离、可路由相关的query到目标数据库、可并发请求多台数据库合并结果。
    主要解决:
    (1)降低数据切分带来的复杂多数据库结构
    (2)提供切分规则并降低 数据切分规则 给应用带来的影响
    (3)降低db与客户端的连接数
    (4)读写分离

    7.主从复制及读写分离操作
    主从复制与读写分离的安装及操作配置的文章已发布,可在本专栏内查找。

    只有历经沧桑,才能遇见曙光。 ------酷酷的韩

    更多相关内容
  • MySQL主从复制读写分离的设置非常简单: 修改配置my.cnf文件 master 和 slave设置的差不多: [mysqld] log-bin=mysql-bin server-id=222 log-bin=mysql-bin的意思是:启用二进制日志。 server-id=222的意思是...
  • 经本人测试已经成功实现
  • 一般来说mysql都是通过 主从复制(Master-Slave)的方式来同步数据,再通过读写分离MySQL-Proxy)来提升数据库的并发负载能力 这样的方案来进行部署与实施的。
  • 在数 据 管理 中,如果 对 MySQL数据库 的读 写操 作 都 在 同 一 个 数 据 库 服 务 器 中的 进 行 ,往 往 是 无 法 满足 实 际 需要 的 。 因为 ,这 样 做 不 仅 容 易 造 成 数 据 的 丢 失和 损 坏 ,而且 ...
  • 基于Mycat的Mysql主从复制读写分离配置详解与示例,DBA必看的
  • .基于Mycat的MySQL主从复制读写分离docker实现.
  • 1.环境准备:mysql主服务器IP:192.168.60.5 Mysql从1服务器IP:192.168.60.10 mysql从2服务器IP:192.168.60.11 Amoeba代理服务器IP;192.168.60.20 客户机IP:192.168.60.30 ...主从复制 读写分离 经本人测试已成功
  • 主要介绍了MySQL主从复制读写分离原理及用法,结合实例形式详细分析了mysql数据库主从复制读写分离基本概念、原理、用法及操作注意事项,需要的朋友可以参考下
  • MySQL主从配置,读写分离,详细完整教程,pdf文档思维导图
  • MySQL主从复制读写分离,看这篇就够了!

    万次阅读 多人点赞 2020-08-26 16:06:36
    前言在很多项目,特别是互联网项目,在使用MySQL时都会采用主从复制读写分离的架构。为什么要采用主从复制读写分离的架构?如何实现?有什么缺点?让我们带着这些问题开始这段学习之旅吧!为什么使用主从复制、...
    简介:什么是主从复制,如何实现读写分离,看这篇你就懂了!

    思维导图

    文章已收录到我的Github精选,欢迎Starhttps://github.com/yehongzhi/learningSummary

    前言

    在很多项目,特别是互联网项目,在使用MySQL时都会采用主从复制、读写分离的架构。

    为什么要采用主从复制读写分离的架构?如何实现?有什么缺点?让我们带着这些问题开始这段学习之旅吧!

    为什么使用主从复制、读写分离

    主从复制、读写分离一般是一起使用的。目的很简单,就是为了提高数据库的并发性能。你想,假设是单机,读写都在一台MySQL上面完成,性能肯定不高。如果有三台MySQL,一台mater只负责写操作,两台salve只负责读操作,性能不就能大大提高了吗?

    所以主从复制、读写分离就是为了数据库能支持更大的并发

    随着业务量的扩展、如果是单机部署的MySQL,会导致I/O频率过高。采用主从复制、读写分离可以提高数据库的可用性

    主从复制的原理

    ①当Master节点进行insert、update、delete操作时,会按顺序写入到binlog中。

    ②salve从库连接master主库,Master有多少个slave就会创建多少个binlog dump线程。

    ③当Master节点的binlog发生变化时,binlog dump 线程会通知所有的salve节点,并将相应的binlog内容推送给slave节点。

    ④I/O线程接收到 binlog 内容后,将内容写入到本地的 relay-log。

    ⑤SQL线程读取I/O线程写入的relay-log,并且根据 relay-log 的内容对从数据库做对应的操作。

    如何实现主从复制

    我这里用三台虚拟机(Linux)演示,IP分别是104(Master),106(Slave),107(Slave)。

    预期的效果是一主二从,如下图所示:

    Master配置

    使用命令行进入mysql:

    mysql -u root -p

    接着输入root用户的密码(密码忘记的话就网上查一下重置密码吧~),然后创建用户:

    //192.168.0.106是slave从机的IP
    GRANT REPLICATION SLAVE ON *.* to 'root'@'192.168.0.106' identified by 'Java@1234';
    //192.168.0.107是slave从机的IP
    GRANT REPLICATION SLAVE ON *.* to 'root'@'192.168.0.107' identified by 'Java@1234';
    //刷新系统权限表的配置
    FLUSH PRIVILEGES;

    创建的这两个用户在配置slave从机时要用到。

    接下来在找到mysql的配置文件/etc/my.cnf,增加以下配置:

    # 开启binlog
    log-bin=mysql-bin
    server-id=104
    # 需要同步的数据库,如果不配置则同步全部数据库
    binlog-do-db=test_db
    # binlog日志保留的天数,清除超过10天的日志
    # 防止日志文件过大,导致磁盘空间不足
    expire-logs-days=10 

    配置完成后,重启mysql:

    service mysql restart

    可以通过命令行show master status\G;查看当前binlog日志的信息(后面有用):

    Slave配置

    Slave配置相对简单一点。从机肯定也是一台MySQL服务器,所以和Master一样,找到/etc/my.cnf配置文件,增加以下配置:

    # 不要和其他mysql服务id重复即可
    server-id=106

    接着使用命令行登录到mysql服务器:

    mysql -u root -p

    然后输入密码登录进去。

    进入到mysql后,再输入以下命令:

    CHANGE MASTER TO 
    MASTER_HOST='192.168.0.104',//主机IP
    MASTER_USER='root',//之前创建的用户账号
    MASTER_PASSWORD='Java@1234',//之前创建的用户密码
    MASTER_LOG_FILE='mysql-bin.000001',//master主机的binlog日志名称
    MASTER_LOG_POS=862,//binlog日志偏移量
    master_port=3306;//端口

    还没完,设置完之后需要启动:

    # 启动slave服务
    start slave;

    启动完之后怎么校验是否启动成功呢?使用以下命令:

    show slave status\G;

    可以看到如下信息(摘取部分关键信息):

    *************************** 1. row ***************************
                   Slave_IO_State: Waiting for master to send event
                      Master_Host: 192.168.0.104
                      Master_User: root
                      Master_Port: 3306
                    Connect_Retry: 60
                  Master_Log_File: mysql-bin.000001
              Read_Master_Log_Pos: 619
                   Relay_Log_File: mysqld-relay-bin.000001
                    Relay_Log_Pos: 782
            Relay_Master_Log_File: mysql-bin.000001 //binlog日志文件名称
                 Slave_IO_Running: Yes //Slave_IO线程、SQL线程都在运行
                Slave_SQL_Running: Yes
                 Master_Server_Id: 104 //master主机的服务id
                      Master_UUID: 0ab6b3a6-e21d-11ea-aaa3-080027f8d623
                 Master_Info_File: /var/lib/mysql/master.info
                        SQL_Delay: 0
              SQL_Remaining_Delay: NULL
          Slave_SQL_Running_State: Slave has read all relay log; waiting for the slave I/O thread to update it
               Master_Retry_Count: 86400
                    Auto_Position: 0

    另一台slave从机配置一样,不再赘述。

    测试主从复制

    在master主机执行sql:

    CREATE TABLE `tb_commodity_info` (
      `id` varchar(32) NOT NULL,
      `commodity_name` varchar(512) DEFAULT NULL COMMENT '商品名称',
      `commodity_price` varchar(36) DEFAULT '0' COMMENT '商品价格',
      `number` int(10) DEFAULT '0' COMMENT '商品数量',
      `description` varchar(2048) DEFAULT '' COMMENT '商品描述',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品信息表';

    接着我们可以看到两台slave从机同步也创建了商品信息表:
    在这里插入图片描述

    主从复制就完成了!java技术爱好者有点东西哦~

    读写分离

    主从复制完成后,我们还需要实现读写分离,master负责写入数据,两台slave负责读取数据。怎么实现呢?

    实现的方式有很多,以前我公司是采用AOP的方式,通过方法名判断,方法名中有get、select、query开头的则连接slave,其他的则连接master数据库。

    但是通过AOP的方式实现起来代码有点繁琐,有没有什么现成的框架呢,答案是有的。

    Apache ShardingSphere 是一套开源的分布式数据库中间件解决方案组成的生态圈,它由 JDBC、Proxy两部分组成。

    ShardingSphere-JDBC定位为轻量级 Java 框架,在 Java 的 JDBC 层提供的额外服务。 它使用客户端直连数据库,以 jar 包形式提供服务,无需额外部署和依赖,可理解为增强版的 JDBC 驱动,完全兼容 JDBC 和各种 ORM 框架。

    读写分离就可以使用ShardingSphere-JDBC实现。
    在这里插入图片描述

    下面演示一下SpringBoot+Mybatis+Mybatis-plus+druid+ShardingSphere-JDBC代码实现。

    项目配置

    版本说明:

    SpringBoot:2.0.1.RELEASE
    druid:1.1.22
    mybatis-spring-boot-starter:1.3.2
    mybatis-plus-boot-starter:3.0.7
    sharding-jdbc-spring-boot-starter:4.1.1

    添加sharding-jdbc的maven配置:

    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        <version>4.1.1</version>
    </dependency>

    然后在application.yml添加配置:

    # 这是使用druid连接池的配置,其他的连接池配置可能有所不同
    spring:
      shardingsphere:
        datasource:
          names: master,slave0,slave1
          master:
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class-name: com.mysql.jdbc.Driver
            url: jdbc:mysql://192.168.0.108:3306/test_db?useUnicode=true&characterEncoding=utf8&tinyInt1isBit=false&useSSL=false&serverTimezone=GMT
            username: yehongzhi
            password: YHZ@1234
          slave0:
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class-name: com.mysql.jdbc.Driver
            url: jdbc:mysql://192.168.0.109:3306/test_db?useUnicode=true&characterEncoding=utf8&tinyInt1isBit=false&useSSL=false&serverTimezone=GMT
            username: yehongzhi
            password: YHZ@1234
          slave1:
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class-name: com.mysql.jdbc.Driver
            url: jdbc:mysql://192.168.0.110:3306/test_db?useUnicode=true&characterEncoding=utf8&tinyInt1isBit=false&useSSL=false&serverTimezone=GMT
            username: yehongzhi
            password: YHZ@1234
        props:
          sql.show: true
        masterslave:
          load-balance-algorithm-type: round_robin
        sharding:
          master-slave-rules:
            master:
              master-data-source-name: master
              slave-data-source-names: slave0,slave1

    sharding.master-slave-rules是标明主库和从库,一定不要写错,否则写入数据到从库,就会导致无法同步。

    load-balance-algorithm-type是路由策略,round_robin表示轮询策略。

    启动项目,可以看到以下信息,代表配置成功:

    编写Controller接口:

        /**
         * 添加商品
         *
         * @param commodityName  商品名称
         * @param commodityPrice 商品价格
         * @param description    商品价格
         * @param number         商品数量
         * @return boolean 是否添加成功
         * @author java技术爱好者
         */
        @PostMapping("/insert")
        public boolean insertCommodityInfo(@RequestParam(name = "commodityName") String commodityName,
                                           @RequestParam(name = "commodityPrice") String commodityPrice,
                                           @RequestParam(name = "description") String description,
                                           @RequestParam(name = "number") Integer number) throws Exception {
            return commodityInfoService.insertCommodityInfo(commodityName, commodityPrice, description, number);
        }

    准备就绪,开始测试!

    测试

    打开POSTMAN,添加商品:

    控制台可以看到如下信息:

    查询数据的话则通过slave进行:

    就是这么简单!

    缺点

    尽管主从复制、读写分离能很大程度保证MySQL服务的高可用和提高整体性能,但是问题也不少:

    • 从机是通过binlog日志从master同步数据的,如果在网络延迟的情况,从机就会出现数据延迟。那么就有可能出现master写入数据后,slave读取数据不一定能马上读出来

    可能有人会问,有没有事务问题呢?

    实际上这个框架已经想到了,我们看回之前的那个截图,有一句话是这样的:

    微信公众号已开启:【java技术爱好者】,没关注的同学记得关注哦~

    我是java技术爱好者,罗定的java精英,人称 【罗ja英】

    坚持原创,持续输出兼具广度和深度的技术文章。

    上面所有例子的代码都上传Github了:

    https://github.com/yehongzhi/mall

    你的点赞是我创作的最大动力~

    拒绝做一条咸鱼,我是一个努力让大家记住的程序员。我们下期再见!!!
    3.png

    原文链接:https://developer.aliyun.com/article/770923?

    版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。
    展开全文
  • 配置主从复制 创建主从复制账户 查看主mysql状态 配置从mysql数据库复制账户 启动从数据库复制进程 安装JDK和amoeba 解压JDK 移动JDK位置 创建amoeba配置文件 配置环境变量 查看jdk版本 5.主mysql、两个...

    配置NTP时间服务器
    1)安装NTP时间服务器
    在这里插入图片描述
    修改ntp主配置文件
    在这里插入图片描述
    在这里插入图片描述
    设置开机自启
    在这里插入图片描述
    从mysql服务器同步时间
    在这里插入图片描述
    在这里插入图片描述
    2.配置主mysql
    ①编译安装mysql服务。
    在这里插入图片描述
    在这里插入图片描述
    配置主从复制
    创建主从复制账户
    在这里插入图片描述
    在这里插入图片描述
    查看主mysql状态
    在这里插入图片描述
    配置从mysql数据库复制账户
    在这里插入图片描述
    启动从数据库复制进程
    在这里插入图片描述
    安装JDK和amoeba
    解压JDK
    在这里插入图片描述
    移动JDK位置
    在这里插入图片描述
    创建amoeba配置文件
    在这里插入图片描述
    配置环境变量
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    查看jdk版本
    在这里插入图片描述
    5.主mysql、两个从mysql创建读写分 离账号
    在这里插入图片描述
    修改amoeba配置文件设置登录amoeba账户
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    启动amoeba服务
    在这里插入图片描述
    安装mysql客户端
    在这里插入图片描述
    登录amoeba
    在这里插入图片描述

    展开全文
  • MySQL5.6主从复制(读写分离)教程 1、MySQL5.6开始主从复制有两种方式: 基于日志(binlog); 基于GTID(全局事务标示符)。 需要注意的是:GTID方式不支持临时表!所以如果你的业务系统要用到临时表的话就不要考虑...
  • mysql主从复制&读写分离

    千次阅读 2022-03-19 23:03:31
    MySQL主从复制1.1 介绍1.2 搭建1.2.1 准备工作1.2.2 主库配置1.2.3 从库配置1.3 测试2. 读写分离案例2.1 背景介绍2.2 ShardingJDBC介绍2.3 数据库环境2.4 初始工程导入2.5 读写分离配置2.6 测试3. 项目实现读写分离...

    本文内容

    • MySQL主从复制
    • 读写分离案例
    • 项目实现读写分离

    前言

    1). 存在的问题

    在前面基础功能实现的过程中,我们后台管理系统及移动端的用户,在进行数据访问时,都是直接操作数据库MySQL的。结构如下图:

    在这里插入图片描述

    而在当前,MySQL服务器只有一台,那么就可能会存在如下问题:

    1). 读和写所有压力都由一台数据库承担,压力大

    2). 数据库服务器磁盘损坏则数据丢失,单点故障

    2). 解决方案

    为了解决上述提到的两个问题,我们可以准备两台MySQL,一台主(Master)服务器,一台从(Slave)服务器,主库的数据变更,需要同步到从库中(主从复制)。而用户在访问我们项目时,如果是写操作(insert、update、delete),则直接操作主库;如果是读(select)操作,则直接操作从库(在这种读写分离的结构中,从库是可以有多个的),这种结构我们称为 读写分离 。

    在这里插入图片描述

    今天我们就需要实现上述的架构,来解决业务开发中所存在的问题。

    1. MySQL主从复制

    MySQL数据库默认是支持主从复制的,不需要借助于其他的技术,我们只需要在数据库中简单的配置即可。接下来,我们就从以下的几个方面,来介绍一下主从复制:

    1.1 介绍

    MySQL主从复制是一个异步的复制过程,底层是基于Mysql数据库自带的 二进制日志 功能。就是一台或多台MySQL数据库(slave,即从库)从另一台MySQL数据库(master,即主库)进行日志的复制,然后再解析日志并应用到自身,最终实现 从库 的数据和 主库 的数据保持一致。MySQL主从复制是MySQL数据库自带功能,无需借助第三方工具。

    二进制日志:

    ​ 二进制日志(BINLOG)记录了所有的 DDL(数据定义语言)语句和 DML(数据操纵语言)语句,但是不包括数据查询语句。此日志对于灾难时的数据恢复起着极其重要的作用,MySQL的主从复制, 就是通过该binlog实现的。默认MySQL是未开启该日志的。

    MySQL的主从复制原理如下:

    在这里插入图片描述

    MySQL复制过程分成三步:

    1). MySQL master 将数据变更写入二进制日志( binary log)

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

    3). slave重做中继日志中的事件,将数据变更反映它自己的数据

    1.2 搭建

    1.2.1 准备工作

    提前准备两台服务器,并且在服务器中安装MySQL,服务器的信息如下:

    数据库IP数据库版本
    Master192.168.200.2005.7.25
    Slave192.168.200.2015.7.25

    并在两台服务器上做如下准备工作:

    1). 防火墙开放3306端口号

    firewall-cmd --zone=public --add-port=3306/tcp --permanent
    
    firewall-cmd --zone=public --list-ports
    

    在这里插入图片描述

    2). 并将两台数据库服务器启动起来:

    systemctl start mysqld
    

    登录MySQL,验证是否正常启动

    在这里插入图片描述

    1.2.2 主库配置

    服务器: 192.168.138.100

    1). 修改Mysql数据库的配置文件/etc/my.cnf

    在最下面增加配置:

    log-bin=mysql-bin   #[必须]启用二进制日志
    server-id=100       #[必须]服务器唯一ID(唯一即可)
    

    在这里插入图片描述

    2). 重启Mysql服务

    执行指令:

     systemctl restart mysqld
    

    在这里插入图片描述

    3). 创建数据同步的用户并授权

    登录mysql,并执行如下指令,创建用户并授权:

    GRANT REPLICATION SLAVE ON *.* to 'xiaoming'@'%' identified by 'Root@123456';
    

    注:上面SQL的作用是创建一个用户 xiaoming ,密码为 Root@123456 ,并且给xiaoming用户授予REPLICATION SLAVE权限。常用于建立复制时所需要用到的用户权限,也就是slave必须被master授权具有该权限的用户,才能通过该用户复制。

    MySQL密码复杂程度说明:

    ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ye9VABWV-1647702497586)(assets/image-20210825144818269.png)]

    ​ 目前mysql5.7默认密码校验策略等级为 MEDIUM , 该等级要求密码组成为: 数字、小写字母、大写字母 、特殊字符、长度至少8位

    4). 登录Mysql数据库,查看master同步状态

    执行下面SQL,记录下结果中FilePosition的值

    show master status;
    

    在这里插入图片描述

    注:上面SQL的作用是查看Master的状态,执行完此SQL后不要再执行任何操作

    1.2.3 从库配置

    服务器: 192.168.138.101

    1). 修改Mysql数据库的配置文件/etc/my.cnf

    server-id=101 	#[必须]服务器唯一ID
    

    在这里插入图片描述

    2). 重启Mysql服务

    systemctl restart mysqld
    

    3). 登录Mysql数据库,设置主库地址及同步位置

    change master to master_host='192.168.138.100',master_user='xiaoming',master_password='Root@123456',master_log_file='mysql-bin.000003',master_log_pos=389;
    
    start slave;
    

    参数说明:

    ​ A. master_host : 主库的IP地址

    ​ B. master_user : 访问主库进行主从复制的用户名(上面在主库创建的)

    ​ C. master_password : 访问主库进行主从复制的用户名对应的密码

    ​ D. master_log_file : 从哪个日志文件开始同步(上述查询master状态中展示的有)

    ​ E. master_log_pos : 从指定日志文件的哪个位置开始同步(上述查询master状态中展示的有)

    4). 查看从数据库的状态

    show slave status;
    

    然后通过状态信息中的 Slave_IO_running 和 Slave_SQL_running 可以看出主从同步是否就绪,如果这两个参数全为Yes,表示主从同步已经配置完成。

    在这里插入图片描述

    MySQL命令行技巧:

    ​ \G : 在MySQL的sql语句后加上\G,表示将查询结果进行按列打印,可以使每个字段打印到单独的行。即将查到的结构旋转90度变成纵向;

    1.3 测试

    主从复制的环境,已经搭建好了,接下来,我们可以通过Navicat连接上两台MySQL服务器,进行测试。测试时,我们只需要在主库Master执行操作,查看从库Slave中是否将数据同步过去即可。

    1). 在master中创建数据库itcast, 刷新slave查看是否可以同步过去

    在这里插入图片描述

    2). 在master的itcast数据下创建user表, 刷新slave查看是否可以同步过去

    在这里插入图片描述

    3). 在master的user表中插入一条数据, 刷新slave查看是否可以同步过去

    在这里插入图片描述

    2. 读写分离案例

    2.1 背景介绍

    面对日益增加的系统访问量,数据库的吞吐量面临着巨大瓶颈。 对于同一时刻有大量并发读操作和较少写操作类型的应用系统来说,将数据库拆分为主库从库,主库负责处理事务性的增删改操作,从库负责处理查询操作,能够有效的避免由数据更新导致的行锁,使得整个系统的查询性能得到极大的改善。

    在这里插入图片描述

    通过读写分离,就可以降低单台数据库的访问压力, 提高访问效率,也可以避免单机故障。

    主从复制的结构,我们在第一节已经完成了,那么我们在项目中,如何通过java代码来完成读写分离呢,如何在执行select的时候查询从库,而在执行insert、update、delete的时候,操作主库呢?这个时候,我们就需要介绍一个新的技术 ShardingJDBC。

    2.2 ShardingJDBC介绍

    Sharding-JDBC定位为轻量级Java框架,在Java的JDBC层提供的额外服务。 它使用客户端直连数据库,以jar包形式提供服务,无需额外部署和依赖,可理解为增强版的JDBC驱动,完全兼容JDBC和各种ORM框架。

    使用Sharding-JDBC可以在程序中轻松的实现数据库读写分离。

    Sharding-JDBC具有以下几个特点:

    1). 适用于任何基于JDBC的ORM框架,如:JPA, Hibernate, Mybatis, Spring JDBC Template或直接使用JDBC。

    2). 支持任何第三方的数据库连接池,如:DBCP, C3P0, BoneCP, Druid, HikariCP等。

    3). 支持任意实现JDBC规范的数据库。目前支持MySQL,Oracle,SQLServer,PostgreSQL以及任何遵循SQL92标准的数据库。

    依赖:

    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        <version>4.0.0-RC1</version>
    </dependency>
    

    2.3 数据库环境

    在主库中创建一个数据库rw, 并且创建一张表, 该数据库及表结构创建完毕后会自动同步至从数据库,SQL语句如下:

    create database rw default charset utf8mb4;
    
    use rw;
    
    CREATE TABLE `user` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(255) DEFAULT NULL,
      `age` int(11) DEFAULT NULL,
      `address` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    

    在这里插入图片描述

    2.4 初始工程导入

    我们本案例主要是演示一下读写分离操作,对于基本的增删改查的业务操作,我们就不再去编写了,我们可以直接导入资料中提供的demo工程(rw_demo),在demo工程中,我们已经完成了user的增删改查操作,具体的工程结构如下:

    在这里插入图片描述

    2.5 读写分离配置

    1). 在pom.xml中增加shardingJdbc的maven坐标

    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        <version>4.0.0-RC1</version>
    </dependency>
    

    2). 在application.yml中增加数据源的配置

    spring:
      shardingsphere:
        datasource:
          names:
            master,slave
          # 主数据源
          master:
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class-name: com.mysql.cj.jdbc.Driver
            url: jdbc:mysql://192.168.200.200:3306/rw?characterEncoding=utf-8
            username: root
            password: root
          # 从数据源
          slave:
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class-name: com.mysql.cj.jdbc.Driver
            url: jdbc:mysql://192.168.200.201:3306/rw?characterEncoding=utf-8
            username: root
            password: root
        masterslave:
          # 读写分离配置
          load-balance-algorithm-type: round_robin #轮询
          # 最终的数据源名称
          name: dataSource
          # 主库数据源名称
          master-data-source-name: master
          # 从库数据源名称列表,多个逗号分隔
          slave-data-source-names: slave
        props:
          sql:
            show: true #开启SQL显示,默认false
    

    配置解析:

    在这里插入图片描述

    3). 在application.yml中增加配置

    spring:  
      main:
        allow-bean-definition-overriding: true
    

    该配置项的目的,就是如果当前项目中存在同名的bean,后定义的bean会覆盖先定义的。

    如果不配置该项,项目启动之后将会报错:

    在这里插入图片描述

    报错信息表明,在声明 org.apache.shardingsphere.shardingjdbc.spring.boot 包下的SpringBootConfiguration中的dataSource这个bean时出错, 原因是有一个同名的 dataSource 的bean在com.alibaba.druid.spring.boot.autoconfigure包下的DruidDataSourceAutoConfigure类加载时已经声明了。

    在这里插入图片描述

    在这里插入图片描述

    而我们需要用到的是 shardingjdbc包下的dataSource,所以我们需要配置上述属性,让后加载的覆盖先加载的。

    2.6 测试

    我们使用shardingjdbc来实现读写分离,直接通过上述简单的配置就可以了。配置完毕之后,我们就可以重启服务,通过postman来访问controller的方法,来完成用户信息的增删改查,我们可以通过debug及日志的方式来查看每一次执行增删改查操作,使用的是哪个数据源,连接的是哪个数据库。

    1). 保存数据

    在这里插入图片描述

    控制台输出日志,可以看到操作master主库:

    在这里插入图片描述

    2). 修改数据

    在这里插入图片描述

    控制台输出日志,可以看到操作master主库:

    在这里插入图片描述

    3). 查询数据

    在这里插入图片描述

    控制台输出日志,可以看到操作slave主库:

    在这里插入图片描述

    4). 删除数据

    在这里插入图片描述

    控制台输出日志,可以看到操作master主库:

    在这里插入图片描述

    3. 项目实现读写分离

    3.1 数据库环境准备

    直接使用我们前面在虚拟机中搭建的主从复制的数据库环境即可。在主库中创建瑞吉外卖项目的业务数据库reggie, 并导入相关表结构和数据(我们可以将自己之前在本地开发时使用的数据库数据导出, 然后导入到服务器中的主库即可)。

    1). 将自己本地的reggie数据库的数据导出SQL文件

    在这里插入图片描述

    这样做的话,我们之前自己开发时,添加的测试数据都还在的,便于测试。

    2). 在主数据库master中,创建数据库reggie,并导入该SQL文件

    master中创建数据库,会自动同步至slave从库

    在这里插入图片描述

    在master的reggie中导入sql文件

    在这里插入图片描述

    3.2 创建Git分支

    目前默认git中有两个分支master 和 v1.0 ,我们接下来进行读写分离的优化,就不在master和v1.0分支来操作了,我们需要在git上创建一个单独的分支v1.1,读写分离的优化,我们就在该分支上进行操作。具体创建分支的操作,和前面演示的一致。

    当前创建的v1.1分支,是基于master分支创建出来的,所以目前master分支的代码, 和v1.1分支的代码是完全一样的,接下来把v1.1的代码也推送至远程仓库。

    3.3 读写分离配置

    1). 在项目的pom.xml增加依赖

    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        <version>4.0.0-RC1</version>
    </dependency>
    

    2). 在项目的application.yml中配置数据源相关信息

    spring:
      shardingsphere:
        datasource:
          names:
            master,slave
          # 主数据源
          master:
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class-name: com.mysql.cj.jdbc.Driver
            url: jdbc:mysql://192.168.200.200:3306/reggie?characterEncoding=utf-8
            username: root
            password: root
          # 从数据源
          slave:
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class-name: com.mysql.cj.jdbc.Driver
            url: jdbc:mysql://192.168.200.201:3306/reggie?characterEncoding=utf-8
            username: root
            password: root
        masterslave:
          # 读写分离配置
          load-balance-algorithm-type: round_robin #轮询
          # 最终的数据源名称
          name: dataSource
          # 主库数据源名称
          master-data-source-name: master
          # 从库数据源名称列表,多个逗号分隔
          slave-data-source-names: slave
        props:
          sql:
            show: true #开启SQL显示,默认false
      main:
        allow-bean-definition-overriding: true
    

    3.4 功能测试

    配置完毕之后,我们启动项目进行测试,直接访问系统管理后台的页面,然后执行相关业务操作,看控制台输出的日志信息即可。

    查询操作:

    在这里插入图片描述

    更新操作:

    在这里插入图片描述

    插入操作:

    在这里插入图片描述

    删除操作:

    在这里插入图片描述

    3.5 Git合并代码

    读写分离的功能我们已经实现完毕了,那么接下来,我们就可以将当前分支v1.1代码提交并推送到远程仓库。

    在这里插入图片描述

    在这里插入图片描述

    然后,再将v1.1的代码,合并到master分支,然后推送至远程仓库。

    在这里插入图片描述

    展开全文
  • 向上扩展,垂直扩展向外扩展,横向扩展读写分离复制:每个节点都有相同的数据集,向外扩展,基于二进制日志的单向复制读写分离,基本的原理是:数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。...
  • Mycat+MySQL主从复制读写分离验证安装手册
  • 1.1 什么是读写分离? 读写分离,基本的原理是让主数据库处理事务性增、改、删操作( INSERT、UPDATE、DELETE) ,而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库,,,...
  • Mysql主从复制读写分离

    千次阅读 2022-02-21 14:43:10
    文章目录Mysql主从复制原理Mysql支持的复制类型Mysql主从复制工作过程MySQL读写分离Mysql主从复制的几个同步模式Mysql主从配置半同步配置Amoeba代理读写分离 Mysql主从复制原理 MySQL 的主从复制和 MySQL 的读写分离...
  • 主从复制读写分离
  • 文章目录一、MySQL 主从复制1.1 主从复制架构1.2 主从复制原理1.2.1 主从复制相关线程1.2.2 复制功能相关的文件1.2.3 复制的作用1.2.4 MySQL 主从复制延迟1.3 读写分离1.3.1 读写分离基本原理1.3.2 读写分离原理...
  • mysql_master_slave.zip
  • MySQL主从复制是一个异步的复制过程,底层是基于Mysql数据库自带的二进制日志功能,我们只需要在数据库中简单的配置即可,不需要借助于其他的技术MySQL数据库默认是支持主从复制的,依靠的就是MySQL自带的二进制日志...
  • MySQL主从复制读写分离

    千次阅读 2022-02-16 15:24:41
    一、MySQL主从复制读写分离概念 1、什么是读写分离? 读写分离,基本的原理是让主数据库处理事务性增、改、删操作(INSERT、 UPDATE、DELETE) ,而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的...
  • 基于docker搭建mysql主从复制读写分离
  • 本文实例讲述了CentOS服务器搭建mysql主从复制读写分离的方法。分享给大家供大家参考,具体如下: mysql 主从复制的优点: ① 如果主服务器出现问题, 可以快速切换到从服务器提供的服务,保证高可用性 ② 可以在从...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,972
精华内容 23,188
关键字:

mysql主从复制读写分离

mysql 订阅