MySQL 主从复制原理和使用

老九君

发布于 2022-09-06 13:40:57

3150

发布于 2022-09-06 13:40:57

文章被收录于专栏：老九学堂

实际生产的过程中为了实现数据库的高可用，不会只有一个数据库节点。至少会搭建主从复制的数据库架构，从库可以作为主库的数据备份。下面就进行从零开始搭建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、I/O线程接收到binlog日志后，会将binlog日志写入到本地的relaylog中。

5、最后，slave节点上的SQL线程会读取relaylog中的biinlog日志，将其解析成具体的增删改操作。

把这些在master节点上进行过的操作，重新在slave节点上也重做一遍，达到数据还原的效果。

【主从复制模式】

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

全同步复制

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

异步复制

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

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

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

半同步复制

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

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

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

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

1、半同步复制的性能，相比异步复制而言有所下降，因为需要等到等待至少一个从库确认接收到binlog日志的响应，所以新能上是有所损耗的。

2、主库等待从库响应的最大时长我们是可以配置的，如果超过了我们配置的事件，半同步复制就会变成异步复制，那么，异步复制的问题同样也就出现了。

3、在MySQL5.7.2之前的版本中，半同步复制存在幻读问题。当主库成功提交事务并处于等待从库确认的过程中，这个时候，从库都还没来得及返回处理结果给客户端，但因为主库存储引擎内部已经提交事务了，所以，其他客户端是可以到主库中读到数据的。

但是，如果下一秒主库宕机，下次请求过来只能读取从库，因为从库还没有从主库同步数据，所以从库中读取不到这条数据了，和上一次读取数据的结果相比，就造成了幻读的现象。

增强半同步复制

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

主库配置了参数后，主库在存储引擎提交事务前，必须先收到从库数据同步完成的确认信息后才能提交事务，就解决幻读问题。

【主从同步实战】

准备数据源

config/datasource.properties

# mastersspring.datasource.masters.driver-class-name=com.mysql.cj.jdbc.Driverspring.datasource.masters.url=jdbc:mysql://192.168.1.111:3306/monomer_order?useUnicode=true&characterEncoding=utf8&useSSL=false&autoReconnect=true&zeroDateTimeBehavior=convertToNullspring.datasource.masters.username=rootspring.datasource.masters.password=123456
# slavesspring.datasource.slaves[0].driver-class-name=com.mysql.cj.jdbc.Driverspring.datasource.slaves[0].url=jdbc:mysql://192.168.1.112:3306/monomer_order?useUnicode=true&characterEncoding=utf8&useSSL=false&autoReconnect=true&zeroDateTimeBehavior=convertToNullspring.datasource.slaves[0].username=rootspring.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;
@Slf4jpublic 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;
@Slf4jpublic 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@Componentpublic 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;    }}