​

博客主页:     南来_北往

系列专栏：Spring Boot实战

---

背景

读写分离是数据库架构中的一种优化策略，它将读操作（查询）和写操作（更新、插入、删除）分开处理，通常通过将读请求和写请求分别发送到不同的数据库服务器来实现。下面介绍实现读写分离的原因：

1. 提高并发能力：在高并发访问场景下，读写分离可以有效地分散请求，提高系统的整体性能。例如，在电商平台中，用户浏览商品的次数远超实际购买的次数，因此将读取操作分配给专门的读库，可以显著降低对主数据库的压力。
2. 优化资源利用：对于数据分析和报告生成任务，需要大量数据读取，而通过读写分离，这些操作不会影响在线事务处理的性能。这样，企业可以进行高效的数据分析，同时确保日常业务的稳定运行。
3. 提升读取性能：读写分离通过多台读库分摊读取压力，从而大幅提升读性能。这对于需要快速响应的数据检索需求尤为关键。
4. 减轻写入负担：在互联网应用中，写操作通常比读操作耗时得多。通过将写操作集中在一个数据库上，并同步到多个读库，可以保证写操作的效率和一致性。
5. 应对不同场景：读写分离适用于多种业务场景，包括高并发访问、数据分析和报告、以及数据仓库等。在这些场景中，读写分离能够优化资源分配，满足不同的业务需求。
6. 支持决策分析：通过读写分离，可以前置处理大量的汇总数据，使得企业的决策分析更加迅速和准确。例如，某公司采用基于FDL的离线数仓方案进行读写分离后，大幅提高了BI报表的稳定性和数据的决策分析能力。

总之，读写分离不仅能有效提升数据库性能，还能根据不同的业务需求，提供灵活的数据处理能力。然而，在实施时也需考虑数据同步延迟、一致性等问题，以确保系统整体的稳定性和可靠性。

实践

1、配置数据源：在application.properties或application.yml文件中配置两个数据源，一个用于读操作（slave），另一个用于写操作（master）。

# application.yml
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

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

 3、建SqlSessionFactory：为每个数据源创建一个SqlSessionFactory。

@Configuration
public class MyBatisConfig {

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

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

    @Bean(name = "masterSqlSessionFactory")
    public SqlSessionFactory masterSqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(masterDataSource);
        return factoryBean.getObject();
    }

    @Bean(name = "slaveSqlSessionFactory")
    public SqlSessionFactory slaveSqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(slaveDataSource);
        return factoryBean.getObject();
    }
}

4、建事务管理器：为每个数据源创建一个事务管理器。

@Configuration
public class TransactionManagerConfig {

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

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

    @Bean(name = "masterTransactionManager")
    public DataSourceTransactionManager masterTransactionManager() {
        return new DataSourceTransactionManager(masterDataSource);
    }

    @Bean(name = "slaveTransactionManager")
    public DataSourceTransactionManager slaveTransactionManager() {
        return new DataSourceTransactionManager(slaveDataSource);
    }
}

5、建动态数据源：根据需要切换不同的数据源。

public class DynamicDataSource extends AbstractRoutingDataSource {

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

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

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

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

    @Override
    protected Object determineCurrentLookupKey() {
        return getDataSource();
    }
}

 6、配置动态数据源：将动态数据源与SqlSessionFactory和事务管理器关联。

@Configuration
public class DataSourceConfig {

    @Autowired
    @Qualifier("masterSqlSessionFactory")
    private SqlSessionFactory masterSqlSessionFactory;

    @Autowired
    @Qualifier("slaveSqlSessionFactory")
    private SqlSessionFactory slaveSqlSessionFactory;

    @Autowired
    @Qualifier("masterTransactionManager")
    private DataSourceTransactionManager masterTransactionManager;

    @Autowired
    @Qualifier("slaveTransactionManager")
    private DataSourceTransactionManager slaveTransactionManager;

    @Bean(name = "dynamicDataSource")
    public DataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("master", masterSqlSessionFactory);
        targetDataSources.put("slave", slaveSqlSessionFactory);
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(masterSqlSessionFactory);
        return dynamicDataSource;
    }

    @Bean(name = "transactionManager")
    public PlatformTransactionManager transactionManager() {
        DynamicDataSourceTransactionManager transactionManager = new DynamicDataSourceTransactionManager();
        transactionManager.setTransactionManagers(Arrays.asList(masterTransactionManager, slaveTransactionManager));
        return transactionManager;
    }
}

 7、用注解切换数据源：在Service层的方法上使用@DS注解来切换数据源。例如，读取操作使用从库，写入操作使用主库。

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @DS("master")
    public void addUser(User user) {
        userMapper.insert(user);
    }

    @DS("slave")
    public List<User> findAllUsers() {
        return userMapper.selectAll();
    }
}

8、最后，需要在启动类上添加@EnableTransactionManagement注解以启用事务管理。

@SpringBootApplication
@EnableTransactionManagement
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}