druid报错 discard long time none received connection

问题背景

在项目启动时出现大量

  c.a.d.pool.DruidAbstractDataSource: discard long time none received connection.
明显是Druid管理的数据库连接由于太长时间没有收到数据库发来的数据，把连接给回收掉了，这导致服务在启动时由于要重复创建连接让服务启动时间延长。
定位原因

根据错误信息，找到Druid源码
com.alibaba.druid.pool.DruidAbstractDataSource#testConnectionInternal(com.alibaba.druid.pool.DruidConnectionHolder, java.sql.Connection)

1. if (validConnectionChecker != null) {
2.         // 验证连接的有效性 mysql下实际调用代码在下面那块
3.         boolean valid = validConnectionChecker.isValidConnection(conn, validationQuery, validationQueryTimeout);
4.         long currentTimeMillis = System.currentTimeMillis();
5.     if (holder != null) {
6.         holder.lastValidTimeMillis = currentTimeMillis;
7.         holder.lastExecTimeMillis = currentTimeMillis;
8.     }
10.     if (valid && isMySql) { // unexcepted branch
11.         long lastPacketReceivedTimeMs = MySqlUtils.getLastPacketReceivedTimeMs(conn);
12.         if (lastPacketReceivedTimeMs > 0) {
13.             long mysqlIdleMillis = currentTimeMillis - lastPacketReceivedTimeMs;
14.             if (lastPacketReceivedTimeMs > 0 //
15.                     && mysqlIdleMillis >= timeBetweenEvictionRunsMillis) {
16.                 discardConnection(holder);
17.                 // 警告信息位置
18.                 String errorMsg = "discard long time none received connection. "
19.                         + ", jdbcUrl : " + jdbcUrl
20.                         + ", version : " + VERSION.getVersionNumber()
21.                         + ", lastPacketReceivedIdleMillis : " + mysqlIdleMillis;
22.                 LOG.warn(errorMsg);
23.                 return false;
24.             }
25.         }
26.     }
27.     // ... 省略
28. }
31. // com.alibaba.druid.pool.vendor.MySqlValidConnectionChecker#isValidConnection
32.     public boolean isValidConnection(Connection conn, String validateQuery, int validationQueryTimeout) throws Exception {
33.         if (conn.isClosed()) {
34.             return false;
35.         }
37.         if (usePingMethod) {
38.                 // 以ping的方式检测连接的有效性
39.             if (conn instanceof DruidPooledConnection) {
40.                 conn = ((DruidPooledConnection) conn).getConnection();
41.             }
43.             if (conn instanceof ConnectionProxy) {
44.                 conn = ((ConnectionProxy) conn).getRawObject();
45.             }
47.             if (clazz.isAssignableFrom(conn.getClass())) {
48.                 if (validationQueryTimeout <= 0) {
49.                     validationQueryTimeout = DEFAULT_VALIDATION_QUERY_TIMEOUT;
50.                 }
52.                 try {
53.                     ping.invoke(conn, true, validationQueryTimeout * 1000);
54.                 } catch (InvocationTargetException e) {
55.                     Throwable cause = e.getCause();
56.                     if (cause instanceof SQLException) {
57.                         throw (SQLException) cause;
58.                     }
59.                     throw e;
60.                 }
61.                 return true;
62.             }
63.         }
65.         String query = validateQuery;
66.         if (validateQuery == null || validateQuery.isEmpty()) {
67.                 // 以 sql SELECT 1 的方式验证连接有效性
68.             query = DEFAULT_VALIDATION_QUERY;
69.         }
71.         Statement stmt = null;
72.         ResultSet rs = null;
73.         try {
74.             stmt = conn.createStatement();
75.             if (validationQueryTimeout > 0) {
76.                 stmt.setQueryTimeout(validationQueryTimeout);
77.             }
78.             rs = stmt.executeQuery(query);
79.             return true;
80.         } finally {
81.             JdbcUtils.close(rs);
82.             JdbcUtils.close(stmt);
83.         }
85.     }
86. }

复制代码

这是调用 testConnectionInternal方法的上层.

可以看到，由于我们开启了testOnBorrow 开关，以是数据库连接会在申请乐成后，立即进行一次测试，然后根据数据库连接的最后一次心跳时间，判断是否闲置过长要丢弃掉该数据库连接。
该开关主要在从连接池获取时立即查抄连接的有效性。
而不开启testOnBorrow则会在保持连接过程中不断查抄连接的闲置环境，对闲置过长的连接回收。
com.alibaba.druid.util.MySqlUtils#getLastPacketReceivedTimeMs 这个方法会返回连接最后一次收到消息的时间.

