正文 

当前位置： 首页 > 代码 > java教程

mysql主从复制原理和使用(代码片段)

Java技术那些事儿 Java技术那些事儿     2022-10-22     216

关键词：

概述

实际生产的过程中为了实现数据库的高可用，不会只有一个数据库节点。至少会搭建主从复制的数据库架构，从库可以作为主库的数据备份，以免主数据库损坏的情况下丢失数据；当访问量增加的时候可以作为读节点承担部分流量等。下面就进行从零开始搭建MySQL的主从架构。

主从复制原理

以MySQL一主两从架构为为例，也就是一个master节点下有两个slave节点，在这套架构下，写操作统一交给master节点，读请求交给slave节点处理。

为了保证master节点和slave节点数据一致，在master节点写入数据后，会同时将数据复制到对应的slave节点。主从复制数据的过程中会用到三个线程，master节点上的binlog dump线程，slave节点的I\\O线程和SQL线程。

主从复制的核心流程：

  1. 当master节点接收到一个写请求时，这个写请求可能是增删改操作，此时会把写请求的操作都记录到binlog日志中。
  2. master节点会把数据赋值给slave节点，如图中的两个slave节点。这个过程首先得要每个slave节点连接到master节点上，当slave节点连接到master节点上时，master节点会为每一个slave节点分别创建一个binlog dump线程，用于向每个slave节点发送binlog日志。
  3. 此时，binlog dump线程会读取master节点上的binlog日志，然后将binlog日志发送给slave节点上的I/O线程。
  4. slave几点上的I/O线程接收到binlog日之后，会将binlog日志先写入到本地的relaylog中，relaylog中就保存了master的binlog日志。
  5. 最后，slave节点上的SQL线程会读取relaylog中的biinlog日志，将其解析成具体的增删改操作，把这些在master节点上进行过的操作，重新在slave节点上也重做一遍，打到数据还原的效果，这样就可以保证master节点和slave节点的数据一致性了。

主从复制模式

MySQL的主从复制模式分为：全同步复制，异步复制，半同步复制，增强半同步复制。

  • 全同步复制

全同步复制，就是当主库执行完一个事物之后，要求所有的从库也都必须执行完该事务，才可以返回处理结果给客户端；因此虽然全同步复制数据一致性得到保证了，但是主库完成一个事物需要等待所有从库也完成，性能就比较低了。

  • 异步复制

异步复制，当主库提交事务后会通知binlog dump线程发送binlog日志给从库，一旦binlog dump线程将binlog日志发送给从库之后，不需要等到从库也同步完成事务，主库就会讲处理结果返回给客户端。

因为主库只管自己执行完事务，就可以将处理结果返回给客户端，而不用关系从库是否执行完事务，这就可能导致短暂的主从数据不一致的问题了，比如刚在主库插入的数据，如果马上在从库查询就可能查询不到。

当主库提交食物后，如果宕机挂掉了，此时可能binlog还没来得及同步给从库，这时候如果为了回复故障切换主从节点的话，就会出现数据丢失的问题，所以异步复制虽然性能高，但数据一致性上是比较弱的。

MySQL默认采用的是异步复制模式。

  • 半同步复制

半同步复制就是在同步复制和异步中做了折中选择，我们可以结合着MySQL官网来看下是半同步和主从复制的过程。

当主库提交事务后，至少还需要一个从库返回接收到binlog日志，并成功写入到relaylog的消息，这个的时候，主库才会讲处理结果返回给客户端。

相比前两种复制方式，半同步复制较好地兼顾了数据一致性以及性能损耗的问题。

同时，半同步复制也存在以下几个问题：

  1. 半同步复制的性能，相比异步复制而言有所下降，因为需要等到等待至少一个从库确认接收到binlog日志的响应，所以新能上是有所损耗的。
  2. 主库等待从库响应的最大时长我们是可以配置的，如果超过了我们配置的事件，半同步复制就会变成异步复制，那么，异步复制的问题同样也就出现了。
  3. 在MySQL5.7.2之前的版本中，半同步复制存在幻读问题。当主库成功提交事务并处于等待从库确认的过程中，这个时候，从库都还没来得及返回处理结果给客户端，但因为主库存储引擎内部已经提交事务了，所以，其他客户端是可以到主库中读到数据的。但是，如果下一秒主库宕机，下次请求过来只能读取从库，因为从库还没有从主库同步数据，所以从库中读取不到这条数据了，和上一次读取数据的结果相比，就造成了幻读的现象。

  • 增强半同步复制

