为什么需要读写分离？

在理解如何实现之前，我们首先要明白为什么需要它，核心原因是为了解决数据库的性能瓶颈和高可用性问题。

1. 缓解读压力：在大多数应用中，读操作（SELECT）的数量远大于写操作（INSERT, UPDATE, DELETE），大量的读请求会消耗数据库服务器大量的 CPU 和 I/O 资源,成为整个系统的瓶颈。
2. 提升系统吞吐量：通过将读请求分发到多个从库，可以并行处理,从而大幅提升系统的整体读吞吐量。
3. 高可用性：可以配置一个或多个从库作为备份，当主库发生故障时，可以快速切换一个从库作为新的主库,保证服务的连续性。
4. 数据备份：从库可以专门用于数据备份,避免备份操作影响主库的性能。

基本架构图：

+----------------+      +----------------+      +----------------+
|    Java App    |----->|    Master      |----->|   Replication  |
| (Read/Write)   |      | (Write Only)   |      |    to Slaves   |
+----------------+      +----------------+      +----------------+
        ^                       |                       |
        |                       |                       |
        |                       v                       v
        |               +----------------+      +----------------+
        +---------------|    Slave 1     |<-----+----------------+
                        | (Read Only)    |      |      ...       |
                        +----------------+      +----------------+
                                |
                                v
                        +----------------+
                        |    Slave 2     |
                        | (Read Only)    |
                        +----------------+

实现读写分离的核心方案

在 Java 应用中实现读写分离，主要有以下几种方案,它们各有优缺点：

核心组件：动态数据源路由

无论采用哪种方案，其核心思想都是 动态数据源路由，也就是说，系统需要根据当前执行的 SQL 语句是读还是写，来动态选择一个合适的数据源（主库或从库）。

这通常包含以下几个关键部分：

1. 数据源上下文：一个线程安全的工具类（通常使用 ThreadLocal），用于在当前线程中保存当前使用的数据源标识（如 master 或 slave）。
2. 动态数据源：一个实现了 javax.sql.DataSource 接口的类，它不直接创建连接，而是根据 ThreadLocal 中的标识，去从一个真实的数据源池（如 HikariCP）中获取对应的 Connection。
3. 路由切面：使用 Spring AOP，在执行 DAO 或 Service 层方法之前，拦截 SQL 语句或方法注解，判断是读操作还是写操作，然后调用数据源上下文工具类,设置对应的数据源标识。

实践示例：基于 AOP + 自定义 DataSource 的方案

这是一个非常经典且易于理解的实现方式,能让你深入理解读写分离的原理。

项目依赖

<!-- Spring Boot Starter -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Boot Starter AOP -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- MyBatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>
<!-- JDBC Driver & Connection Pool -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
</dependency>

配置文件 (application.yml)

配置主库和多个从库的信息。

spring:
  datasource:
    # 主库配置
    master:
      jdbc-url: jdbc:mysql://master-host:3306/mydb?useSSL=false&serverTimezone=UTC
      username: root
      password: password
      driver-class-name: com.mysql.cj.jdbc.Driver
      hikari:
        maximum-pool-size: 20
    # 从库配置 (可以配置多个)
    slave1:
      jdbc-url: jdbc:mysql://slave1-host:3306/mydb?useSSL=false&serverTimezone=UTC
      username: root
      password: password
      driver-class-name: com.mysql.cj.jdbc.Driver
      hikari:
        maximum-pool-size: 20
    slave2:
      jdbc-url: jdbc:mysql://slave2-host:3306/mydb?useSSL=false&serverTimezone=UTC
      username: root
      password: password
      driver-class-name: com.mysql.cj.jdbc.Driver
      hikari:
        maximum-pool-size: 20

核心代码实现

创建数据源枚举和上下文

public enum DataSourceType {
    MASTER, SLAVE
}
public class DataSourceContextHolder {
    // 使用 ThreadLocal 保证线程安全
    private static final ThreadLocal<DataSourceType> contextHolder = new ThreadLocal<>();
    public static void setDataSourceType(DataSourceType type) {
        contextHolder.set(type);
    }
    public static DataSourceType getDataSourceType() {
        return contextHolder.get() != null ? contextHolder.get() : DataSourceType.MASTER; // 默认主库
    }
    public static void clearDataSourceType() {
        contextHolder.remove();
    }
}

创建动态数据源

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        // 从 ThreadLocal 中获取数据源类型
        return DataSourceContextHolder.getDataSourceType();
    }
}

配置数据源并注入到 Spring

