druid作为数据库连接池的几种配置总结，通过debug去跟配置结果

目录

检测方法--后面的测试结果，debug结果都是基于该测试类测试。

一、数据库默认的数据连接池

二、纯yml配置druid阿里巴巴数据库连接池（强烈推荐方式，我也是这么配置的）

三、需要借助配置文件，Java类来注入属性的配置

四、注入同三，只是注入配置文件可以改成自己对应属性注入，有yml基础的看的懂，方式差不多

踩坑点总结

---

整篇文章基于SpringBoot2.2.6编写。不同SpringBoot配置存在某些差异，后面会提。

检测方法--后面的测试结果，debug结果都是基于该测试类测试。

作用：用于检测数据库连接池是否生效，属性是否注入等。

测试类如下，通过打断点测试

@SpringBootTest
public class DataSourceTest {

    @Autowired
    DataSource dataSource;

    @Test
    void contexts() throws SQLException {
        //测试数据源、通过数据源拿到的连接种类
        System.out.println(dataSource.getClass());
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
}

此方法每次可以根据输出结果观察到数据源是哪种，连接是哪种

测试属性是否注入，断点位置如下

通过debug启动，然后查看dataSource的属性，对于我，一般只要查看initialSize=0就是未注入成功

下面进入正题

一、数据库默认的数据连接池

application.yml配置

spring:
#数据源配置，使用默认的数据库连接池
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/essm_dev?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
    username: essm_dev
    password: essm123456

注意：如果遇到什么错，基本上是url：jdbc那个属性后面的配置没有写正确，时区啥的

进行测试，通过test打印数据源类，数据连接类型如下图

SpringBoot2.2.6默认是使用的是HikariDataSource作为数据库连接池

二、纯yml配置druid阿里巴巴数据库连接池（强烈推荐方式，我也是这么配置的）

依赖：使用strarer启动器作为依赖，便可以实现纯yml配置

