druid数据库连接池配置

在Maven依赖中加入druid和mysql-connector-java依赖

在同src目录下的druid.properties文件进行相关的配置。

url=jdbc:mysql://localhost:3306/xxx
username=root
password=123456
driverClassName=com.mysql.jdbc.Driver

initialSize=10//初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
maxActive=20//最大连接池数量
maxWait=1000//获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
filters=wall

 //使用Druid连接池
    private static DataSource source=null;
    static {
        try {
            Properties prop=new Properties();
            InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
            prop.load(is);
            //加载驱动
            source = DruidDataSourceFactory.createDataSource(prop);
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnectionDruid() throws Exception {

        //获取连接
        Connection connection = source.getConnection();
        return connection;
    }

通过应该配置类的方式


import com.alibaba.druid.pool.DruidDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
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.sql.SQLException;


/**
 * @ClassName: DruidConfiguration
 * @Description:Druid监控配置类
 * @author  df.l
 * @date 2021年11月04日
 * @Copyright boulderai8tech.com
 */
@Configuration
public class DruidConfiguration {
  private static final Logger LOGGER = LoggerFactory.getLogger(DruidConfiguration.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.driverClassName}")
  private String driverClassName;

  @Value("${spring.datasource.initialSize}")
  private int initialSize;

  @Value("${spring.datasource.minIdle}")
  private int minIdle;

  @Value("${spring.datasource.maxActive}")
  private int maxActive;

  @Value("${spring.datasource.maxWait}")
  private int maxWait;

  @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
  private int timeBetweenEvictionRunsMillis;

  @Value("${spring.datasource.minEvictableIdleTimeMillis}")
  private int minEvictableIdleTimeMillis;

  @Value("${spring.datasource.validationQuery}")
  private String validationQuery;

  @Value("${spring.datasource.testWhileIdle}")
  private boolean testWhileIdle;

  @Value("${spring.datasource.testOnBorrow}")
  private boolean testOnBorrow;

  @Value("${spring.datasource.testOnReturn}")
  private boolean testOnReturn;

  @Value("${spring.datasource.poolPreparedStatements}")
  private boolean poolPreparedStatements;

  @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
  private int maxPoolPreparedStatementPerConnectionSize;

  @Value("${spring.datasource.filters}")
  private String filters;

  @Value("{spring.datasource.connectionProperties}")
  private String connectionProperties;

  @Bean(name = "dataSource")
  public DataSource dataSource() {
    DruidDataSource datasource = new DruidDataSource();

    datasource.setUrl(this.dbUrl);
    datasource.setUsername(username);
    datasource.setPassword(password);
    datasource.setDriverClassName(driverClassName);

    //configuration
    datasource.setInitialSize(initialSize);
    datasource.setMinIdle(minIdle);
    datasource.setMaxActive(maxActive);
    datasource.setMaxWait(maxWait);
    datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
    datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
    datasource.setValidationQuery(validationQuery);
    datasource.setTestWhileIdle(testWhileIdle);
    datasource.setTestOnBorrow(testOnBorrow);
    datasource.setTestOnReturn(testOnReturn);
    datasource.setPoolPreparedStatements(poolPreparedStatements);
    datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
    try {
      datasource.setFilters(filters);
    } catch (SQLException e) {
      LOGGER.error("druid configuration initialization filter", e);
    }
    datasource.setConnectionProperties(connectionProperties);
    return datasource;
  }

}

---

后加

springboot+druid数据库连接池配置

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

在application.yml项目配置文件中加入druid的数据库连接池配置

spring:
  datasource:
    #类型
    type: com.alibaba.druid.pool.DruidDataSource
    #驱动
    driverClassName: com.mysql.jdbc.Driver
    driver-class-name: com.mysql.jdbc.Driver
    platform: mysql
    #数据库连接
    url: jdbc:mysql://xxx.xx.xxx.xxx:3306/MYDATA?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false
    #数据库用户名密码
    username: xxxxx
    password: xxxxxxxx
    #连接池配置
    druid:
      #初始化连接池大小
      initialSize: 10
      #最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止
      minIdle: 1
      #最大活跃数
      maxActive: 50
      #最大建立连接等待时间。如果超过此时间将接到异常。设为－1表示无限制
      maxWait: 60000
      #失效检查线程运行时间间隔，要小于MySQL默认
      timeBetweenEvictionRunsMillis: 60000
      #连接的超时时间，默认为半小时
      minEvictableIdleTimeMillis: 300000
      #检查连接有效性的SQL语句
      validationQuery: SELECT 1 FROM dual
      #检查连接是否有效
      testWhileIdle: true
      testOnBorrow: true
      testOnReturn: false
      #开启池的prepared statement 池功能
      poolPreparedStatements: false
      #statement池能够同时分配的打开的statements的最大数量
      maxOpenPreparedStatements: 50
      #开启StatFilter
      filter:
        stat:
          enabled: true
          log-slow-sql: true
          slow-sql-millis: 1000
        #开启Slf4jFilter,使用logback时注释
        #slf4j:
          #enabled: true
          #data-source-log-enabled: false
          #connection-log-enabled: false
          #statement-log-enabled: false
          #result-set-log-enabled: false
        #开启WallFilter
        wall:
          enabled: true
          log-violation: true
          throw-exception: false
          config:
            delete-where-none-check: true
      #开启Web监控
      web-stat-filter:
        enabled: true
        exclusions: /druid/*,*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico
        url-pattern: /*
      #开启监控页面
      stat-view-servlet:
        enabled: true
        login-username: admin
        login-password: admin123

启动项目，打开http://127.0.0.1:8080/druid页面即可看到druid的监控页面。ip和端口就是项目的ip和端口

需要自己为 DruidDataSource 绑定全局配置文件中的参数，再添加到容器中，而不再使用 Spring Boot 的自动生成了；我们需要 自己添加 DruidDataSource 组件到容器中，并绑定属性

@Configuration
public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){
       return  new DruidDataSource();
    }

   
}

使用

@SpringBootTest
class SpringbootDataJdbcApplicationTests {

    //DI注入数据源
    @Autowired
    DataSource dataSource;

    @Test
    public void contextLoads() throws SQLException {
        //看一下默认数据源
        System.out.println(dataSource.getClass());
        //获得连接
        Connection connection =   dataSource.getConnection();
        System.out.println(connection);

        DruidDataSource druidDataSource = (DruidDataSource) dataSource;
        System.out.println("druidDataSource 数据源最大连接数：" + druidDataSource.getMaxActive());
        System.out.println("druidDataSource 数据源初始化连接数：" + druidDataSource.getInitialSize());

        //关闭连接
        connection.close();
    }
}

druid连接池配置的主要参数说明
name ： 配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。如果没有配置，将会生成一个名字，格式是：“DataSource-” + System.identityHashCode(this). 另外配置此属性至少在1.0.5版本中是不起作用的，强行设置name会出错。

url：连接数据库的url，不同数据库不一样。例如：

mysql : jdbc:mysql://x.x.xxx.xxx:3306/database

oracle : jdbc:oracle:thin:@xx.xx.xx.xx:1521:database

username:连接数据库的用户名

password:连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter

driverClassName: 缺省值-根据url自动识别 这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName

initialSize: 缺省值-0 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时

maxActive: 缺省值- 8 最大连接池数量

maxIdle: 缺省值- 8 已经不再使用，配置了也没有效果的

minIdle: 最小连接池数量

maxWait:获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。

poolPreparedStatements: 缺省值-false 是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。

maxPoolPreparedStatementPerConnectionSize: 缺省值- -1 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100

validationQuery:用来检测连接是否有效的sql，要求是一个查询语句，常用select ‘x’。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用

validationQueryTimeout:单位：秒，检测连接是否有效的超时时间。底层调用jdbc Statement对象的void setQueryTimeout(int seconds)方法

testOnBorrow: 缺省值-true 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。

testOnReturn: 缺省值-false 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。

testWhileIdle:缺省值-false 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。

keepAlive:缺省值-false(1.0.28版本)连接池中的minIdle数量以内的连接，空闲时间超过minEvictableIdleTimeMillis，则会执行keepAlive操作。

timeBetweenEvictionRunsMillis: 缺省值- 1分钟（1.0.14） 有两个含义：

Destroy线程会检测连接的间隔时间，如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。

testWhileIdle的判断依据，详细看testWhileIdle属性的说明

numTestsPerEvictionRun:缺省值- 30分钟 不再使用，一个DruidDataSource只支持一个EvictionRun

minEvictableIdleTimeMillis: 连接保持空闲而不被驱逐的最小时间

connectionInitSqls: 物理连接初始化的时候执行的sql

exceptionSorter:缺省值-根据dbtype自动识别 当数据库抛出一些不可恢复的异常时，抛弃连接

filters: 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：

监控统计用的filter:stat

日志用的filter:log4j

防御sql注入的filter:wall

proxyFilters:类型是List<com.alibaba.druid.filter.Filter>，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系