springboot多数据源配合docker部署mysql主从实现读写分离效果

目录
  • 一、使用docker部署mysql主从 实现主从复制
  • 二、springboot项目多数据源配置,实现读写分离

一、使用docker部署mysql主从 实现主从复制

此次使用的是windows版本docker,mysql版本是5.7

1、使用docker获取mysql镜像

docker pull mysql:5.7.23 #拉取镜像文件

docker images #查看镜像文件

2、使用docker运行mysql master

docker run --name mysql-master --privileged=true -v F:\dockerV\mysql:/var/lib/mysql -p 3307:3306 -e MYSQL_ROOT_PASSWORD=654321 -d mysql:5.7.23
  • --name 容器名称mysql-master
  • --privileged 指定了当前容器是否真正的具有root权限,所谓的root权限是指具有宿主机的root权限,而不仅仅只是在容器内部有root权限
  • -v 将系统的F:\dockerV\mysql挂载到容器的/var/lib/mysql,注意是将宿主机 挂载到 容器内部,而不是将容器内部挂载到宿主机
  • -p 表示宿主机上的某个端口映射到docker容器内的某个端口,这里也就是将宿主机的3307端口映射到容器内部的3306端口
  • -e 表示指定当前容器运行的环境变量,该变量一般在容器内部程序的配置文件中使用,而在外部运行容器指定该参数。这里的MYSQL_ROOT_PASSWORD表示容器内部的MySQL的启动密码
  • -d 后台运行,镜像文件为mysql:5.7.23

接下来进入容器内部,修改配置,使其作为mysql master运行

docker exec -it mysql-master bash #进入容器内部

配置mysql master,修改mysql.cnf

使用vim修改mysql.cnf,没有安装vim会提示bash: vi: command not found 则需要安装vim

apt-get install vim

apt-get update

apt-get install vim

vim mysqld.cnf #修改cnf文件,添加 server-id 表示master服务标识,同一局域网内注意要唯一 和 log-bin=mysql-bin 开启二进制日志功能,可以随便取,用来完成主从复制

修改完成mysql的配置后,需要重启服务生效

service MySQL restart # 重启mysql服务时会使得docker容器停止,我们还需要docker start mysql-master启动容器

docker start mysql-master #启动容器

连接mysql客户端,创建用来完成主从复制的账号

mysql -uroot -p654321 #连接mysql

为从服务器创建一个可以用来操作master服务器的账户,也就是创建一个专门用来复制binlog的账号,并且赋予该账号复制权限,其命令如下

grant replication slave on *.* to 'slaveaccount'@'%' identified by '654321'; #账号slaveaccount 密码654321

flush privileges; #刷新用户权限表

show master status #查看mysql master的状态

记录下上的position和file 在创建MySQL slave配置时会用到

到这里mysql master 已经配置完成了

3、使用docker运行mysql slave

docker run --name mysql-slave --privileged=true -v F:\dockerV\mysql-slave:/var/lib/mysql -p 3308:3306 --link mysql-master:master -e MYSQL_ROOT_PASSWORD=654321 -d mysql:5.7.23

mysql slave 的参数主要和master有两点不同

  • 所映射的宿主机的端口号不能与master容器相同,因为其已经被master容器占用;
  • 必须加上--link参数,其后指定了当前容器所要连接的容器,mysql-master表示所要连接的容器的名称,master表示为该容器起的一个别名,通俗来讲,就是slave容器通过这两个名称都可以访问到master容器。这么做的原因在于,如果master与slave不在同一个docker network中,那么这两个容器相互之间是没法访问的。
docker exec -it mysql-slave /bin/bash #进入mysql salve容器

vim mysqld.cnf #修改cnf文件,添加 server-id 表示slave服务标识,如果此salve需要作为其他mysql的主,那么就需要配置log-bin=mysql-bin

service MySQL restart # 重启mysql服务时会使得docker容器停止,我们还需要docker start mysql-slave启动容器

docker start mysql-master #启动容器

mysql -uroot -proot #连接mysql服务

配置mysql slave 使其以slave模式运行

change master to master_host='172.17.0.2', master_user='slaveaccount', master_password='654321', master_port=3306, master_log_file='mysql-bin.000001', master_log_pos=2272, master_connect_retry=30;

注意:这一步主要在slave是配置master的信息,包括 master的 地址、端口、账号、密码、log文件、log文件偏移量、重试。下面介绍这些参数值从何获取

获取master_host,使用docker inspect mysql-master查看master容器元数据。其中 IPAdress是master_host

  • 获取master_port,是运行master映射容器内部的端口,这里就是3306
  • 获取master_user和master_password,是第一步中在master中创建的slave账号
  • 获取master_log_file和master_log_pos,是配置master中最后一步使用show master status获取的文件和偏移量
  • 获取master_connect_retry,是slave重试连接master动作前的休眠时间,单位s,默认60s