 <!--数据源配置，纯yml配置，结合springboot的druid_start启动器实现-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

yml配置信息如下：

spring:
#数据源配置，纯yml配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/essm_dev?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
    username: essm_dev
    password: essm123456
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 初始化大小，最小，最大活跃数
      initial-size: 8
      min-idle: 8
      max-active: 20
      # 配置获取连接等待超时的时间，单位是毫秒
      max-wait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      time-between-eviction-runs-millis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      min-evictable-idle-time-millis: 30000
      max-evictable-idle-time-millis: 300000
      validation-query: SELECT 1
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      # 打开PSCache，并且指定每个连接上PSCache的大小
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      #配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙，slf4j（用log4j需要额外导入依赖，版本不同，这里也可以去掉slf4j）
      filters: stat,wall,slf4j
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      # 配置监控服务器
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        reset-enable: true
        login-username: druid
        login-password: druid123

debug测试结果：

1、属性都正常注入，成功

2、输入结果拿到的是阿里巴巴druid数据库自动配置starater的连接池和连接

3、启动应用程序后--不是测试啦，登录localhost:8080/druid出现数据库监测界面

4、输入yml配置文件的账户密码，druid,druid123，登录成功，结束

三、需要借助配置文件，Java类来注入属性的配置

导入的是普通的阿里巴巴druid依赖，这里不支持yml纯配置，不是starter，检测就是debug你会发现数据注入不成功。

依赖：

<!-- 加入阿里巴巴连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

还是用原来的yml配置文件，未修改

debug测试结果

1、属性对不上，注入失败

2、数据库连接池是druid，拿到的连接是普通的数据库连接

难道是yml配置问题？修改一下，将yml配置的druid节点去掉再次测试

新的配置文件

spring:
  #禁用thymeleaf
  thymeleaf:
    cache: false

#数据源配置，配置文件DruidConfig配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/essm_dev?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
    username: essm_dev
    password: essm123456
    type: com.alibaba.druid.pool.DruidDataSource
    #druid:
    # 初始化大小，最小，最大活跃数
    initial-size: 8
    min-idle: 8
    max-active: 20
    # 配置获取连接等待超时的时间，单位是毫秒
    max-wait: 60000
    # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    time-between-eviction-runs-millis: 60000
    # 配置一个连接在池中最小生存的时间，单位是毫秒
    min-evictable-idle-time-millis: 30000
    max-evictable-idle-time-millis: 300000
    validation-query: SELECT 1
    test-while-idle: true
    test-on-borrow: false
    test-on-return: false
    # 打开PSCache，并且指定每个连接上PSCache的大小
    pool-prepared-statements: true
    max-pool-prepared-statement-per-connection-size: 20
    #配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,slf4j
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    # 配置监控服务器
    stat-view-servlet:
      enabled: true
      url-pattern: /druid/*
      reset-enable: true
      login-username: druid
      login-password: druid123

测试结果还是一样，这里不贴结果

其实是要自己编写属性配置文件，进行注入

yml配置文件

spring:
  #禁用thymeleaf
  thymeleaf:
    cache: false

#数据源配置，配置文件DruidConfig配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/essm_dev?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
    username: essm_dev
    password: essm123456
    type: com.alibaba.druid.pool.DruidDataSource
    #druid:
    # 初始化大小，最小，最大活跃数
    initial-size: 8
    min-idle: 8
    max-active: 20
    # 配置获取连接等待超时的时间，单位是毫秒
    max-wait: 60000
    # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    time-between-eviction-runs-millis: 60000
    # 配置一个连接在池中最小生存的时间，单位是毫秒
    min-evictable-idle-time-millis: 30000
    max-evictable-idle-time-millis: 300000
    validation-query: SELECT 1
    test-while-idle: true
    test-on-borrow: false
    test-on-return: false
    # 打开PSCache，并且指定每个连接上PSCache的大小
    pool-prepared-statements: true
    max-pool-prepared-statement-per-connection-size: 20
    #配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,slf4j
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    # 配置监控服务器
    stat-view-servlet:
      enabled: true
      url-pattern: /druid/*
      reset-enable: true
      login-username: druid
      login-password: druid123

属性注入类DruidConfig

 package com.essm.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;
import java.util.HashMap;


/**
 *
 * druid数据源具有监控的功能，并提供了一个 web 界面方便用户查看
 *
 * @author ：HUANG ZHI XUE
 * @date ：Create in 2020-08-04
 */


@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource() {
        return new DruidDataSource();
    }

    //后台监控:因为springboot内置了servlet容器，使用没有web.xml，可以用ServletRegistrationBean替代
    @Bean
    public ServletRegistrationBean statViewServlet() {
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");

        //后台需要有人登陆，账号密码
        HashMap<String, String> initParameters = new HashMap<>();

        //增加配置
        initParameters.put("loginUsername", "admin");  //登陆参数是固定的
        initParameters.put("loginPassword", "123456");

        //允许谁可以访问
        initParameters.put("allow", "");


        bean.setInitParameters(initParameters);  //设置初始化参数
        return bean;
    }

} 

重新测试，测试结果

1、属性注入成功

2、输出结果，拿到的是普通的druid数据源和连接

3、启动主程序，登录监控localhost:8080/druid，输入账户密码admin/admin123成功

四、注入同三，只是注入配置文件可以改成自己对应属性注入，有yml基础的看的懂，方式差不多

配置文件DruidConfig给出如下

package com.essm.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 *
 * 数据源具有监控的功能，并提供了一个 web 界面方便用户查看
 * Druid数据库连接池配置文件
 *
 * @author ：HUANG ZHI XUE
 * @date ：Create in 2020-08-04
 */

