暂无图片
暂无图片
暂无图片
暂无图片
暂无图片
首页 / Druid监控还可以这样用

Druid监控还可以这样用

重口味码农 2020-06-18
1154

一、基础监控配置

依赖

  1.         <!-- Druid -->
  2.         <dependency>
  3.             <groupId>com.alibaba</groupId>
  4.             <artifactId>druid-spring-boot-starter</artifactId>
  5.             <version>1.1.10</version>
  6.         </dependency>

1、纯配置文件方式

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

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

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

2、通过配置类配置方式

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

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

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

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

2）配置信息类DruidDataSourceProperties

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

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

  4. /**
  5.  * Druid配置信息类
  6.  *
  7.  * @author
  8.  * @date
  9.  */
  10. @ConfigurationProperties(prefix = "spring.datasource.druid")
  11. public class DruidDataSourceProperties {

  13.     private String driverClassName;
  14.     private String url;
  15.     private String username;
  16.     private String password;

  18.     private int initialSize;
  19.     private int minIdle;
  20.     private int maxActive = 100;
  21.     private long maxWait;
  22.     private long timeBetweenEvictionRunsMillis;
  23.     private long minEvictableIdleTimeMillis;
  24.     private String validationQuery;
  25.     private boolean testWhileIdle;
  26.     private boolean testOnBorrow;
  27.     private boolean testOnReturn;
  28.     private boolean poolPreparedStatements;
  29.     private int maxPoolPreparedStatementPerConnectionSize;

  31.     private String filters;

  33.     public int getInitialSize() {
  34.         return initialSize;
  35.     }

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

  41.     public int getMinIdle() {
  42.         return minIdle;
  43.     }

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

  49.     public int getMaxActive() {
  50.         return maxActive;
  51.     }

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

  57.     public long getMaxWait() {
  58.         return maxWait;
  59.     }

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

  65.     public long getTimeBetweenEvictionRunsMillis() {
  66.         return timeBetweenEvictionRunsMillis;
  67.     }

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

  73.     public long getMinEvictableIdleTimeMillis() {
  74.         return minEvictableIdleTimeMillis;
  75.     }

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

  81.     public String getValidationQuery() {
  82.         return validationQuery;
  83.     }

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

  89.     public boolean isTestWhileIdle() {
  90.         return testWhileIdle;
  91.     }

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

  97.     public boolean isTestOnBorrow() {
  98.         return testOnBorrow;
  99.     }

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

  105.     public boolean isTestOnReturn() {
  106.         return testOnReturn;
  107.     }

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

  113.     public boolean isPoolPreparedStatements() {
  114.         return poolPreparedStatements;
  115.     }

  117.     public void setPoolPreparedStatements(boolean poolPreparedStatements) {
  118.         this.poolPreparedStatements = poolPreparedStatements;
  119.     }

  121.     public int getMaxPoolPreparedStatementPerConnectionSize() {
  122.         return maxPoolPreparedStatementPerConnectionSize;
  123.     }

  125.     public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {
  126.         this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
  127.     }

  129.     public String getFilters() {
  130.         return filters;
  131.     }

  133.     public void setFilters(String filters) {
  134.         this.filters = filters;
  135.     }

  137.     public String getDriverClassName() {
  138.         return driverClassName;
  139.     }

  141.     public void setDriverClassName(String driverClassName) {
  142.         this.driverClassName = driverClassName;
  143.     }

  145.     public String getUrl() {
  146.         return url;
  147.     }

  149.     public void setUrl(String url) {
  150.         this.url = url;
  151.     }

  153.     public String getUsername() {
  154.         return username;
  155.     }

  157.     public void setUsername(String username) {
  158.         this.username = username;
  159.     }

  161.     public String getPassword() {
  162.         return password;
  163.     }

  165.     public void setPassword(String password) {
  166.         this.password = password;
  167.     }

  169. }

3）配置DataSource

类中引入刚才的配置信息类

  1. @Configuration
  2. @EnableConfigurationProperties({DruidDataSourceProperties.class})
  3. public class DataSourceConfig{

  5.     @Autowired
  6.     private DruidDataSourceProperties druidProperties;
  7. }