增强半同步复制是MySQL5.7.2后的版本对半同步复制做的一个改进，原理几乎是一样的，主要是解决幻读的问题。

主库配置了参数rpl_semi_sync_master_wait_point=AFTER_SYNC后，主库在存储引擎提交事务前，必须先首都哦啊从库数据同步完成的确认信息后，才能提交事务，以此来解决幻读问题。

主从同步实战

  • 准备数据源

config/datasource.properties

# masters
spring.datasource.masters.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.masters.url=jdbc:mysql://192.168.1.111:3306/monomer_order?useUnicode=true&characterEncoding=utf8&useSSL=false&autoReconnect=true&zeroDateTimeBehavior=convertToNull
spring.datasource.masters.username=root
spring.datasource.masters.password=123456
​
# slaves
spring.datasource.slaves[0].driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.slaves[0].url=jdbc:mysql://192.168.1.112:3306/monomer_order?useUnicode=true&characterEncoding=utf8&useSSL=false&autoReconnect=true&zeroDateTimeBehavior=convertToNull
spring.datasource.slaves[0].username=root
spring.datasource.slaves[0].password=123456
  • 配置数据源
package com.xinxin.order.context.config;
​
import com.alibaba.druid.pool.DruidDataSourceFactory;
import lombok.Data;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.*;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.util.CollectionUtils;
​
import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
​
@Slf4j
@Data
@Configuration
@PropertySource("classpath:config/datasource.properties")
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceConfig 
    /**
     * 主库数据源信息
     */
    private Map<String, String> masters;
    /**
     * 从库数据源信息
     */
    private List<Map<String, String>> slaves;
​
    @SneakyThrows
    @Bean
    public DataSource masterDataSource() 
        log.info("masters:", masters);
        if (CollectionUtils.isEmpty(masters)) 
            throw new Exception("主库数据源不能为空");
        
        return DruidDataSourceFactory.createDataSource(masters);
    
​
    @SneakyThrows
    @Bean
    public List<DataSource> slaveDataSources() 
        if (CollectionUtils.isEmpty(slaves)) 
            throw new Exception("从库数据源不能为空");
        
        final ArrayList<DataSource> dataSources = new ArrayList<>();
        for (Map<String, String> slaveProperties : slaves) 
            log.info("slave:", slaveProperties);
            dataSources.add(DruidDataSourceFactory.createDataSource(slaveProperties));
        
        return dataSources;
    
​
    @Bean
    @Primary
    @DependsOn("masterDataSource", "slaveDataSources")
    public DataSource routingDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                        @Qualifier("slaveDataSources") List<DataSource> slaveDataSources) 
        final Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceContextHolder.MASTER, masterDataSource);
        for (int i = 0; i < slaveDataSources.size(); i++) 
            targetDataSources.put(DataSourceContextHolder.SLAVE + i, slaveDataSources.get(i));
        
        final DataSourceRouter dataSourceRouter = new DataSourceRouter();
        dataSourceRouter.setTargetDataSources(targetDataSources);
        dataSourceRouter.setDefaultTargetDataSource(masterDataSource);
        return dataSourceRouter;
    
​
    @Bean
    public DataSourceTransactionManager dataSourceTransactionManager(
            @Qualifier("routingDataSource") DataSource routingDataSource) 
        return new DataSourceTransactionManager(routingDataSource);
  • 数据源上下文切换
package com.xinxin.order.context.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

@Slf4j
public class DataSourceContextHolder 
    public static final String MASTER = "master";
    public static final String SLAVE = "slave";

    private static ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    public static void setDatasourceType(String dataSourceType) 
        if (StringUtils.isBlank(dataSourceType)) 
            log.error("dataSourceType为空");
        
        log.info("设置dataSource: ", dataSourceType);
        CONTEXT_HOLDER.set(dataSourceType);
    

    public static String getDataSourceType() 
        return CONTEXT_HOLDER.get() == null ? MASTER : CONTEXT_HOLDER.get();
    

    public static void remove() 
        CONTEXT_HOLDER.remove();
  • 数据源路由实现类