创建一个配置类，将主库和从库的 DataSource 实例化，并设置到 DynamicDataSource 中。

@Configuration
public class DataSourceConfig {
    @Bean
    @ConfigurationProperties("spring.datasource.master")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
    @Bean
    @ConfigurationProperties("spring.datasource.slave1")
    public DataSource slave1DataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
    @Bean
    @ConfigurationProperties("spring.datasource.slave2")
    public DataSource slave2DataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
    @Bean
    public DataSource dynamicDataSource() {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MASTER, masterDataSource());
        targetDataSources.put(DataSourceType.SLAVE1, slave1DataSource());
        targetDataSources.put(DataSourceType.SLAVE2, slave2DataSource());
        DynamicDataSource dataSource = new DynamicDataSource();
        dataSource.setDefaultTargetDataSource(masterDataSource()); // 默认主库
        dataSource.setTargetDataSources(targetDataSources);
        return dataSource;
    }
}

创建 AOP 切面进行路由

@Aspect
@Component
@Order(-1) // 保证在事务切面之前执行
public class DataSourceAspect {
    // 定义切入点，比如所有在 com.example.demo.mapper 包下的方法
    @Pointcut("execution(* com.example.demo.mapper..*.*(..))")
    public void dsPointCut() {}
    @Before("dsPointCut()")
    public void beforeSwitchDS(JoinPoint point) {
        // 获取到当前执行的方法
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        // 如果方法上有 @Master 注解，则切换到主库
        if (method.getAnnotation(Master.class) != null) {
            DataSourceContextHolder.setDataSourceType(DataSourceType.MASTER);
            return;
        }
        // 如果方法上有 @Slave 注解，则切换到从库
        if (method.getAnnotation(Slave.class) != null) {
            DataSourceContextHolder.setDataSourceType(DataSourceType.SLAVE1); // 简单起见，固定使用 slave1
            // 在实际项目中，可以实现一个负载均衡算法，如轮询
            return;
        }
        // 默认使用主库
        DataSourceContextHolder.setDataSourceType(DataSourceType.MASTER);
    }
    @After("dsPointCut()")
    public void afterSwitchDS() {
        // 方法执行完毕后，清理 ThreadLocal
        DataSourceContextHolder.clearDataSourceType();
    }
}

创建自定义注解

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

在 Mapper 接口上使用注解

@Mapper
public interface UserMapper {
    @Master // 强制使用主库
    int insert(User user);
    @Slave // 强制使用从库
    User selectById(Long id);
    // 默认使用主库
    User selectByUsername(String username);
}

重要问题与最佳实践

1. 主从复制延迟

   • 问题：写操作在主库执行后，数据会异步复制到从库，这个复制过程需要时间，期间从库的数据是“旧”的，如果在一个事务中先写后读,可能会读到旧数据。
   • 解决方案：
     • 强制读主：对于需要强一致性的读操作（比如刚插入完数据后马上就要查询），可以使用 @Master 注解强制从主库读取。
     • 应用层缓存：对于一些不要求强实时性的数据，可以引入 Redis 等缓存，先读缓存,缓存未命中再读数据库。
     • 优化复制：确保主从复制的网络通畅,并采用半同步复制等机制来减少延迟。

2. 事务管理

   • 问题：在一个事务中，Spring 的 TransactionManager 会在事务开始时获取一个 Connection 并绑定到当前线程，如果这个事务中包含了读写操作，那么整个事务期间，所有数据库操作都会使用同一个 Connection,也就无法实现读写分离。
   • 解决方案：上述 AOP 方案中，@Order(-1) 的设置就是为了保证我们的数据源切换切面在 Spring 事务切面之前执行，但在一个事务内，数据源只会被切换一次（在事务开始时），后续操作不会再次切换。一个事务内不能混合读写分离，如果业务逻辑要求在一个事务内既有写又有读,那么所有操作都必须走主库。

3. 负载均衡

   • 问题：如果有多个从库,如何分配读请求？
   • 解决方案：可以在 DataSourceAspect 中实现一个负载均衡算法，如：
     • 轮询：依次访问 slave1, slave2, slave1...
     • 随机：随机选择一个从库。
     • 权重：根据从库的性能和负载情况,分配不同的权重。

对于新项目，特别是微服务架构，强烈推荐使用 ShardingSphere，它提供了 JDBC 和 Proxy 两种模式，既能满足轻量级需求，也能应对复杂的分布式场景，对于现有项目，如果不想引入太重的中间件，基于 AOP + 自定义 DataSource 的方案是一个很好的选择。