springboot 关闭多数据源的druid重连的配置

如果你使用的是多数据源的情况下，想要关闭druid的重连功能，可以在application.yml配置文件中进行如下配置：

spring:
  datasource:
    # 第一个数据源
    master:
      type: com.alibaba.druid.pool.DruidDataSource
      ...
      testOnBorrow: false
      testOnReturn: false
      testWhileIdle: false
      # 关闭druid的重连功能
      timeBetweenConnectErrorMillis: -1
    # 第二个数据源
    slave:
      type: com.alibaba.druid.pool.DruidDataSource
      ...
      testOnBorrow: false
      testOnReturn: false
      testWhileIdle: false
      # 关闭druid的重连功能
      timeBetweenConnectErrorMillis: -1

其中，将`timeBetweenConnectErrorMillis`的值设置为-1即可关闭druid的重连功能。

相关问题

springboot mysql多数据源 druid加解密连接数据库代码

好的，下面是一个示例代码，使用Spring Boot和Druid连接MySQL多数据源，并且对数据库密码进行了加解密：

1. 添加依赖

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

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <!-- Spring Boot Starter JDBC -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <!-- Druid -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.23</version>
    </dependency>

    <!-- Jasypt -->
    <dependency>
        <groupId>com.github.ulisesbocchio</groupId>
        <artifactId>jasypt-spring-boot-starter</artifactId>
        <version>3.0.3</version>
    </dependency>
</dependencies>

2. 配置数据源

在 application.yml 文件中添加以下配置：

# 默认数据源
spring.datasource.url=jdbc:mysql://localhost:3306/db1
spring.datasource.username=root
spring.datasource.password=ENC(加密后的密码)
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 第二个数据源
datasource2.url=jdbc:mysql://localhost:3306/db2
datasource2.username=root
datasource2.password=ENC(加密后的密码)
datasource2.driver-class-name=com.mysql.jdbc.Driver

其中，密码字段使用 Jasypt 进行加密，格式为 `ENC(加密后的密码)`。

3. 配置Druid数据源

在配置文件中添加以下配置：

# Druid数据源配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# 配置第一个数据源
spring.datasource.druid.initial-size=5
spring.datasource.druid.min-idle=5
spring.datasource.druid.max-active=20
spring.datasource.druid.max-wait=60000
spring.datasource.druid.time-between-eviction-runs-millis=60000
spring.datasource.druid.min-evictable-idle-time-millis=300000
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.pool-prepared-statements=true
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
spring.datasource.druid.filters=stat,wall,log4j

# 配置第二个数据源
datasource2.druid.initial-size=5
datasource2.druid.min-idle=5
datasource2.druid.max-active=20
datasource2.druid.max-wait=60000
datasource2.druid.time-between-eviction-runs-millis=60000
datasource2.druid.min-evictable-idle-time-millis=300000
datasource2.druid.validation-query=SELECT 1 FROM DUAL
datasource2.druid.test-while-idle=true
datasource2.druid.test-on-borrow=false
datasource2.druid.test-on-return=false
datasource2.druid.pool-prepared-statements=true
datasource2.druid.max-pool-prepared-statement-per-connection-size=20
datasource2.druid.filters=stat,wall,log4j

4. 配置数据源连接池

在配置类中添加以下代码：

@Configuration
public class DataSourceConfig {

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

    @Bean(name = "dataSource2")
    @ConfigurationProperties(prefix = "datasource2")
    public DruidDataSource dataSource2() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = "dataSource1TransactionManager")
    @Primary
    public DataSourceTransactionManager dataSourceTransactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }

    @Bean(name = "dataSource2TransactionManager")
    public DataSourceTransactionManager dataSource2TransactionManager() {
        return new DataSourceTransactionManager(dataSource2());
    }

    @Bean(name = "dataSource1SqlSessionFactory")
    @Primary
    public SqlSessionFactory dataSourceSqlSessionFactory(@Qualifier("dataSource") DruidDataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
        return sessionFactory.getObject();
    }

    @Bean(name = "dataSource2SqlSessionFactory")
    public SqlSessionFactory dataSource2SqlSessionFactory(@Qualifier("dataSource2") DruidDataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper2/*.xml"));
        return sessionFactory.getObject();
    }
}

其中，`@Primary` 注解表示默认数据源，`@ConfigurationProperties` 注解表示从配置文件中读取配置。

5. 配置MyBatis

在 `application.yml` 文件中添加以下配置：

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.example.entity

6. 编写DAO和Mapper

在 `com.example.dao` 包中编写DAO和Mapper，例如：

@Repository
public interface UserDAO {

    @Select("SELECT * FROM user")
    @Results(id = "userResultMap", value = {
            @Result(property = "id", column = "id", id = true),
            @Result(property = "name", column = "name"),
            @Result(property = "email", column = "email"),
            @Result(property = "phone", column = "phone"),
            @Result(property = "createTime", column = "create_time")
    })
    List<User> list();

}

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM user")
    @ResultMap("userResultMap")
    List<User> list();

}

7. 使用数据源

在Service中使用数据源，例如：

@Service
public class UserService {

    @Autowired
    private UserDAO userDAO;

    @Autowired
    private UserMapper userMapper;

    @Transactional(transactionManager = "dataSource1TransactionManager")
    public List<User> list() {
        return userDAO.list();
    }

    @Transactional(transactionManager = "dataSource2TransactionManager")
    public List<User> list2() {
        return userMapper.list();
    }

}

其中，`@Transactional` 注解表示开启事务，`transactionManager` 参数指定使用的数据源。

springboot如何配置多数据源druid

Spring Boot可以通过配置多个数据源来实现多数据源的使用，而Druid是一种数据库连接池，可以提供对多个数据源的连接管理和监控功能。

首先，在`pom.xml`文件中添加Druid和对应数据库驱动的依赖：

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

<!-- 添加其他数据库驱动的依赖 -->

然后，在`application.properties`或`application.yml`中配置多个数据源的相关信息，例如：

# 主数据源
spring.datasource.url=jdbc:mysql://localhost:3306/db1
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 第二个数据源
spring.datasource.second.url=jdbc:mysql://localhost:3306/db2
spring.datasource.second.username=root
spring.datasource.second.password=123456
spring.datasource.second.driver-class-name=com.mysql.cj.jdbc.Driver

接下来，创建多个数据源的配置类，例如：

@Configuration
public class DataSourceConfig {

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

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

注意，`@Primary`注解用于标识默认的主数据源。

最后，在需要使用数据源的地方，通过`@Qualifier`注解指定要使用的数据源，例如：

@Service
public class MyService {

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

    // 使用dataSource进行数据库操作

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

    // 使用secondDataSource进行数据库操作
}

这样就完成了Spring Boot中多数据源Druid的配置。在使用数据源时，可以根据需要在不同的地方注入不同的数据源。