package com.xinxin.order.context.config;
​
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
​
@Slf4j
public class DataSourceRouter extends AbstractRoutingDataSource 
    @Override
    protected Object determineCurrentLookupKey() 
        log.info("当前数据源为: ", DataSourceContextHolder.getDataSourceType());
        return DataSourceContextHolder.getDataSourceType();
  • 数据源切换注解
@Target(ElementType.METHOD, ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadOnly 
    String value() default DataSourceContextHolder.MASTER;
  • 动态数据源切换切面
package com.xinxin.order.aspect;

import com.xinxin.order.annotation.ReadOnly;
import com.xinxin.order.context.config.DataSourceContextHolder;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class DynamicDataSourceAspect implements Ordered 

    @Before(value = "execution(* *(..))&& @annotation(readOnly)")
    public void before(JoinPoint joinPoint, ReadOnly readOnly) 
        log.info(joinPoint.getSignature().getName() + "走从库");
        DataSourceContextHolder.setDatasourceType(DataSourceContextHolder.SLAVE);
    

    @After(value = "execution(* *(..))&& @annotation(readOnly)")
    public void after(JoinPoint joinPoint, ReadOnly readOnly) 
        log.info(joinPoint.getSignature().getName() + "清除数据源");
        DataSourceContextHolder.remove();
    

    @Override
    public int getOrder() 
        return 0;

总结

项目整合读写分离主要是通过收到注入数据源，并通过拦截器设置当前线程的数据源类型，需要使用数据源的地方会通过数据源路由器读取当前线程的数据源类型后返回实际的数据源进行数据库的操作。

mysql数据库——主从复制与读写分离(代码片段)

文章目录前言一、MySQL主从复制1.支持的复制类型2.主从复制的工作过程是基于日志3.请求方式4.主从复制的原理5.MySQL集群和主从复制分别适合在什么场景下使用6.为什么使用主从复制、读写分离7.用途及条件8.mysql主从复制存在的... 查看详情

简述mysql主从复制的原理面试必看(代码片段)

MySQL主从复制主节点和从节点同步数据，每个节点保持数据一致MySQL主从复制的作用实现负载均衡读写分离实现数据库备份实现数据库高可用和故障切换MySQL主从复制原理和过程MySQL主从复制依赖二进制日志实现主节点更新数... 查看详情

mysql(23)—数据库主从复制的基本原理和步骤(代码片段)

详细介绍了MySQL主从复制的原理和基本流程，以及一些问题的处理方式。文章目录1主从复制的原理2主从切换3双主互备4主备延迟4.1什么是主备延迟4.2主备延迟的原因4.3主备切换策略4.3.1可靠性优先策略4.3.2可用性优先策略1.4.... 查看详情

mysql主从复制(代码片段)

目录主从复制基础主从复制简介主从复制前提主从复制搭建主库配置（3307实例）从库配置（3308实例）主从复制原理主从复制相关文件主从复制相关线程主从复制图解原理主从故障监控/分析/处理IO线程故障连接主... 查看详情

半万字长文学习mysql主从复制原理，面试必问，建议收藏！(代码片段)

快速导航一、主从复制到底是啥1、一张图过程2、新的备库与主库同步方法3、复制配置二、主从复制有什么用1、数据备份2、负载均衡3、高可用性和故障切换4、MySQL升级测试三、复制原理有2个1、基于语句的复制：2、基于行... 查看详情

半万字长文学习mysql主从复制原理，面试必问，建议收藏！(代码片段)

快速导航一、主从复制到底是啥1、一张图过程2、新的备库与主库同步方法3、复制配置二、主从复制有什么用1、数据备份2、负载均衡3、高可用性和故障切换4、MySQL升级测试三、复制原理有2个1、基于语句的复制：2、基于行... 查看详情

mysql运维主从复制--主从复制概述主从复制原理搭建mysql主从复制(代码片段)

文章目录1.主从复制概述2.主从复制原理3.搭建3.1服务器准备3.2主库配置3.2.1修改配置文件/etc/my.cnf3.2.2重启MySQL服务器3.2.3登录mysql，创建远程连接的账号，并授予主从复制权限3.2.4通过指令，查看二进制日志坐标3.3从库... 查看详情

mysql主从复制原理及一主一从搭建过程—2023.04(代码片段)

文章目录一、MySQL主从复制介绍1、主从复制概念2、为什么要做主从复制3、主从复制原理4、主从复制形式5、主从复制主要用途二、MySQL一主一从搭建1、准备工作2、MySQL主从复制部署流程1.关闭防火墙，两台主机都操作2.修改配置... 查看详情

mysql主从复制(代码片段)

MySQL主从复制前言：一.什么叫高可性：二.MySQL设计思路三.MySQL主从复制原理3.1MySQL的复制类型3.2MySQL主从复制默认使用的机制3.3MySQL主从复制工作过程四.主从复制配置4.1主从服务器时间同步4.2配置主从同步4.3配置规则4.4验... 查看详情

精华推荐|mysql技术专题「主从同步架构」全面详细透析mysql的三种主从复制（replication）机制的原理和实战开发（原理+实战）(代码片段)

...请求都是查询操作。此时，我们可以将数据库扩展成主从复制模式，将读操作和写操作分离开来，多台数据库分摊请求，从而减少单库的访问压力，进而应用得到优化。复制概述Replication复制是指将主数据库的... 查看详情

mysql主从复制与读写分离（原理深刻，过程详细，值得一看）(代码片段)

...是读写分离(2)为什么要读写分离(3)什么时候要读写分离(4)主从复制与读写分离2.MySQL主从复制(1)mysql支持的复制类型(2)主从复制的工作过程(3)mysql主从复制高延迟的原因(4)mysql主从复制高延迟的解决办法3.常见的MySQL读写分离方式(1)... 查看详情

主从复制和读写分离(代码片段)

主从复制和读写分离一.概述二.主从复制原理1.mysql复制类型2.mysql主从复制的工作过程三.Mysql读写分离1.读写分离原理2.读写分离方案3.读写分离存在的意义4.什么时候要读写分离四.Mysql主从复制和读写分离实验案例拓扑图：思... 查看详情

从理论到实战，彻底搞懂mysql主从复制原理(代码片段)

文章目录前言常见主从架构模式单向主从双向主从级联主从多主一从主从原理基于语句复制（STATEMENT）基于行复制（ROW）混合模式（MIXED）主从实战一主一从双向主从级联主从多主一从半同步复制实战GTID前... 查看详情

mysql主从复制及读写分离实际部署与验证(代码片段)

MySQL主从复制及读写分离前言：一、主从复制1.原理：2.准备来做主从复制和读写分离的服务器如下：3.主从复制具体步骤1.关闭所有服务器的防火墙2.Mysql主从服务器都进行时间同步3.主从服务器mysql配置4.从服务器的mysq... 查看详情

mysql主从复制以及读写分离（❤❤❤❤含理论和实验❤❤❤❤大家中秋快乐！㊗）(代码片段)

文章目录一、MySQL主从复制的理论部分1.1、主从复制与读写分离的概述1.2、mysql支持的复制类型1.3、主从复制的工作过程（主写从复制❤❤❤❤）1.4、MySOL主从复制延迟的原因二、MySQL读写分离的理论部分2.1、MySQL读写分离... 查看详情

mysql主从复制以及读写分离（❤❤❤❤含理论和实验❤❤❤❤大家中秋快乐！㊗）(代码片段)

文章目录一、MySQL主从复制的理论部分1.1、主从复制与读写分离的概述1.2、mysql支持的复制类型1.3、主从复制的工作过程（主写从复制❤❤❤❤）1.4、MySOL主从复制延迟的原因二、MySQL读写分离的理论部分2.1、MySQL读写分离... 查看详情

mysql的主从复制(代码片段)

MySQL的主从复制Whyweneed主从复制?复制功能复制方式复制原理复制流程图复制过程复制中线程的作用从节点主节点从节点需要建立二进制日志文件吗？Mysql复制特点主从复制配置过程主节点从节点配置演示主机修改my.ini配置文... 查看详情

mysql数据库--主从复制读写分离(代码片段)

文章目录一、主从复制1、原理2、二进制日志的保存方式3、主从复制策略4、搭建MySQL主从复制二、读写分离1、原理2、读写分离3、读写分离的好处4、实现方式4.1、Amoeba简介五、搭建MySQL读写分离1、实验准备2、amoeba(192.168.35.30)安... 查看详情