46 初始MyCat实现读写分离与动态数据源切换

作者: 滔滔逐浪 | 来源:发表于2020-08-21 08:20 被阅读0次

分表分库与分区的区别及拆分策略
46 初始MyCat实现读写分离与动态数据源切换
MyCat实现读写分离与动态数据源切换
Mycat 实现 MySQL 读写分离
Mycat 实现 MySQL 读写分离
Mycat笔记
myCat MyCat读写分离多主库配置切换
想要学会MyCat高可用集群搭建，但是这些知识点却还玩不明白？
你还在代码里做读写分离么，试试这个中间件吧！
Mysql读写分离

image.png

1，角色分清：
读的数据库权限：只可以做select
写的数据库操作： select/uodate/insert/create/delete
既然要实现分离，通过mycat路由不同的数据库进行访问：
mycat原理：会拦截用户端的所有jdbc进行根据sql语句判断转发到不同的数据库执行

mycat java语言开发类似与nginx
mycat 可以实现数据库反向代理隐藏真实的数据库ip地址。

image.png

基于MyCat实现读写分离
读写分离，简单地说是把对数据库的读和写操作分开，以对应不同的数据库服务器。主数据库提供写操作，从数据库提供读操作，这样能有效地减轻单台数据库的压力。主数据库进行写操作后，数据及时同步到所读的数据库，尽可能保证读、写数据库的数据一致，比如MySQL的主从复制、Oracle的data guard、SQL Server的复制订阅等。
Linux环境安装MyCat实现读写分离
1、上传安装Mycat-server-1.6.5-release-20180122220033-linux.tar
2、解压安装包tar –zxvf
3、配置schema.xml 和server.xml
4、客户端连接端口号: 8066
配置文件介绍:

image.png

Linux环境安装MyCat实现读写分离
1、进入bin目录
启动MyCat ./mycat start
停止MyCat ./mycat stop
2、查看/usr/local/mycat/logs wrapper.log日志如果是为successfully 则启动成功

关闭防火墙:systemctl stop firewalld.service
只可读的账号 user user 端口号8066
可读可写的账号 root root端口号8066

image.png

shema.xml配置


<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
    <!-- TESTDB1 是mycat的逻辑库名称，链接需要用的 -->
    <schema name="mycat_testdb" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1"></schema>
        <!-- database 是MySQL数据库的库名 -->
    <dataNode name="dn1" dataHost="localhost1" database="test" />
    <!--
    dataNode节点中各属性说明：
    name：指定逻辑数据节点名称；
    dataHost：指定逻辑数据节点物理主机节点名称；
    database：指定物理主机节点上。如果一个节点上有多个库，可使用表达式db$0-99，     表示指定0-99这100个数据库；

    dataHost 节点中各属性说明：
        name：物理主机节点名称；
        maxCon：指定物理主机服务最大支持1000个连接；
        minCon：指定物理主机服务最小保持10个连接；
        writeType：指定写入类型；
            0，只在writeHost节点写入；
            1，在所有节点都写入。慎重开启，多节点写入顺序为默认写入根据配置顺序，第一个挂掉切换另一个；
        dbType：指定数据库类型；
        dbDriver：指定数据库驱动；
        balance：指定物理主机服务的负载模式。
            0，不开启读写分离机制；
            1，全部的readHost与stand by writeHost参与select语句的负载均衡，简单的说，当双主双从模式(M1->S1，M2->S2，并且M1与 M2互为主备)，正常情况下，M2,S1,S2都参与select语句的负载均衡；
            2，所有的readHost与writeHost都参与select语句的负载均衡，也就是说，当系统的写操作压力不大的情况下，所有主机都可以承担负载均衡；
-->
    <dataHost name="localhost1" maxCon="1000" minCon="10" balance="3" writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
        <heartbeat>select user()</heartbeat>
        <!-- 可以配置多个主从 -->
        <writeHost host="hostM1" url="192.168.212.202:3306" user="root" password="root">
            <!-- 可以配置多个从库 -->
            <readHost host="hostS2" url="192.168.212.203:3306" user="root" password="root" />
        </writeHost>
    </dataHost>
</mycat:schema>

server.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<!-- - - Licensed under the Apache License, Version 2.0 (the "License"); 
    - you may not use this file except in compliance with the License. - You 
    may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 
    - - Unless required by applicable law or agreed to in writing, software - 
    distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT 
    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the 
    License for the specific language governing permissions and - limitations 
    under the License. -->
<!DOCTYPE mycat:server SYSTEM "server.dtd">
<mycat:server xmlns:mycat="http://io.mycat/">
   

   <!-- 读写都可用的用户 -->
    <user name="root" defaultAccount="true">
        <property name="password">123456</property>
        <property name="schemas">mycat_testdb</property>

        <!-- 表级 DML 权限设置 -->
        <!--        
        <privileges check="false">
            <schema name="TESTDB" dml="0110" >
                <table name="tb01" dml="0000"></table>
                <table name="tb02" dml="1111"></table>
            </schema>
        </privileges>       
         -->
    </user>

    <!-- 只读用户 -->
    <user name="user">
        <property name="password">user</property>
        <property name="schemas">mycat_testdb</property>
        <property name="readOnly">true</property>
    </user>

