Druid监控配置及扩展

一、基础监控配置

依赖

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

1、纯配置文件方式

普通的单数据源项目中，通过在配置文件中配置的方式即可实现监控（但特殊的需求如SpringAOP还是需要通过部分编码）

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      filters: stat,wall,slf4j # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      max-active: 20 #最大连接池数量 maxIdle已经不再使用
      initial-size: 5 #初始化时建立物理连接的个数
      max-wait: 60000
      min-idle: 5 #最小连接池数量
      time-between-eviction-runs-millis: 60000 #既作为检测的间隔时间又作为testWhileIdel执行的依据
      min-evictable-idle-time-millis: 300000 #销毁线程时检测当前连接的最后活动时间和当前时间差大于该值时，关闭当前连接
      validation-query: select 'x' #用来检测连接是否有效的sql
      #申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
      test-while-idle: true
      test-on-borrow: false #申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
      test-on-return: false #归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
      pool-prepared-statements: false # 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭
      max-open-prepared-statements: 20
      max-pool-prepared-statement-per-connection-size: 20 #当值大于0时poolPreparedStatements会自动修改为true
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录（配置慢SQL的定义时间）
      connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      use-global-data-source-stat: true # 合并多个DruidDataSource的监控数据

      # 设置监控配置
      web-stat-filter:
        enabled: true
        url-pattern: /*
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
        session-stat-enable: true
        session-stat-max-count: 100
      #设置视图拦截,访问druid监控页的账号和密码,默认没有
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        reset-enable: true
        login-username: admin
        login-password: admin

2、通过配置类配置方式

在某些特殊情况下，如系统中有多数据源、动态数据源等情况，Spring无法直接读取配置文件，我们会采用Config类的方式进行配置，这样比较灵活。

1）配置文件，同上，供配置类读取

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      filters: stat,wall,slf4j # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      max-active: 20 #最大连接池数量 maxIdle已经不再使用
      initial-size: 5 #初始化时建立物理连接的个数
      max-wait: 60000
      min-idle: 5 #最小连接池数量
      time-between-eviction-runs-millis: 60000 #既作为检测的间隔时间又作为testWhileIdel执行的依据
      min-evictable-idle-time-millis: 300000 #销毁线程时检测当前连接的最后活动时间和当前时间差大于该值时，关闭当前连接
      validation-query: select 'x' #用来检测连接是否有效的sql
      #申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
      test-while-idle: true
      test-on-borrow: false #申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
      test-on-return: false #归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
      pool-prepared-statements: false # 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭
      max-open-prepared-statements: 20
      max-pool-prepared-statement-per-connection-size: 20 #当值大于0时poolPreparedStatements会自动修改为true
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录（配置慢SQL的定义时间）
      connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      use-global-data-source-stat: true # 合并多个DruidDataSource的监控数据

      # 设置监控配置
      web-stat-filter:
        enabled: true
        url-pattern: /*
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
        session-stat-enable: true
        session-stat-max-count: 100
      #设置视图拦截,访问druid监控页的账号和密码,默认没有
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        reset-enable: true
        login-username: admin
        login-password: admin

2）配置信息类DruidDataSourceProperties

负责读入配置文件中的信息

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * Druid配置信息类
 *
 * @author 
 * @date
 */
@ConfigurationProperties(prefix = "spring.datasource.druid")
public class DruidDataSourceProperties {
   

    private String driverClassName;
    private String url;
    private String username;
    private String password;
    
    private int initialSize;
    private int minIdle;
    private int maxActive = 100;
    private long maxWait;
    private long timeBetweenEvictionRunsMillis;
    private long minEvictableIdleTimeMillis;
    private String validationQuery;
    private boolean testWhileIdle;
    private boolean testOnBorrow;
    private boolean testOnReturn;
    private boolean poolPreparedStatements;
    private int maxPoolPreparedStatementPerConnectionSize;
    
    private String filters;

    public int getInitialSize() {
   
        return initialSize;
    }

    public void setInitialSize(int initialSize) {
   
        this.initialSize = initialSize;
    }

    public int getMinIdle() {
   
        return minIdle;
    }

    public void setMinIdle(int minIdle) {
   
        this.minIdle = minIdle;
    }

    public int getMaxActive() {
   
        return maxActive;
    }

    public void setMaxActive(int maxActive) {
   
        this.maxActive = maxActive;
    }

    public long getMaxWait() {
   
        return maxWait;
    }

    public void setMaxWait(long maxWait) {
   
        this.maxWait = maxWait;
    }

    public long getTimeBetweenEvictionRunsMillis() {
   
        return timeBetweenEvictionRunsMillis;
    }

    public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {
   
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }

    public long getMinEvictableIdleTimeMillis() {
   
        return minEvictableIdleTimeMillis;
    }

    public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
   
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }

    public String getValidationQuery() {
   
        return validationQuery;
    }

    public void setValidationQuery(String validationQuery) {
   
        this.validationQuery = validationQuery;
    }

    public boolean isTestWhileIdle() {
   
        return testWhileIdle;
    }

    public void setTestWhileIdle(boolean testWhileIdle) {
   
        this.testWhileIdle = testWhileIdle;
    }

    public boolean isTestOnBorrow() {
   
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
   
        this.testOnBorrow = testOnBorrow;
    }

    public boolean isTestOnReturn() {
   
        return testOnReturn;
    }

    public void setTestOnReturn(boolean testOnReturn) {
   
        this.testOnReturn = testOnReturn;
    }

    public boolean isPoolPreparedStatements() {
   
        return poolPreparedStatements;
    }