SpringBoot怎么实现读写分离

在现代的Web应用中，数据库的读写分离是一种常见的优化手段。通过将读操作和写操作分配到不同的数据库实例上，可以有效减轻主数据库的压力，提高系统的整体性能和可用性。本文将介绍如何在SpringBoot项目中实现读写分离。

1. 读写分离的基本概念

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

2. SpringBoot实现读写分离的步骤

在SpringBoot中，我们可以通过配置多个数据源，并结合AOP（面向切面编程）来实现读写分离。以下是具体的实现步骤：

2.1 配置多数据源

首先，我们需要在application.yml或application.properties中配置主从数据库的连接信息。假设我们有一个主数据库和一个从数据库，配置如下：

spring:
  datasource:
    master:
      url: jdbc:mysql://localhost:3306/master_db
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
    slave:
      url: jdbc:mysql://localhost:3306/slave_db
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver

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("master", masterDataSource);
        targetDataSources.put("slave", slaveDataSource);

        AbstractRoutingDataSource routingDataSource = new AbstractRoutingDataSource() {
            @Override
            protected Object determineCurrentLookupKey() {
                return DataSourceContextHolder.getDataSourceType();
            }
        };
        routingDataSource.setDefaultTargetDataSource(masterDataSource);
        routingDataSource.setTargetDataSources(targetDataSources);
        return routingDataSource;
    }
}

2.3 创建数据源上下文持有类

为了在运行时动态切换数据源，我们需要创建一个上下文持有类，用于存储当前线程所使用的数据源类型。

public class DataSourceContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSourceType(String type) {
        contextHolder.set(type);
    }

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

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

2.4 创建AOP切面

通过AOP切面，我们可以在方法执行前根据方法类型（读或写）动态切换数据源。

@Aspect
@Component
public class DataSourceAspect {

    @Before("@annotation(com.example.demo.annotation.Master)")
    public void setMasterDataSource() {
        DataSourceContextHolder.setDataSourceType("master");
    }

    @Before("@annotation(com.example.demo.annotation.Slave)")
    public void setSlaveDataSource() {
        DataSourceContextHolder.setDataSourceType("slave");
    }

    @After("@annotation(com.example.demo.annotation.Master) || @annotation(com.example.demo.annotation.Slave)")
    public void clearDataSource() {
        DataSourceContextHolder.clearDataSourceType();
    }
}

2.5 创建自定义注解

为了在方法上标记使用主库还是从库，我们可以创建两个自定义注解。

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

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

2.6 在Service层使用注解

最后，在Service层的方法上使用自定义注解来指定数据源。

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Master
    public void addUser(User user) {
        userMapper.insert(user);
    }

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

3. 总结

通过以上步骤，我们可以在SpringBoot项目中实现读写分离。通过配置多数据源、使用AOP切面动态切换数据源，并结合自定义注解，我们可以轻松地将读操作和写操作分配到不同的数据库实例上，从而提升系统的性能和可用性。

需要注意的是，读写分离虽然可以提升系统的性能，但也带来了一些复杂性，如数据一致性问题。在实际应用中，我们需要根据业务需求和数据一致性要求来合理设计读写分离策略。