SpringBoot实现MySQL读写分离

在高并发下,需要对应用进行读写分离,配置多数据源,即写操作走主库,读操作则走从库,主从数据库负责各自的读和写,缓解了锁的争用,提高了读取性能。

实现读写分离有多种方式,如使用中间件MyCat、Sharding-JDBC等,这里我们使用Aop的方式在代码层面实现读写分离。


实现原理

实现读写分离,首先要对Mysql做主从复制,即搭建一个主数据库,以及一个或多个从数据库。

具体实现主从复制,可参照前一篇博客《基于docker配置MySQL主从复制》

使用Aop的方式,当调用业务层方法前,判断请求是否是只读操作,动态切换数据源,如果是只读操作,则切换从数据库的数据源,否则使用主数据库的数据源。


系统架构

这是我之前写的一个项目,项目就是使用了本文章介绍的读写分离方式,架构图大概如下:


代码实现

在application.yml配置MySQL
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    #主机
    master:
      username: root
      password: 123456
      url: jdbc:mysql://服务器ip:3306/letfit?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
      driver-class-name: com.mysql.cj.jdbc.Driver
    #从机
    slave:
      username: root
      password: 123456
      url: jdbc:mysql://服务器ip:3307/letfit?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
      driver-class-name: com.mysql.cj.jdbc.Driver
    #连接池
    druid:
      initialSize: 5
      minIdle: 5
      maxActive: 20
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 1 FROM DUAL
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: true
      filters: stat,wall
      maxPoolPreparedStatementPerConnectionSize: 20
      useGlobalDataSourceStat: true
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

创建 ReadOnly 注解

在业务层的方法上使用该注解,使用 ReadOnly 注解的方法只处理读操作,会切换到从机的数据源

package com.letfit.aop.annotation;

/**
 * 只读注解
 */
@Target({
   
   ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadOnly {
   
   
}

创建枚举类

定义两个枚举类型 MASTERslave分别代表数据库类型

package com.letfit.common;

/**
 * 数据库类型
 */
public enum DBTypeEnum {
   
   
    /**
     * 主数据库
     */
    MASTER,

    /**
     * 从数据库
     */
    SLAVE;
}

编写动态切换数据源的工具类
package com.letfit.util;

/**
 * 动态切换数据源工具类
 */
@Slf4j
public class DynamicDbUtil {
   
   

    /**
     * 用来存储代表数据源的对象
     */
    private static final ThreadLocal<DBTypeEnum> CONTEXT_HAND = new ThreadLocal<>();

    /**
     * 切换当前线程要使用的数据源
     * @param dbTypeEnum
     */
    public static void set(DBTypeEnum dbTypeEnum){
   
   
        CONTEXT_HAND.set(dbTypeEnum);
        log.info("切换数据源:{}", dbTypeEnum);
    }

    /**
     * 切换
### Spring Boot实现 MySQL 读写分离的解决方案 在现代应用系统中,随着业务的增长和用户量的增加,数据库的读写压力也随之增大。为了提高数据库的性能和吞吐量,读写分离成为了一种常用的解决方案。以下是基于 Spring BootMySQL读写分离实现方案。 #### 1. 数据源配置 在 `application.yml` 或 `application.properties` 文件中,需要配置两个数据源:一个用于主库(写操作),另一个用于从库(读操作)。以下是一个典型的配置示例: ```yaml spring: datasource: master: url: jdbc:mysql://localhost:3306/master_db?useSSL=false&serverTimezone=UTC username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver slave: url: jdbc:mysql://localhost:3306/slave_db?useSSL=false&serverTimezone=UTC username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver ``` 通过上述配置,可以分别定义主库和从库的数据源[^3]。 #### 2. 动态数据源切换 动态数据源切换是实现读写分离的核心部分。Spring Boot 提供了 `AbstractRoutingDataSource` 类,可以通过自定义逻辑实现数据源的动态切换。以下是实现步骤: - **创建自定义数据源类** 继承 `AbstractRoutingDataSource` 并重写 `determineCurrentLookupKey` 方法,用于决定当前使用哪个数据源。 ```java public class DynamicDataSource extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { return DataSourceContextHolder.getDataSourceType(); } } ``` - **定义数据源上下文** 创建一个线程安全的上下文工具类,用于存储当前线程的数据源类型。 ```java public class DataSourceContextHolder { private static final ThreadLocal<String> contextHolder = new ThreadLocal<>(); public static void setDataSourceType(String dataSourceType) { contextHolder.set(dataSourceType); } public static String getDataSourceType() { return contextHolder.get(); } public static void clearDataSourceType() { contextHolder.remove(); } } ``` - **配置数据源** 在 Spring 配置类中,将主库和从库注册到 `DynamicDataSource` 中,并设置默认数据源。 ```java @Configuration public class DataSourceConfig { @Bean public DataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource, @Qualifier("slaveDataSource") DataSource slaveDataSource) { Map<Object, Object> dataSourceMap = new HashMap<>(); dataSourceMap.put("master", masterDataSource); dataSourceMap.put("slave", slaveDataSource); DynamicDataSource dynamicDataSource = new DynamicDataSource(); dynamicDataSource.setTargetDataSources(dataSourceMap); dynamicDataSource.setDefaultTargetDataSource(masterDataSource); // 默认为主库 return dynamicDataSource; } @Bean @ConfigurationProperties(prefix = "spring.datasource.master") public DataSource masterDataSource() { return DataSourceBuilder.create().build(); } @Bean @ConfigurationProperties(prefix = "spring.datasource.slave") public DataSource slaveDataSource() { return DataSourceBuilder.create().build(); } } ``` #### 3. 数据源路由规则 根据业务需求,可以在代码中动态切换数据源。例如,在执行查询操作时切换到从库,而在执行插入、更新或删除操作时切换到主库。 ```java @Service public class UserService { @Autowired private UserMapper userMapper; public List<User> getAllUsers() { DataSourceContextHolder.setDataSourceType("slave"); // 切换到从库 try { return userMapper.selectAll(); } finally { DataSourceContextHolder.clearDataSourceType(); // 清除数据源 } } public void saveUser(User user) { DataSourceContextHolder.setDataSourceType("master"); // 切换到主库 try { userMapper.insert(user); } finally { DataSourceContextHolder.clearDataSourceType(); // 清除数据源 } } } ``` #### 4. 测试与验证 完成上述配置后,可以通过单元测试或集成测试验证读写分离的效果。确保查询操作正确地路由到从库,而写操作路由到主库。 --- ### 总结 通过以上步骤,可以实现 Spring Boot 环境下的 MySQL 读写分离。关键点在于配置多个数据源并通过 `AbstractRoutingDataSource` 实现动态切换。此外,还需要根据具体的业务场景设计合理的路由规则[^1]。
评论 24
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值