Springboot项目 整合Druid连接池+设置注入条件

基础操作

POM文件：

        <!-- 连接池  -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- mysql连接  -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

yml配置文件:

application.yml配置：

spring:
  datasource:
    username: root
    password: *******
    url: jdbc:mysql://XXXXXX.com:XXXX/XXXXXX?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource            # 数据库连接池类别
    druid:
      min-idle: 10                                          # 最小连接数
      max-active: 20                                        # 最大连接数
      initial-size: 10                                       # 初始化大小
      max-wait: 60000                                       # 获取连接时的最大等待时间
      async-init: true                                      # 异步初始化加载
      min-evictable-idle-time-millis: 300000                # 一个连接在池中最小生存的时间，单位是毫秒
      time-between-eviction-runs-millis: 600000             # 多久才进行一次检测需要关闭的空闲连接，单位是毫秒
      filters: stat,wall                                    # 配置扩展插件：stat-监控统计，log4j-日志，wall-防火墙（防止SQL注入），去掉后，监控界面的sql无法统计
      validation-query: SELECT 1                            # 检测连接是否有效的 SQL语句，为空时以下三个配置均无效
      test-on-borrow: true                                  # 申请连接时执行validationQuery检测连接是否有效，默认true，开启后会降低性能
      test-on-return: true                                  # 归还连接时执行validationQuery检测连接是否有效，默认false，开启后会降低性能
      test-while-idle: true                                 # 申请连接时如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效，默认false，建议开启，不影响性能

      stat-view-servlet:
        enabled: true                                       # 是否开启 StatViewServlet
        allow: 127.0.0.1                                    # 访问监控页面 白名单，默认127.0.0.1
        deny:                                               # 访问监控页面 黑名单
        login-username: admin                               # 访问监控页面 登陆账号
        login-password: admin                               # 访问监控页面 登陆密码
      filter:
        stat:
          enabled: true                                     # 是否开启 FilterStat，默认true
          log-slow-sql: true                                # 是否开启 慢SQL 记录，默认false
          slow-sql-millis: 5000                             # 慢 SQL 的标准，默认 3000，单位：毫秒
          merge-sql: false                                  # 合并多个连接池的监控数据，默认false

启动服务

查看监控

在浏览器中输入http://IP:端口号/druid/index.html访问监控中心

设置条件加载

忽略自动加载

数据库DataSourceAutoConfiguration.class 、连接池DruidDataSourceAutoConfigure.class

spring:
  #忽略Spring自动加载
  autoconfigure:
    exclude:
      #====《忽略 数据库自动加载》====
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration  #基础数据源 jdbc配置
      - com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure #数据库连接池 配置

数据库连接池 条件类：DataSourceCondition.class

import com.details.utils.ExceptionUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * @Author Owen
 * @Date 2020/8/17
 * @Description数据库连接池加载条件
 */
@Slf4j
public class DataSourceCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        boolean result = false;
        try {
            //项目环境 上下文
            Environment environment = context.getEnvironment();
            //数据源账号
            String username = environment.getProperty("spring.datasource.username");


            //是否配置 默认数据源(读写都使用相同的数据源)
            if (StringUtils.isNotBlank(username)) {
                //数据源配置
                String password = environment.getProperty("spring.datasource.password");
                ExceptionUtils.isBlank(password, "Password not null!");

                //连接池配置
                String minIdle = environment.getProperty("spring.datasource.druid.min-idle");
                ExceptionUtils.isBlank(minIdle, "Params:{spring.datasource.druid} get null!");

                return true;
            } else {
                log.error("DataSource not config ured, Ignore the load !");
                return false;
            }
        } catch (Exception e) {
            log.error("DataSource exception: {}", e.getMessage());
        }
        return result;
    }
}

连接池 自定义加载类：DruidDataSourceConfig.class

package com.details.config;
import com.alibaba.druid.filter.Filter;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.properties.DruidStatProperties;
import com.alibaba.druid.spring.boot.autoconfigure.stat.DruidFilterConfiguration;
import com.alibaba.druid.spring.boot.autoconfigure.stat.DruidSpringAopConfiguration;
import com.alibaba.druid.spring.boot.autoconfigure.stat.DruidStatViewServletConfiguration;
import com.alibaba.druid.spring.boot.autoconfigure.stat.DruidWebStatFilterConfiguration;
import javax.sql.DataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import java.util.List;


 /**
 * @Author: Owen
 * @Date: 2022/10/25
 * @Description:数据库连接池配置
 * application.yml若未配置数据库, 则忽略Spring加载
 */
@Slf4j
@Configuration
//Spring依赖注入  条件依赖类:(DataSourceCondition.class)
@Conditional(DataSourceCondition.class)
@ConditionalOnClass({DruidDataSource.class})
@AutoConfigureBefore({DataSourceAutoConfiguration.class})
@EnableConfigurationProperties({DruidStatProperties.class, DataSourceProperties.class})
@Import({DruidSpringAopConfiguration.class, DruidStatViewServletConfiguration.class, DruidWebStatFilterConfiguration.class, DruidFilterConfiguration.class})
public class DruidDataSourceConfig {
    public DruidDataSourceConfig() {
    }


    /**
    * @Author: Owenx
    * @Date: 2022/10/25
    * @Description:构建数据源
    */
    @Bean(initMethod = "init")
    @ConditionalOnMissingBean
    public DataSource dataSource() {
        log.info("Init DruidDataSource");
        return new DataSourceWrapper();
    }


    /**
    * @Author: Owen
    * @Date: 2022/10/25
    * @Description:数据源包装类
    */
    @ConfigurationProperties("spring.datasource.druid")
    class DataSourceWrapper extends DruidDataSource implements InitializingBean {
        @Autowired
        private DataSourceProperties basicProperties;

        DataSourceWrapper() {
        }

        public void afterPropertiesSet() throws Exception {
            if (super.getUsername() == null) {
                super.setUsername(this.basicProperties.determineUsername());
            }

            if (super.getPassword() == null) {
                super.setPassword(this.basicProperties.determinePassword());
            }

            if (super.getUrl() == null) {
                super.setUrl(this.basicProperties.determineUrl());
            }

            if (super.getDriverClassName() == null) {
                super.setDriverClassName(this.basicProperties.getDriverClassName());
            }

        }

        @Autowired(required = false)
        public void autoAddFilters(List<Filter> filters) {
            super.filters.addAll(filters);
        }

        public void setMaxEvictableIdleTimeMillis(long maxEvictableIdleTimeMillis) {
            try {
                super.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);
            } catch (IllegalArgumentException var4) {
                super.maxEvictableIdleTimeMillis = maxEvictableIdleTimeMillis;
            }
        }
    }

}