druid多数据源切换

在使用Druid进行多数据源切换时，你可以按照以下步骤进行操作：

1. 配置多个数据源：在Druid的配置文件中，可以添加多个数据源的配置信息，每个数据源需要指定其唯一的名称、连接URL、用户名、密码等信息。

2. 创建数据源路由器：在你的应用程序中，创建一个数据源路由器类，用于根据需要切换使用不同的数据源。这个类需要维护一个数据源的列表，并提供方法来选择并返回当前需要使用的数据源。

3. 实现数据源切换逻辑：根据你的业务需求，在应用程序中确定何时需要切换数据源。可以根据用户请求、环境变量、配置文件等条件来判断使用哪个数据源，并通过数据源路由器类来获取相应的数据源。

4. 动态切换数据源：在需要切换数据源的地方，通过调用数据源路由器类的方法来获取当前需要使用的数据源，并将其设置为当前线程或上下文中的默认数据源。这样，在后续的数据库操作中，就会使用该数据源来执行查询或更新操作。

需要注意的是，Druid本身并不提供多数据源切换的功能，但你可以借助Druid的连接池和配置灵活性来实现多数据源切换。具体实现方式会根据你所使用的编程语言和框架而有所不同，你可以参考相关文档或搜索相关的示例代码来获取更具体的指导。

相关问题

springboot druid 多数据源 示例

非常感谢您的提问。下面是 Spring Boot 和 Druid 多数据源的示例代码：

您需要添加以下 Maven 依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.21</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

然后，在 `application.yml` 中配置数据源：

spring:
  datasource:
    # 主数据源
    druid:
      url: jdbc:mysql://localhost:3306/main?useUnicode=true&characterEncoding=utf-8&autoReconnect=true
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver
      initialSize: 5
      minIdle: 5
      maxActive: 20
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: select 1 from dual
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      filters: stat,wall,log4j
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

    # 第一个从数据源
    druid1:
      url: jdbc:mysql://localhost:3306/user_db?useUnicode=true&characterEncoding=utf-8&autoReconnect=true
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver
      initialSize: 5
      minIdle: 5
      maxActive: 20
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: select 1 from dual
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      filters: stat,wall,log4j
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

    # 第二个从数据源
    druid2:
      url: jdbc:mysql://localhost:3306/other_db?useUnicode=true&characterEncoding=utf-8&autoReconnect=true
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver
      initialSize: 5
      minIdle: 5
      maxActive: 20
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: select 1 from dual
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      filters: stat,wall,log4j
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

然后，在 Java 代码中配置数据源：

@Configuration
public class DataSourceConfig {

    @Bean
    @Primary
    @ConfigurationProperties("spring.datasource.druid")
    public DataSource mainDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid1")
    public DataSource dataSource1() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid2")
    public DataSource dataSource2() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    public DataSource dynamicDataSource(@Qualifier("mainDataSource") DataSource mainDataSource,
                                        @Qualifier("dataSource1") DataSource dataSource1,
                                        @Qualifier("dataSource2") DataSource dataSource2) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MAIN, mainDataSource);
        targetDataSources.put(DataSourceType.DATA_SOURCE_1, dataSource1);
        targetDataSources.put(DataSourceType.DATA_SOURCE_2, dataSource2);
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(mainDataSource);
        return dynamicDataSource;
    }
}

其中，`DynamicDataSource` 是一个自定义的 `javax.sql.DataSource` 实现类，用于支持数据源的动态切换。最后，您就可以在代码中使用 `@Qualifier(DataSourceType.MAIN)`、`@Qualifier(DataSourceType.DATA_SOURCE_1)`、`@Qualifier(DataSourceType.DATA_SOURCE_2)` 等注解来区分使用不同的数据源了。

希望这个示例能够帮到您！

springboot 关于druid多数据源配置文件

好的，关于Spring Boot中使用Druid实现多数据源配置，你可以按照以下步骤进行操作：

1. 添加Druid和JDBC依赖

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

<!-- Druid依赖 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.21</version>
</dependency>

<!-- JDBC依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

2. 配置Druid数据源

在application.yml配置文件中，添加Druid数据源的配置，包括主数据源和从数据源的配置，例如：

spring:
  datasource:
    master:
      url: jdbc:mysql://localhost:3306/db_master?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver
      # Druid配置
      initialSize: 5
      minIdle: 5
      maxActive: 20
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 1 FROM DUAL
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      filters: stat,wall,log4j
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    slave:
      url: jdbc:mysql://localhost:3306/db_slave?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver
      # Druid配置
      initialSize: 5
      minIdle: 5
      maxActive: 20
      maxWait: 60000
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 1 FROM DUAL
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      filters: stat,wall,log4j
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

3. 配置数据源路由

在配置类中，使用@Primary注解指定主数据源，使用@Qualifier注解指定从数据源，使用@DependsOn注解保证数据源初始化顺序，例如：

@Configuration
public class DataSourceConfig {

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

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

    @Bean
    @DependsOn({"masterDataSource", "slaveDataSource"})
    public DataSourceRouting dataSourceRouting(@Qualifier("masterDataSource") DataSource masterDataSource,
                                                 @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        return new DataSourceRouting(masterDataSource, slaveDataSource);
    }

}

4. 配置数据源切换

使用ThreadLocal实现数据源切换，例如：

public class DataSourceRouting {

    private final ThreadLocal<String> dataSourceKey = new ThreadLocal<>();

    private final DataSource masterDataSource;

    private final DataSource slaveDataSource;

    public DataSourceRouting(DataSource masterDataSource, DataSource slaveDataSource) {
        this.masterDataSource = masterDataSource;
        this.slaveDataSource = slaveDataSource;
    }

    public DataSource determineDataSource() {
        String key = dataSourceKey.get();
        if (key != null && !key.isEmpty()) {
            if ("master".equals(key)) {
                return masterDataSource;
            } else if ("slave".equals(key)) {
                return slaveDataSource;
            }
        }
        return masterDataSource;
    }

    public void setDataSourceKey(String key) {
        dataSourceKey.set(key);
    }

    public void clearDataSourceKey() {
        dataSourceKey.remove();
    }

}

5. 在需要切换数据源的地方调用setDataSourceKey方法进行切换

例如：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private DataSourceRouting dataSourceRouting;

    @Override
    public User getUserById(Long id) {
        dataSourceRouting.setDataSourceKey("slave");
        User user = userDao.getUserById(id);
        dataSourceRouting.clearDataSourceKey();
        return user;
    }

    @Override
    @Transactional
    public void addUser(User user) {
        dataSourceRouting.setDataSourceKey("master");
        userDao.addUser(user);
        dataSourceRouting.clearDataSourceKey();
    }

}

以上就是使用Druid实现Spring Boot多数据源配置的步骤，希望对你有所帮助。