springcloud如何实现数据库读写分离

Spring Cloud可以通过使用动态数据源实现数据库读写分离，具体步骤如下：

1. 引入相关依赖

在Spring Boot项目的pom.xml文件中引入以下依赖：

<!-- MyBatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.0.0</version>
</dependency>

<!-- Druid 数据库连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.21</version>
</dependency>

<!-- HikariCP 数据库连接池 -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>3.4.5</version>
</dependency>

<!-- Spring Data JPA -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

2. 配置数据源

在application.properties或application.yml文件中配置数据源，例如：

# 主数据源
spring.datasource.master.jdbc-url=jdbc:mysql://localhost:3306/masterdb?useUnicode=true&characterEncoding=utf-8
spring.datasource.master.username=root
spring.datasource.master.password=123456
spring.datasource.master.driver-class-name=com.mysql.jdbc.Driver

# 从数据源
spring.datasource.slave.jdbc-url=jdbc:mysql://localhost:3306/slavedb?useUnicode=true&characterEncoding=utf-8
spring.datasource.slave.username=root
spring.datasource.slave.password=123456
spring.datasource.slave.driver-class-name=com.mysql.jdbc.Driver

3. 配置动态数据源

创建动态数据源配置类，例如：

@Configuration
public class DynamicDataSourceConfig {

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

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

    @Bean
    public DynamicDataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                               @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MASTER, masterDataSource);
        targetDataSources.put(DataSourceType.SLAVE, slaveDataSource);
        return new DynamicDataSource(masterDataSource, targetDataSources);
    }
}

其中，masterDataSource()和slaveDataSource()方法分别返回主数据源和从数据源，而dynamicDataSource()方法则创建一个动态数据源，该数据源包含主数据源和从数据源，且可以根据具体的业务需求动态切换数据源。

4. 创建数据源切换类

创建数据源切换类，例如：

public class DataSourceContextHolder {

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

    public static void setDataSourceType(DataSourceType dataSourceType) {
        contextHolder.set(dataSourceType);
    }

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

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

该类使用ThreadLocal存储数据源类型，setDataSourceType()方法设置当前线程使用的数据源类型，getDataSourceType()方法获取当前线程使用的数据源类型，clearDataSourceType()方法清空当前线程使用的数据源类型。

5. 创建数据源切面类

创建数据源切面类，例如：

@Aspect
@Component
public class DataSourceAspect {

    @Pointcut("@annotation(com.example.demo.annotation.DataSource)")
    public void dataSourcePointCut() {
    }

    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        DataSource dataSource = method.getAnnotation(DataSource.class);
        if (dataSource == null) {
            DataSourceContextHolder.setDataSourceType(DataSourceType.MASTER);
        } else {
            DataSourceContextHolder.setDataSourceType(dataSource.value());
        }
        try {
            return point.proceed();
        } finally {
            DataSourceContextHolder.clearDataSourceType();
        }
    }
}

该类使用@Aspect注解声明为切面类，使用@Pointcut注解定义切点，使用@Around注解定义环绕通知，在方法执行前根据注解中指定的数据源类型切换数据源，在方法执行后清空数据源类型。

6. 根据具体业务需求使用动态数据源

在需要使用动态数据源的地方，使用@DataSource注解指定数据源类型，例如：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    @DataSource(DataSourceType.MASTER)
    public int addUser(User user) {
        return userMapper.addUser(user);
    }

    @Override
    @DataSource(DataSourceType.SLAVE)
    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }
}

以上就是使用Spring Cloud实现数据库读写分离的步骤。