Spring中如何实现数据库数据源的读写分离配置？

可以通过配置多个数据源，然后使用Spring提供的AbstractRoutingDataSource类来实现读写分离。在AbstractRoutingDataSource的子类中，可以根据具体的业务需求，动态地选择数据源。同时，也可以使用第三方的数据库连接池，如Druid，来实现更加高效的数据源管理。

相关问题

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实现数据库读写分离的步骤。

spring boot 多数据源_Spring Boot2(四)：使用Spring Boot多数据源实现读写分离

在Spring Boot应用中使用多数据源可以实现读写分离，提高系统的性能和可用性，同时也可以满足不同业务场景下的需求。下面我们来介绍如何使用Spring Boot多数据源实现读写分离。

1. 添加依赖

在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

其中，spring-boot-starter-jdbc是Spring Boot提供的JDBC Starter，用于连接数据库。druid是阿里巴巴开源的数据库连接池。

2. 配置数据源

在application.yml文件中添加数据源配置：

spring:
  datasource:
    master:
      url: jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
    slave:
      url: jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver

其中，我们配置了两个数据源：master和slave。分别连接了两个不同的数据库，用于实现读写分离。

3. 配置数据源和事务管理器

在Spring Boot中，我们需要自己配置数据源和事务管理器。可以在代码中通过@Primary和@Qualifier注解实现数据源的动态切换。

@Configuration
public class DataSourceConfig {

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

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

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

    @Bean(name = "transactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("dynamicDataSource") DynamicDataSource dynamicDataSource) {
        return new DataSourceTransactionManager(dynamicDataSource);
    }
}

其中，我们定义了DataSourceConfig配置类，用于配置数据源和事务管理器。我们通过@Bean注解创建数据源对象并读取application.yml配置文件中的数据源信息。然后通过@Primary注解指定默认的数据源为Master数据源。最后，我们创建了DynamicDataSource对象，用于动态切换数据源，同时创建了事务管理器对象，用于管理事务。

4. 定义数据源切换注解

我们可以通过自定义注解来实现动态切换数据源。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface TargetDataSource {
    DynamicDataSource.DataSourceType value() default DynamicDataSource.DataSourceType.MASTER;
}

其中，@TargetDataSource注解用于标记数据源类型，我们通过value()方法指定数据源类型，默认为Master数据源。

5. 定义动态数据源

我们可以通过继承AbstractRoutingDataSource类来实现动态数据源的切换。

public class DynamicDataSource extends AbstractRoutingDataSource {

    private DataSource masterDataSource;
    private Map<Object, Object> targetDataSources;

    public DynamicDataSource(DataSource masterDataSource, Map<Object, Object> targetDataSources) {
        this.masterDataSource = masterDataSource;
        this.targetDataSources = targetDataSources;
        super.setDefaultTargetDataSource(masterDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceType();
    }

    public enum DataSourceType {
        MASTER, SLAVE
    }
}

其中，我们定义了DynamicDataSource类，继承了AbstractRoutingDataSource类。在DynamicDataSource类中，我们重写了determineCurrentLookupKey()方法，根据当前线程的数据源类型，返回对应的数据源。我们通过枚举类型DataSourceType定义了Master和Slave两种数据源类型。

6. 实现数据源切换

我们可以通过AOP的方式，在方法执行前切换数据源。

@Aspect
@Component
public class DataSourceAspect {

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

    }

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

其中，我们定义了DataSourceAspect切面类，用于切换数据源。我们通过@Around注解标记了切点，在方法执行前，根据注解中指定的数据源类型，切换数据源。执行完毕后，再切换回默认的Master数据源。

7. 编写业务代码

最后，我们编写业务代码，通过@TargetDataSource注解指定数据源类型。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    @TargetDataSource(DynamicDataSource.DataSourceType.MASTER)
    public void addUser(User user) {
        userMapper.addUser(user);
    }

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

其中，我们定义了UserServiceImpl类，实现了UserService接口。在addUser()方法中，我们指定数据源类型为Master数据源，在getUserById()方法中，我们指定数据源类型为Slave数据源。

通过以上步骤，我们就可以实现Spring Boot多数据源的读写分离了。