</mycat:server>

关闭防火墙:systemctl stop firewalld.service
只可读的账号 user user 端口号8066
可读可写的账号 root 123456 端口号8066

image.png

SpringBoot项目整合动态数据源(读写分离)

1.配置多个数据源，根据业务需求访问不同的数据，指定对应的策略：增加，删除，修改操作访问对应数据，查询访问对应数据，不同数据库做好的数据一致性的处理。由于此方法相对易懂，简单，不做过多介绍。

动态切换数据源，根据配置的文件，业务动态切换访问的数据库:此方案通过Spring的AOP，AspactJ来实现动态织入，通过编程继承实现Spring中的AbstractRoutingDataSource,来实现数据库访问的动态切换，不仅可以方便扩展，不影响现有程序，而且对于此功能的增删也比较容易。
通过mycat来实现读写分离:使用mycat提供的读写分离功能，mycat连接多个数据库，数据源只需要连接mycat，对于开发人员而言他还是连接了一个数据库(实际是mysql的mycat中间件)，而且也不需要根据不同业务来选择不同的库，这样就不会有多余的代码产生。
详细参考配置
动态数据源核心配置
在Spring 2.0.1中引入了AbstractRoutingDataSource, 该类充当了DataSource的路由中介, 能有在运行时, 根据某种key值来动态切换到真正的DataSource上。

1.项目中需要集成多个数据源分别为读和写的数据源，绑定不同的key。
2.采用AOP技术进行拦截业务逻辑层方法，判断方法的前缀是否需要写或者读的操作
3.如果方法的前缀是写的操作的时候，直接切换为写的数据源，反之切换为读的数据源
也可以自己定义注解进行封装

动态数据源项目整合

Maven依赖信息

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.taotao</groupId>
    <artifactId>dxfl</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>dxfl</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>


        <!-- mysql -->

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
            <scope>runtime</scope>
        </dependency>


        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.23</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-support</artifactId>
            <version>2.2.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

spring:
  datasource:
    ###可读数据源
    select:
      jdbc-url: jdbc:mysql://192.168.0.99:8066/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=true
      driver-class-name: com.mysql.jdbc.Driver
      username: user
      password: user
    ####可写数据源  
    update:
      jdbc-url: jdbc:mysql://192.168.0.99:8066/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=true
      driver-class-name: com.mysql.jdbc.Driver
      username: root
      password: 123456

logging:
  level:
    com.taotao.dxfl: debug

DataSourceContextHolder

package com.taotao.dxfl.config;

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

/**
 *@author tom
 *Date  2020/8/22 0022 10:09
 *
 */
@Component
@Lazy(false)
public class DataSourceContextHolder {
    // 采用ThreadLocal 保存本地多数据源
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    // 设置数据源类型
    public static void setDbType(String dbType) {
        contextHolder.set(dbType);
    }

    public static String getDbType() {
        return contextHolder.get();
    }

    public static void clearDbType() {
        contextHolder.remove();
    }

}

DataSourceConfig

package com.taotao.dxfl.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

/**
 *@author tom
 *Date  2020/8/22 0022 10:10
 *
 */
@Configuration
public class DataSourceConfig {

    // 创建可读数据源
    @Bean(name = "selectDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.select") // application.properteis中对应属性的前缀
    public DataSource dataSource1() {
        return DataSourceBuilder.create().build();
    }

    // 创建可写数据源
    @Bean(name = "updateDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.update") // application.properteis中对应属性的前缀
    public DataSource dataSource2() {
        return DataSourceBuilder.create().build();
    }

}

DynamicDataSource


package com.taotao.dxfl.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 *@author tom
 *Date  2020/8/22 0022 10:12
 *
 */
//在Spring 2.0.1中引入了AbstractRoutingDataSource, 该类充当了DataSource的路由中介, 能有在运行时, 根据某种key值来动态切换到真正的DataSource上。

@Component
@Primary
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Autowired
    @Qualifier("selectDataSource")
    private DataSource selectDataSource;

    @Autowired
    @Qualifier("updateDataSource")
    private DataSource updateDataSource;

    /**
     * 这个是主要的方法，返回的是生效的数据源名称
     */
    @Override
    protected Object determineCurrentLookupKey() {
        System.out.println("DataSourceContextHolder：：：" + DataSourceContextHolder.getDbType());
        return DataSourceContextHolder.getDbType();
    }

    /**
     * 配置数据源信息
     */
    @Override
    public void afterPropertiesSet() {
        Map<Object, Object> map = new HashMap<>();
        map.put("selectDataSource", selectDataSource);
        map.put("updateDataSource", updateDataSource);
        setTargetDataSources(map);
        setDefaultTargetDataSource(updateDataSource);
        super.afterPropertiesSet();
    }
}