手动配置相关信息

  1. private void setDruidDataSourceConfig(DruidDataSource druidDataSource) {
  2.         druidDataSource.setDriverClassName(druidProperties.getDriverName);
  3.         druidDataSource.setUrl(druidProperties.getUrl);
  4.         druidDataSource.setUsername(druidProperties.getUsername);
  5.         druidDataSource.setPassword(druidProperties.getPassword);
  6.         druidDataSource.setConnectionInitSqls(new ArrayList<String>(){{add(initSqls);}});
  7.         // 初始化大小，最小，最大
  8.         druidDataSource.setInitialSize(druidProperties.getInitialSize());
  9.         druidDataSource.setMinIdle(druidProperties.getMinIdle());
  10.         druidDataSource.setMaxActive(druidProperties.getMaxActive());
  11.         // 配置获取连接等待超时的时间
  12.         druidDataSource.setMaxWait(druidProperties.getMaxWait());
  13.         // 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
  14.         druidDataSource.setTimeBetweenEvictionRunsMillis(druidProperties.getTimeBetweenEvictionRunsMillis());
  15.         // 配置一个连接在池中最小生存的时间，单位是毫秒
  16.         druidDataSource.setMinEvictableIdleTimeMillis(druidProperties.getMinEvictableIdleTimeMillis());
  17.         druidDataSource.setTestWhileIdle(druidProperties.isTestWhileIdle());
  18.         druidDataSource.setTestOnBorrow(druidProperties.isTestOnBorrow());
  19.         druidDataSource.setTestOnReturn(druidProperties.isTestOnReturn());
  20.         // 打开PSCache，并且指定每个连接上PSCache的大小
  21.         druidDataSource.setPoolPreparedStatements(druidProperties.isPoolPreparedStatements());
  22.         druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(druidProperties.getMaxPoolPreparedStatementPerConnectionSize());
  23.         druidDataSource.setUseGlobalDataSourceStat(false);

  25.                 // 配置慢SQL信息，注意druid.timeBetweenLogStatsMillis为多久记录日志并清空一次信息，与setUseGlobalDataSourceStat互斥
  26.         Properties properties = new Properties();
  27.         properties.setProperty("druid.stat.mergeSql", "true");
  28.         properties.setProperty("druid.stat.slowSqlMillis", "5000");
  29.         properties.setProperty("druid.timeBetweenLogStatsMillis", "100000");
  30.         druidDataSource.setConnectProperties(properties);

  32.         try {
  33.             druidDataSource.setFilters(druidProperties.getFilters());
  34.             druidDataSource.init();
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }

一般情况下，我们采用纯配置文件的方式使用即可。

配置完成后，启动访问http://localhost:8080/druid/index.html

如果配置了访问账号密码，需要登录后查看相关信息

二、扩展

1、Spring类的AOP监控

在以上信息完成完成后，有一项还无法查看，就是Spring监控，是因为Spring监控需要对方法做AOP拦截，需要额外配置。这个功能非常强大并且实用，以下是配置方法

新建druid-bean.xml，放入resource文件夹中

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:aop="http://www.springframework.org/schema/aop" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="
  5.         http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/aop
  8.         http://www.springframework.org/schema/aop/spring-aop.xsd">

  10.     <!-- 配置_Druid和Spring关联监控配置 -->
  11.     <bean id="druid-stat-interceptor"
  12.           class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor"></bean>

  14.     <!-- 方法名正则匹配拦截配置 -->
  15.     <bean id="druid-stat-pointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut"
  16.           scope="prototype">
  17.         <property name="patterns">
  18.             <list>
  19.                 <value>com.sogou.test.*.service.*</value>
  20.             </list>
  21.         </property>
  22.     </bean>

  24.     <aop:config proxy-target-class="true">
  25.         <aop:advisor advice-ref="druid-stat-interceptor"
  26.                      pointcut-ref="druid-stat-pointcut" />
  27.     </aop:config>

  29. </beans>

其中patterns处配置你需要切的位置，比如dao或service层，会对你配置方法进行监控

引入配置

  1. @SpringBootApplication
  2. @ImportResource(locations = { "classpath:druid-bean.xml" })
  3. public class Application {

  5.     public static void main(String[] args) {
  6.         TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
  7.         SpringApplication.run(Application.class, args);
  8.     }

  10. }

配置完成后，即可在Spring监控中查看到对应方法的sql执行信息，可以方便地查看到哪个方法的sql执行有异常情况。

2、日志数据持久化

druid监控的数据，都是存储在缓存中，当应用重启或重新发布时数据会清空，页面上也有两个重置按钮，其中记录日志并重置会将当前日志打印。

当配置了druid.timeBetweenLogStatsMillis参数时，会每隔一段时间记录日志并重置统计信息，会将连接数、SQL信息都打印到日志中，但这样有个缺点是会将这段时间的SQL也打印出来，没有必要，可以通过自定义StatLogger的方式来自定义输出格式。

  1. public class DruidStatLogger extends DruidDataSourceStatLoggerAdapter implements DruidDataSourceStatLogger {

  3.     private static final Log LOG    = LogFactory.getLog(DruidDataSourceStatLoggerImpl.class);

  5.     private Log logger = LOG;

  7.     public DruidStatLogger() {
  8.         this.configFromProperties(System.getProperties());
  9.     }

  11.     public boolean isLogEnable() {
  12.         return logger.isInfoEnabled();
  13.     }

  15.     public void log(String value) {
  16.         logger.info(value);
  17.     }

  19.     @Override
  20.     public void log(DruidDataSourceStatValue druidDataSourceStatValue) {
  21.         if (!isLogEnable()) {
  22.             return;
  23.         }
  24.         Map<String, Object> map = new LinkedHashMap<>();

  26.         map.put("dbType", druidDataSourceStatValue.getDbType());
  27.         map.put("name", druidDataSourceStatValue.getName());
  28.         map.put("activeCount", druidDataSourceStatValue.getActiveCount());

  30.         if (druidDataSourceStatValue.getActivePeak() > 0) {
  31.             map.put("activePeak", druidDataSourceStatValue.getActivePeak());
  32.             map.put("activePeakTime", druidDataSourceStatValue.getActivePeakTime());
  33.         }
  34.         map.put("poolingCount", druidDataSourceStatValue.getPoolingCount());
  35.         if (druidDataSourceStatValue.getPoolingPeak() > 0) {
  36.             map.put("poolingPeak", druidDataSourceStatValue.getPoolingPeak());
  37.             map.put("poolingPeakTime", druidDataSourceStatValue.getPoolingPeakTime());
  38.         }
  39.         map.put("connectCount", druidDataSourceStatValue.getConnectCount());
  40.         map.put("closeCount", druidDataSourceStatValue.getCloseCount());

  42.         if (druidDataSourceStatValue.getWaitThreadCount() > 0) {
  43.             map.put("waitThreadCount", druidDataSourceStatValue.getWaitThreadCount());
  44.         }

  46.         if (druidDataSourceStatValue.getNotEmptyWaitCount() > 0) {
  47.             map.put("notEmptyWaitCount", druidDataSourceStatValue.getNotEmptyWaitCount());
  48.         }

  50.         if (druidDataSourceStatValue.getNotEmptyWaitMillis() > 0) {
  51.             map.put("notEmptyWaitMillis", druidDataSourceStatValue.getNotEmptyWaitMillis());
  52.         }

  54.         if (druidDataSourceStatValue.getLogicConnectErrorCount() > 0) {
  55.             map.put("logicConnectErrorCount", druidDataSourceStatValue.getLogicConnectErrorCount());
  56.         }

  58.         if (druidDataSourceStatValue.getPhysicalConnectCount() > 0) {
  59.             map.put("physicalConnectCount", druidDataSourceStatValue.getPhysicalConnectCount());
  60.         }

  62.         if (druidDataSourceStatValue.getPhysicalCloseCount() > 0) {
  63.             map.put("physicalCloseCount", druidDataSourceStatValue.getPhysicalCloseCount());
  64.         }

  66.         if (druidDataSourceStatValue.getPhysicalConnectErrorCount() > 0) {
  67.             map.put("physicalConnectErrorCount", druidDataSourceStatValue.getPhysicalConnectErrorCount());
  68.         }

  70.         if (druidDataSourceStatValue.getExecuteCount() > 0) {
  71.             map.put("executeCount", druidDataSourceStatValue.getExecuteCount());
  72.         }

  74.         if (druidDataSourceStatValue.getErrorCount() > 0) {
  75.             map.put("errorCount", druidDataSourceStatValue.getErrorCount());
  76.         }

  78.         if (druidDataSourceStatValue.getCommitCount() > 0) {
  79.             map.put("commitCount", druidDataSourceStatValue.getCommitCount());
  80.         }

  82.         if (druidDataSourceStatValue.getRollbackCount() > 0) {
  83.             map.put("rollbackCount", druidDataSourceStatValue.getRollbackCount());
  84.         }

  86.         if (druidDataSourceStatValue.getPstmtCacheHitCount() > 0) {
  87.             map.put("pstmtCacheHitCount", druidDataSourceStatValue.getPstmtCacheHitCount());
  88.         }

  90.         if (druidDataSourceStatValue.getPstmtCacheMissCount() > 0) {
  91.             map.put("pstmtCacheMissCount", druidDataSourceStatValue.getPstmtCacheMissCount());
  92.         }

  94.         if (druidDataSourceStatValue.getStartTransactionCount() > 0) {
  95.             map.put("startTransactionCount", druidDataSourceStatValue.getStartTransactionCount());
  96.             map.put("transactionHistogram", (druidDataSourceStatValue.getTransactionHistogram()));
  97.         }

  99.         if (druidDataSourceStatValue.getConnectCount() > 0) {
  100.             map.put("connectionHoldTimeHistogram", (druidDataSourceStatValue.getConnectionHoldTimeHistogram()));
  101.         }

  103.         if (druidDataSourceStatValue.getClobOpenCount() > 0) {
  104.             map.put("clobOpenCount", druidDataSourceStatValue.getClobOpenCount());
  105.         }

  107.         if (druidDataSourceStatValue.getBlobOpenCount() > 0) {
  108.             map.put("blobOpenCount", druidDataSourceStatValue.getBlobOpenCount());
  109.         }

  111.         if (druidDataSourceStatValue.getSqlSkipCount() > 0) {
  112.             map.put("sqlSkipCount", druidDataSourceStatValue.getSqlSkipCount());
  113.         }
  114.         if (!isLogEnable()) {
  115.             return;
  116.         }
  117.         //Map<String, Object> map = new LinkedHashMap<String, Object>();
  118.         myArrayList<Map<String, Object>> sqlList = new myArrayList<Map<String, Object>>();

  120.         //有执行sql的话 只显示sql语句
  121.         if (druidDataSourceStatValue.getSqlList().size() > 0) {
  122.             for (JdbcSqlStatValue sqlStat : druidDataSourceStatValue.getSqlList()) {
  123.                 Map<String, Object> sqlStatMap = new LinkedHashMap<String, Object>();
  124.                 sqlStatMap.put("执行了sql语句：", sqlStat.getSql());
  125.                 sqlList.add(sqlStatMap);
  126.                 String text = sqlList.toString();
  127.                 //log(text);
  128.             }
  129.         }
  130.         //没有sql语句的话就显示最上面那些
  131.         else{
  132.             String text = map.toString();
  133.             log(text);
  134.         }
  135.     }

  137.     @Override
  138.     public void configFromProperties(Properties properties) {
  139.         String property = properties.getProperty("druid.stat.loggerName");
  140.         if (property != null && property.length() > 0) {
  141.             setLoggerName(property);
  142.         }
  143.     }

  145.     @Override
  146.     public void setLogger(Log log) {
  147.         if (log == null) {
  148.             throw new IllegalArgumentException("logger can not be null");
  149.         }
  150.         this.logger = log;
  151.     }

  153.     @Override
  154.     public void setLoggerName(String loggerName) {
  155.         logger = LogFactory.getLog(loggerName);
  156.     }

  158.     class myArrayList<E> extends ArrayList<E> {
  159.         @Override
  160.         public String toString() {
  161.             Iterator<E> it = iterator();
  162.             if (!it.hasNext()) {
  163.                 return "";
  164.             }

  166.             StringBuilder sb = new StringBuilder();
  167.             for (; ; ) {
  168.                 E e = it.next();
  169.                 sb.append(e == this ? "(this Collection)" : e);
  170.                 if (!it.hasNext()) {
  171.                     return sb.toString();
  172.                 }
  173.                 sb.append(',').append(' ');
  174.             }
  175.         }
  176.     }

DataSource配置

  1. @Configuration
  2. public class DruidConfig {

  4.     @ConfigurationProperties(prefix="spring.datasource")
  5.     @Bean
  6.     public DataSource druidDataSource()
  7.     {
  8.         DruidDataSource dataSource = new DruidDataSource();
  9.         dataSource.setStatLogger(new MyStatLogger());
  10.         return dataSource;
  11.     }

  13.     @Bean
  14.     public ServletRegistrationBean statViewServlet()
  15.     {
  16.         ServletRegistrationBean<StatViewServlet> bean=new ServletRegistrationBean<>(new StatViewServlet(),"/druid/*");

  18.         //后台需要有人登录监控
  19.         HashMap<String,String> initParameters=new HashMap<>();

  21.         //增加配置
  22.         initParameters.put("loginUsername","admin");
  23.         initParameters.put("loginPassword","123456");

  25.         //允许谁能访问
  26.         initParameters.put("allow"," ");

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

  32.     @Bean
  33.     public FilterRegistrationBean webStatFilter()
  34.     {
  35.         FilterRegistrationBean bean=new FilterRegistrationBean();
  36.         bean.setFilter(new WebStatFilter());

  38.         HashMap<String,String> initParameters=new HashMap<>();

  40.         initParameters.put("exclusions","*.js,*.css,/druid/*");

  42.         bean.setInitParameters(initParameters);

  44.         return bean;
  45.     }

  47. }

可以设置每隔24小时记录日志并清空当前数据。

你会用了吗？


数据库
文章转载自重口味码农，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

评论