1. // 以mysql6的 com.mysql.cj.jdbc.ConnectionImpl 为栗子
2. // getLastPacketReceivedTimeMs 方法中获取链接时间的实际方法
3. public long getIdleFor() {
4.      return this.lastQueryFinishedTime == 0 ? 0 : System.currentTimeMillis() - this.lastQueryFinishedTime;
5. }
7. // com.mysql.cj.NativeSession#execSQL
8.     public <T extends Resultset> T execSQL(Query callingQuery, String query, int maxRows, NativePacketPayload packet, boolean streamResults,
9.             ProtocolEntityFactory<T, NativePacketPayload> resultSetFactory, ColumnDefinition cachedMetadata, boolean isBatch) {
11.         long queryStartTime = this.gatherPerfMetrics.getValue() ? System.currentTimeMillis() : 0;
12.         int endOfQueryPacketPosition = packet != null ? packet.getPosition() : 0;
14.         this.lastQueryFinishedTime = 0; // we're busy!
16.         if (this.autoReconnect.getValue() && (getServerSession().isAutoCommit() || this.autoReconnectForPools.getValue()) && this.needsPing && !isBatch) {
17.             try {
18.                 ping(false, 0);
19.                 this.needsPing = false;
21.             } catch (Exception Ex) {
22.                 invokeReconnectListeners();
23.             }
24.         }
26.         try {
27.             return packet == null
28.                     ? ((NativeProtocol) this.protocol).sendQueryString(callingQuery, query, this.characterEncoding.getValue(), maxRows, streamResults,
29.                             cachedMetadata, resultSetFactory)
30.                     : ((NativeProtocol) this.protocol).sendQueryPacket(callingQuery, packet, maxRows, streamResults, cachedMetadata, resultSetFactory);
32.         } catch (CJException sqlE) {
33.             if (getPropertySet().getBooleanProperty(PropertyKey.dumpQueriesOnException).getValue()) {
34.                 String extractedSql = NativePacketPayload.extractSqlFromPacket(query, packet, endOfQueryPacketPosition,
35.                         getPropertySet().getIntegerProperty(PropertyKey.maxQuerySizeToLog).getValue());
36.                 StringBuilder messageBuf = new StringBuilder(extractedSql.length() + 32);
37.                 messageBuf.append("\n\nQuery being executed when exception was thrown:\n");
38.                 messageBuf.append(extractedSql);
39.                 messageBuf.append("\n\n");
40.                 sqlE.appendMessage(messageBuf.toString());
41.             }
43.             if ((this.autoReconnect.getValue())) {
44.                 if (sqlE instanceof CJCommunicationsException) {
45.                     // IO may be dirty or damaged beyond repair, force close it.
46.                     this.protocol.getSocketConnection().forceClose();
47.                 }
48.                 this.needsPing = true;
49.             } else if (sqlE instanceof CJCommunicationsException) {
50.                 invokeCleanupListeners(sqlE);
51.             }
52.             throw sqlE;
54.         } catch (Throwable ex) {
55.             if (this.autoReconnect.getValue()) {
56.                 if (ex instanceof IOException) {
57.                     // IO may be dirty or damaged beyond repair, force close it.
58.                     this.protocol.getSocketConnection().forceClose();
59.                 } else if (ex instanceof IOException) {
60.                     invokeCleanupListeners(ex);
61.                 }
62.                 this.needsPing = true;
63.             }
64.             throw ExceptionFactory.createException(ex.getMessage(), ex, this.exceptionInterceptor);
66.         } finally {
67.                 // 需要开启数据库连接的jdbc参数 maintainTimeStats=true
68.             if (this.maintainTimeStats.getValue()) {
69.                     // 连接的最后查询时间被更新
70.                 this.lastQueryFinishedTime = System.currentTimeMillis();
71.             }
73.             if (this.gatherPerfMetrics.getValue()) {
74.                 ((NativeProtocol) this.protocol).getMetricsHolder().registerQueryExecutionTime(System.currentTimeMillis() - queryStartTime);
75.             }
76.         }
77.     }

复制代码

办理

通过源码分析，就大抵清楚问题的原因。
druid会从数据库获取一批连接持有在当地，以便快速利用。
为了查抄连接的可用（如连接超时被数据库回收了，网络非常等），以是当开启testOnBorrow开关后，会在客户端从druid获取连接时进行闲置连接查抄。
而闲置查抄时比较连接当前时间与最后一次执行sql的时间的差值。
我们的服务在启动时没有进行数据查询，而且连接保活维持是通过ping的方式，以是当启动时间超过之前设置的15s后，再利用最开始池化的数据库借入连接时检测不外而抛出文章开头的非常信息。
我们可以通过调大闲置连接剔除时间和保活时间，让连接闲置能够撑过服务启动的无数据查询时间。
此外，假如服务的活泼环境很低，也就是执行sql的频率很低，可以设置环境变量druid.mysql.usePingMethod为false，让druid以执行SELECT 1sql的方式来保活连接，如此就会顺带刷新getLastPacketReceivedTimeMs属性。

1. // com.alibaba.druid.pool.vendor.MySqlValidConnectionChecker#configFromProperties
2.     public void configFromProperties(Properties properties) {
3.         if (properties == null) {
4.             return;
5.         }
7.         String property = properties.getProperty("druid.mysql.usePingMethod");
8.         if ("true".equals(property)) {
9.             setUsePingMethod(true);
10.         } else if ("false".equals(property)) {
11.             setUsePingMethod(false);
12.         }
13.     }

复制代码

当然通过源码尚有其他方式，可以自行发现。

1. spring:
2.         datasource:
3.                 druid:
4.                         # 让底层的jdbc维护连接的状态的时间
5.                         url: jdck:mysql://xxx?maintainTimeStats=true
6.                         # 连接闲置剔除时间
7.                       time-between-eviction-runs-millis: 300000
8.                       # 必须大于 time-between-eviction-runs-millis 时间
9.                       keep-alive-between-time-millis: 450000

复制代码

1.         // 启动代码添加系统属性
2.         // 或者通过 -Ddruid.mysql.usePingMethod=false 的命令参数
3.         // 或者通过环境变量
4.     public static void main(String[] args) {
5.         Properties properties = System.getProperties();
6.         // 用 select 1 替换 ping 来检测连接保活
7.         properties.setProperty("druid.mysql.usePingMethod", "false");
9.         SpringApplication.run(App.class, args);
10.     }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。