//@Configuration
public class DruidConfig {
    private static final Logger logger = LoggerFactory.getLogger(DruidConfig.class);
    @Value("${spring.datasource.url}")
    private String dbUrl;
    @Value("${spring.datasource.username}")
    private String username;
    @Value("${spring.datasource.password}")
    private String password;
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.druid.initial-size}")
    private int initialSize;
    @Value("${spring.datasource.druid.max-active}")
    private int maxActive;
    @Value("${spring.datasource.druid.min-idle}")
    private int minIdle;
    @Value("${spring.datasource.druid.max-wait}")
    private int maxWait;
    @Value("${spring.datasource.druid.pool-prepared-statements}")
    private boolean poolPreparedStatements;
    @Value("${spring.datasource.druid.max-pool-prepared-statement-per-connection-size}")
    private int maxPoolPreparedStatementPerConnectionSize;
    @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
    private int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
    private int minEvictableIdleTimeMillis;
    @Value("${spring.datasource.druid.max-evictable-idle-time-millis}")
    private int maxEvictableIdleTimeMillis;
    @Value("${spring.datasource.druid.validation-query}")
    private String validationQuery;
    @Value("${spring.datasource.druid.test-while-idle}")
    private boolean testWhileIdle;
    @Value("${spring.datasource.druid.test-on-borrow}")
    private boolean testOnBorrow;
    @Value("${spring.datasource.druid.test-on-return}")
    private boolean testOnReturn;
    @Value("${spring.datasource.druid.filters}")
    private String filters;
    @Value("{spring.datasource.druid.connection-properties}")
    private String connectionProperties;

    /**
     * Druid 连接池配置
     */
    @Bean     //声明其为Bean实例
    public DruidDataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(dbUrl);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setMaxEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (Exception e) {
            logger.error("druid configuration initialization filter", e);
        }
        datasource.setConnectionProperties(connectionProperties);
        return datasource;
    }

    /**
     * 配置 Druid 监控界面
     */
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean srb =
                new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
        //设置控制台管理用户
        srb.addInitParameter("loginUsername","root");
        srb.addInitParameter("loginPassword","root");
        //是否可以重置数据
        srb.addInitParameter("resetEnable","false");
        return srb;
    }

/*    @Bean
    public FilterRegistrationBean statFilter(){
        //创建过滤器
        FilterRegistrationBean frb =
                new FilterRegistrationBean(new WebStatFilter());
        //设置过滤器过滤路径
        frb.addUrlPatterns("/*");
        //忽略过滤的形式
        frb.addInitParameter("exclusions",
                "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return frb;
    }*/
}

yml配置

spring:
#数据源配置，纯yml配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/essm_dev?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
    username: essm_dev
    password: essm123456
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 初始化大小，最小，最大活跃数
      initial-size: 8
      min-idle: 8
      max-active: 20
      # 配置获取连接等待超时的时间，单位是毫秒
      max-wait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      time-between-eviction-runs-millis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      min-evictable-idle-time-millis: 30000
      max-evictable-idle-time-millis: 300000
      validation-query: SELECT 1
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      # 打开PSCache，并且指定每个连接上PSCache的大小
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      #配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙，slf4j（用log4j需要额外导入依赖，版本不同，这里也可以去掉slf4j）
      filters: stat,wall,slf4j
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      # 配置监控服务器
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        reset-enable: true
        login-username: druid
        login-password: druid123

踩坑点总结

版本问题1：

版本问题会导致很多问题，如比较低的SpringBoot版本，在配置里面，很多加了log4j会不会报错，但是后面版本高的SpringBoot就会报错，需要去掉log4j或者加入log4j依赖或者改成slf4j

版本问题2：

看到很多在DruidConfig里面配了过滤器这个在同样在低版本中的SpringBoot可以，但是高版本也不支持，直接去掉就行了。

jdbc版本问题：

driver依赖6以上的驱动是配置cj的，url时区问题常发生错误，注意配置后面属性&serverTimezone=GMT%2B8

差不多了吧，以上简单总结一下。

本文地址：https://blog.csdn.net/qq_41055045/article/details/107883715