SwitchDataSourceAOP

package com.taotao.dxfl.config;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.context.annotation.Lazy;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 *@author tom
 *Date  2020/8/22 0022 10:19
 *
 */
@Aspect
@Component
@Lazy(false)
@Order(0) // Order设定AOP执行顺序 使之在数据库事务上先执行
public class SwitchDataSourceAOP {
    // 这里切到你的方法目录
    @Before("execution(*  com.taotao.dxfl.controller.*.*(..))")
    public void process(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        if (methodName.startsWith("get") || methodName.startsWith("count") || methodName.startsWith("find")
                || methodName.startsWith("list") || methodName.startsWith("select") || methodName.startsWith("check")) {
            DataSourceContextHolder.setDbType("selectDataSource");
        } else {
            // 切换dataSource
            DataSourceContextHolder.setDbType("updateDataSource");
        }
    }
}

image.png

entity:

package com.taotao.dxfl.entity;

/**
 *@author tom
 *Date  2020/8/22 0022 10:26
 *
 */

import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableLogic;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.annotations.Version;
import com.baomidou.mybatisplus.enums.IdType;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.io.Serializable;
import java.time.LocalDateTime;

/**
 * <p>
 *
 * </p>
 *
 * @author jobob
 * @since 2020-06-09
 */
@TableName("meite_user")
@Data
@EqualsAndHashCode(callSuper = false)
public class MeiteUser implements Serializable {

    private static final long serialVersionUID = 1L;


    private Integer userId;

    private String userName;

    private Integer userAge;

    private String userAddres;

    private LocalDateTime createTime;

    /**
     * 逻辑删除
     * 0存在 1 隐藏
     */
    @TableLogic
    private Integer deleted = 0;
    // 版本
 /*   @Version
    private Integer version;*/

}

controller


package com.taotao.dxfl.controller;

import com.taotao.dxfl.entity.MeiteUser;
import com.taotao.dxfl.mapper.MeiteUserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 *@author tom
 *Date  2020/8/22 0022 10:28
 *
 */
@RestController
public class MtController {
    @Autowired
    private MeiteUserMapper meiteUserMapper;


    @RequestMapping("/find")
    public MeiteUser find(Integer userId){
        MeiteUser meiteUser = meiteUserMapper.select(userId);
        return meiteUser;
    }

    @GetMapping("/insertUser")
    public String insertUser(MeiteUser user) {
     meiteUserMapper.add(user);
        return "2";
    }
}

mapper:


package com.taotao.dxfl.mapper;



import com.taotao.dxfl.entity.MeiteUser;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;


/**
 *@author tom
 *Date  2020/8/22 0022 10:27
 *
 */

public interface MeiteUserMapper extends BaseMapper<MeiteUser> {
    @Select("select * from meite_user where user_id=27")
            MeiteUser select(Integer userId);



    @Insert("INSERT INTO `test`.`meite_user`( `user_name`, `user_age`, `user_addres`, `create_time`, `deleted`, `version`) VALUES ( '1', 19, '上海市', '2020-04-22 15:45:52', 1, 0);\n")
    void add(MeiteUser user);

}

结果：

image.png

https://www.cnblogs.com/joylee/p/7513038.html

分表分库与分区的区别及拆分策略
上一篇 <<
46 初始MyCat实现读写分离与动态数据源切换
基于MyCat实现读写分离读写分离，简单地说是把对数据库的读和写操作分开，以对应不同的数据库服务器。主数据库提供写...
MyCat实现读写分离与动态数据源切换
上一篇 <<
Mycat 实现 MySQL 读写分离
Mycat 实现 MySQL 读写分离目前MyCat配置Mysql 读写分离的文章虽然很多，但是看起来比较杂乱，...
Mycat 实现 MySQL 读写分离
Mycat 实现 MySQL 读写分离环境：CentOS 6.8 实验拓扑： mycat: 192.168.0....
Mycat笔记
Mycat关键特性：基于心跳的自动故障切换支持读写分离，支持Mysql主从基于NIO实现，有效管理线程，解决...
myCat MyCat读写分离多主库配置切换
起因：学完mysql，了解一下mycat，对数据相关知识进一步了解。 1. MyCat读写分离多主库配置切换读写...
想要学会MyCat高可用集群搭建，但是这些知识点却还玩不明白？
一、集群架构 1.MyCat实现读写分离架构在我前面的文章, 我已经讲解过了通过MyCat来实现MySQL的读写...
你还在代码里做读写分离么，试试这个中间件吧！
传统的MySql读写分离方案是通过在代码中根据SQL语句的类型动态切换数据源来实现的，那么有没有什么中间件可以自动...
Mysql读写分离
常见读写分离方式 MySQL-Proxy读写分离 Amoeba读写分离 Mycat读写分离基于程序读写分离 My...