start slave; #以slave模式运行

show salve status \G; #查看slave的状态

可以看到,Slave_IO_Running:YES和Slave_SQL_Running:YES 证明此时主从复制已经就绪,slave配置到此完成

4、验证主从复制效果

  • 这里我们在连接master,并创建一张表,添加数据,在从库查看数据是否同步。
  • 在主库创建数据,并在从库查看数据是否同步成功。
mysql> create database test;
Query OK, 1 row affected (0.01 sec)

mysql> use test;
Database changed

mysql> create table t_user(id bigint, name varchar(255));
Query OK, 0 rows affected (0.02 sec)

mysql> insert into t_user(id, name) value (1, 'cgg');
Query OK, 1 row affected (0.01 sec)
mysql> select * from test.t_user;
+------+------+
| id   | name |
+------+------+
|    1 | cgg |
+------+------+
1 row in set (0.00 sec)

5、mysql主从复制原理

  • 主库db的更新事件(update、insert、delete)被写到binlog
  • 主库创建一个binlog dump thread,把binlog的内容发送到从库
  • 从库启动并发起连接,连接到主库
  • 从库启动之后,创建一个I/O线程,读取主库传过来的binlog内容并写入到relay log
  • 从库启动之后,创建一个SQL线程,从relay log里面读取内容,从Exec_Master_Log_Pos位置开始执行读取到的更新事件,将更新内容写入到slave的db

二、springboot项目多数据源配置,实现读写分离

1、主从多数据源配置

yml配置

server:
  port: 8888
  servlet:
    encoding:
      charset: UTF-8
      force: true
      enabled: true
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://127.0.0.1:3307/test?serverTimezone=GMT%2B8&characterEncoding=utf-8&autoReconnect=true&failOverReadOnly=false&useSSL=false
    username: root
    password: 654321
slave:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://127.0.0.1:3308/test?serverTimezone=GMT%2B8&characterEncoding=utf-8&autoReconnect=true&failOverReadOnly=false&useSSL=false
    username: root
    password: 654321

数据源配置

/**
 * @author cgg
 **/
@Configuration
@EnableTransactionManagement
public class DynamicDataSourceConfig {

    @Bean(name = "slaveDatasource")
    @ConfigurationProperties(prefix = "slave.datasource")
    public DataSource dbSlave() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = "dataSource")
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dbMaster() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public DataSource multipleDataSource(@Qualifier("dataSource") DataSource db,
                                         @Qualifier("slaveDatasource") DataSource slaveDatasource) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>(16);
        targetDataSources.put("dataSource", db);
        targetDataSources.put("slaveDatasource", slaveDatasource);
        dynamicDataSource.setTargetDataSources(targetDataSources);
        //设置默认数据源为从库,如果写操作业务多,可以默认设置为主库
        dynamicDataSource.setDefaultTargetDataSource(slaveDatasource);
        return dynamicDataSource;
    }

    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(multipleDataSource(dbSlave(), dbMaster()));
        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setJdbcTypeForNull(JdbcType.NULL);
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(false);
        sqlSessionFactory.setConfiguration(configuration);
        sqlSessionFactory.setMapperLocations((new PathMatchingResourcePatternResolver()).getResources(DEFAULT_MAPPER_LOCATION));
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        paginationInterceptor.setOverflow(false);
        paginationInterceptor.setLimit(-1);
        paginationInterceptor.setCountSqlParser(tenantSqlParserCountOptimize());
        Interceptor[] plugins = new Interceptor[]{new ShardTableInterceptor(), paginationInterceptor};
        sqlSessionFactory.setPlugins(plugins);
        return sqlSessionFactory.getObject();
    }

}

/**
 * 动态数据源
 *
 * @author cgg
 **/
@Slf4j
public class DynamicDataSource  extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DbContextHolder.getDbType();
    }
}

2、配置切面控制主从数据源切换、读从库写主库,实现读写分离

aop切面

/**
 * @author cgg
 **/
@Component
@Order(value = -100)
@Slf4j
@Aspect
public class DataSourceSwitchAspect {

    //master 包下的操作都是操作主库业务
    @Pointcut("execution(* com.master..*.*(..))")
    private void db1Aspect() {
    }

    //slave 包下的操作都是操作从库业务
    @Pointcut("execution(* com.slave.*.*(..))")
    private void db2Aspect() {
    }

    @Before("db1Aspect()")
    public void dbMaster() {
        log.debug("切换到Master 数据源...");
        DbContextHolder.setDbType("dataSource");
    }

    @Before("db2Aspect()")
    public void dbSlave() {
        log.debug("切换到Slave 数据源...");
        DbContextHolder.setDbType("slaveDatasource");
    }
}

