SpringBoot项目中如何实现MySQL读写分离

在现代Web应用中，数据库的读写分离是一种常见的优化策略，尤其是在高并发场景下。通过将读操作和写操作分配到不同的数据库实例上，可以有效减轻主数据库的负载，提高系统的整体性能和可用性。本文将介绍如何在SpringBoot项目中实现MySQL的读写分离。

1. 读写分离的基本概念

读写分离的核心思想是将数据库的读操作和写操作分别分配到不同的数据库实例上。通常情况下，写操作（如INSERT、UPDATE、DELETE）会集中在主库（Master）上执行，而读操作（如SELECT）则会分散到多个从库（Slave）上执行。这样可以有效减轻主库的负载，提高系统的并发处理能力。

2. 实现读写分离的步骤

在SpringBoot项目中实现MySQL的读写分离，通常需要以下几个步骤：

2.1 配置主从数据库

首先，需要在MySQL中配置主从复制。主库负责处理写操作，从库负责处理读操作。主从复制的配置可以参考MySQL官方文档。

2.2 配置SpringBoot数据源

在SpringBoot项目中，我们需要配置多个数据源，分别对应主库和从库。可以使用AbstractRoutingDataSource来实现动态数据源切换。

2.2.1 配置主库和从库的数据源

spring:
  datasource:
    master:
      url: jdbc:mysql://master-host:3306/db_name
      username: root
      password: master_password
      driver-class-name: com.mysql.cj.jdbc.Driver
    slave:
      url: jdbc:mysql://slave-host:3306/db_name
      username: root
      password: slave_password
      driver-class-name: com.mysql.cj.jdbc.Driver

2.2.2 创建数据源配置类

@Configuration
public class DataSourceConfig {

    @Bean(name = "masterDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "slaveDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean(name = "dynamicDataSource")
    public DataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                        @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DbContextHolder.DB_MASTER, masterDataSource);
        targetDataSources.put(DbContextHolder.DB_SLAVE, slaveDataSource);

        AbstractRoutingDataSource dynamicDataSource = new AbstractRoutingDataSource() {
            @Override
            protected Object determineCurrentLookupKey() {
                return DbContextHolder.getDbType();
            }
        };
        dynamicDataSource.setDefaultTargetDataSource(masterDataSource);
        dynamicDataSource.setTargetDataSources(targetDataSources);
        return dynamicDataSource;
    }
}

2.3 实现数据源切换

为了实现动态数据源切换，我们需要一个上下文持有类来保存当前线程的数据源类型。

public class DbContextHolder {

    public static final String DB_MASTER = "master";
    public static final String DB_SLAVE = "slave";

    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();
    }
}

2.4 使用AOP实现数据源切换

我们可以使用Spring AOP来在方法执行前切换数据源。通过自定义注解来标记哪些方法使用主库，哪些方法使用从库。

2.4.1 自定义注解

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadOnly {
}

2.4.2 AOP切面

@Aspect
@Component
public class DataSourceAspect {

    @Before("@annotation(readOnly)")
    public void setReadOnlyDataSource(ReadOnly readOnly) {
        DbContextHolder.setDbType(DbContextHolder.DB_SLAVE);
    }

    @Before("execution(* com.example.service..*.insert*(..)) || " +
            "execution(* com.example.service..*.update*(..)) || " +
            "execution(* com.example.service..*.delete*(..))")
    public void setWriteDataSource() {
        DbContextHolder.setDbType(DbContextHolder.DB_MASTER);
    }

    @After("execution(* com.example.service..*.*(..))")
    public void clearDataSource() {
        DbContextHolder.clearDbType();
    }
}

2.5 配置事务管理

由于我们使用了动态数据源，因此需要配置事务管理器来确保事务的正确性。

@Configuration
@EnableTransactionManagement
public class TransactionManagerConfig {

    @Bean
    public PlatformTransactionManager transactionManager(@Qualifier("dynamicDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

3. 测试读写分离

在完成上述配置后，可以通过编写测试用例来验证读写分离是否生效。例如，在Service层中，使用@ReadOnly注解标记只读方法，确保这些方法会从从库中读取数据。

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @ReadOnly
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    public void updateUser(User user) {
        userMapper.updateById(user);
    }
}

4. 总结

通过以上步骤，我们可以在SpringBoot项目中实现MySQL的读写分离。这种架构可以有效提升系统的并发处理能力，减轻主库的负载。当然，读写分离的实现还需要根据具体的业务场景进行调整和优化，例如增加更多的从库、实现负载均衡等。希望本文能为你提供一些参考和帮助。