/**
 * @author cgg
 **/
public class DbContextHolder {
    private static final ThreadLocal contextHolder = new ThreadLocal<>();
    /**
     * 设置数据源
     * @param dbType
     */
    public static void setDbType(String dbType) {
        contextHolder.set(dbType);
    }

    /**
     * 取得当前数据源
     * @return
     */
    public static String getDbType() {
        return (String) contextHolder.get();
    }

    /**
     * 清除上下文数据
     */
    public static void clearDbType() {
        contextHolder.remove();
    }
}

3、验证读写分离效果

使用接口调用不同接口,切点会自动切换数据源,这里写库接口只会操作主库,读库接口会操作从库。实现读写分离

到此这篇关于springboot多数据源配合docker部署mysql主从实现读写分离的文章就介绍到这了,更多相关springboot读写分离内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • springboot redis使用lettuce配置多数据源的实现

    目前项目上需要连接两个redis数据源,一个redis数据源是单机模式,一个redis数据源是分片集群模式,这里将具体配置列一下. 项目用的springboot版本为 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.1.RELEASE</ver

  • Springboot mybatis plus druid多数据源解决方案 dynamic-datasource的使用详解

    依赖 <dependency> <groupId>com.baomidou</groupId> <artifactId>dynamic-datasource-spring-boot-starter</artifactId> <version>2.5.0</version> </dependency> <dependency> <groupId>p6spy</groupId>

  • SpringBoot自定义注解使用读写分离Mysql数据库的实例教程

    需求场景 为了防止代码中有的SQL慢查询,影响我们线上主数据库的性能.我们需要将sql查询操作切换到从库中进行.为了使用方便,将自定义注解的形式使用. mysql导入的依赖 <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.16</version> </dependency&

  • Springboot + Mysql8实现读写分离功能

    在实际的生产环境中,为了确保数据库的稳定性,我们一般会给数据库配置双机热备机制,这样在master数据库崩溃后,slave数据库可以立即切换成主数据库,通过主从复制的方式将数据从主库同步至从库,在业务代码中编写代码实现读写分离(让主数据库处理 事务性增.改.删操作,而从数据库处理查询操作)来提升数据库的并发负载能力. 下面我们使用最新版本的Mysql数据库(8.0.16)结合SpringBoot实现这一完整步骤(一主一从). 安装配置mysql 从 https://dev.mysql.com/d

  • 使用springboot aop来实现读写分离和事物配置

    什么事读写分离 读写分离,基本的原理是让主数据库处理事务性增.改.删操作(INSERT.UPDATE.DELETE),而从数据库处理SELECT查询操作.数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库. 为什么要实现读写分离 增加冗余 增加了机器的处理能力 对于读操作为主的应用,使用读写分离是最好的场景,因为可以确保写的服务器压力更小,而读又可以接受点时间上的延迟. 实现 本文介绍利用spring aop来动态切换数据源来实现读写分离. 先建一个maven项目,导入springBo

  • SpringBoot+docker环境变量配置详解

    项目中遇到springBoot+docker需要配置不同环境变量的问题,做个简单的总结: 1.开发环境ide中启动项目 可以通过ide的环境变量参数配置,启动之后使用哪个配置,比如 这样就使用application-test.yml中的配置 2.通过gradle打包 可以通过-P参数来指定打包后的jar使用哪种环境来运行,比如 gradlew -Pprod bootWar 打包之后运行会使用prod中的配置:我的项目是jhipster生成出来的,现在需要添加test的环境配置,需求修改下项目的g

  • SpringBoot+Mybatis-Plus实现mysql读写分离方案的示例代码

    1. 引入mybatis-plus相关包,pom.xml文件 2. 配置文件application.property增加多库配置 mysql 数据源配置 spring.datasource.primary.jdbc-url=jdbc:mysql://xx.xx.xx.xx:3306/portal?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=

  • SpringBoot整合MyCat实现读写分离的方法

    MyCat一个彻底开源的,面向企业应用开发的大数据库集群.基于阿里开源的Cobar产品而研发.能满足数据库数据大量存储:提高了查询性能.文章介绍如何实现MyCat连接MySQL实现主从分离,并集成SpringBoot实现读写分离. MySQL配置主从关系 说明 192.168.0.105 Linux 数据库作为主master数据库 127.0.0.1 Window 作为从slave数据库 master主数据库配置 binlog是Mysql sever层维护的一种二进制日志,主要是用来记录对Mys

  • springboot多数据源配合docker部署mysql主从实现读写分离效果

    目录 一.使用docker部署mysql主从 实现主从复制 二.springboot项目多数据源配置,实现读写分离 一.使用docker部署mysql主从 实现主从复制 此次使用的是windows版本docker,mysql版本是5.7 1.使用docker获取mysql镜像 docker pull mysql:5.7.23 #拉取镜像文件 docker images #查看镜像文件 2.使用docker运行mysql master docker run --name mysql-master

  • Django搭建MySQL主从实现读写分离

    目录 一.MySQL主从搭建 操作步骤 二.Django实现读写分离 自动指定 一.MySQL主从搭建 主从配置原理: 主库写日志到 BinLog 从库开个 IO 线程读取主库的 BinLog 日志,并写入 RelayLog 再开一个 SQL 线程,读 RelayLog 日志,回放到从库中 主从配置流程: master 会将变动记录到二进制日志里面: master 有一个 I/O 线程将二进制日志发送到 slave: salve 有一个 I/O 线程把 master 发送的二进制写入到 rela

  • Docker部署Mysql集群的实现

    单节点数据库的弊病 大型互联网程序用户群体庞大,所以架构必须要特殊设计 单节点的数据库无法满足性能上的要求 单节点的数据库没有冗余设计,无法满足高可用 单节点MySQL的性能瓶领颈 2016年春节微信红包巨大业务量,数据库承受巨大负载 常见MySQL集群方案 mysql 集群方案介绍,建议使用pxc,因为弱一致性会有问题,比如说a节点数据库显示我购买成功,b 节点数据库显示没有成功,这就麻烦了,pxc 方案是在全部节点都写入成功之后才会告诉你成功,是可读可写双向同步的,但是replication

  • Docker部署mysql一主一从的操作方法

    下载镜像 选择MySQL镜像 docker search mysql 下载MySQL5.7镜像 docker pull mysql:5.7 查看mysql镜像 docker images 搭建MySQL主从 master docker run --name mysql-master -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7 slave docker run --name mysql-slave -p 3308:3306 -e

  • Docker部署Mysql,.Net6,Sqlserver等容器

    Centos8安装Docker 1.更新一下yum [root@VM-24-9-centos ~]# yum -y update 2.安装containerd.io # centos8默认使用podman代替docker,所以需要containerd.io [root@VM-24-9-centos ~]# yum install https://download.docker.com/linux/fedora/30/x86_64/stable/Packages/containerd.io-1.2

  • 详解使用Docker部署MySQL(数据持久化)

    本文简述如何使用Docker部署mysql,同时持久化数据.我们会用到tutum-docker-mysql 这个项目来搭建一个mysql,省去重头写Dockerfile的时间. 首先我们将tutum-docker-mysql跑起来. docker run -d -p 3306:3306 --name mysql tutum/mysql 如果你本地没有tutum/mysql的image,docker会先下载它的image,这一步可能会用些时间.待执行完毕我们检查一下应该会有如下样子 tutum-d

  • centos6使用docker部署redis主从数据库操作示例

    本文实例讲述了centos6使用docker部署redis主从数据库操作.分享给大家供大家参考,具体如下: 目录结构: /redis /Dockerfile /Readme /redis-3.2.8.tar.gz /start.sh Dockerfile: FROM centos MAINTAINER qiongtao.li hnatao@126.com ADD ./redis-3.2.8.tar.gz /opt ADD ./start.sh /opt/start_redis.sh RUN ec

  • 详解用Docker构建MySQL主从环境

    前言 本篇文章记录我使用 docker-compose 以及 dockerfile 来构建基于 binlog 的 MySQL 主从环境.如果你严格按照文中的步骤进行配置,相信很快就可以搭建好一个基础的 MySQL 主从环境. 介绍 MySQL 主从同步分为 3 个步骤: master 节点将数据的更新记录写到 binary log 中. slave 节点开启 IO 线程连接 master 节点,请求获取指定 binary log 文件的指定位置之后的日志. master 节点的 binary l

  • Docker 部署Mysql 服务和Redis 服务的方法

    Docker 部署Mysql 服务的方法 1. 拉取Mysql 5.6最新版本镜像 sudo docker pull mysql:5.6 2. 查看Mysql 镜像 sudo docker images 3. 在home目录下创建需要映射的目录: mkdir -p /home/computer/project/mysql/{conf,log,data} 4. 运行容器 duso docker run -p 53603:3306 --name iot-mysql \ -v /home/comput

  • Docker部署mysql远程连接 解决2003的问题

    连接MySQL 这里我使用navicat远程连接,连接MySQL前需要防火墙开放端口或者关闭防火墙. 开放端口 firewall-cmd --add-port=3306/tcp --permanent // --permanent 永久生效,没有此参数重启后失效 firewall-cmd --reload // 重新载入 关闭防火墙 systemctl stop firewalld systemctl enable iptables // 设置开机启动 firewall-cmd --reload

随机推荐