1.Druid提供的校验参数
Druid对于连接校验提供了六个参数，其中testOnBorrow、testOnReturn、testWhileIdle是Druid所提供的连接校验时点，其余三个参数为校验的相关配置。
配置 | 缺省值 | 说明 |
validationQuery | 用来检测连接是否有效的sql，要求是一个查询语句，常用select ‘x’。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。 | |
validationQueryTimeout | 单位：秒，检测连接是否有效的超时时间。底层调用jdbc Statement对象的void setQueryTimeout(int seconds)方法 | |
testOnBorrow | false | 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 |
testOnReturn | false | 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 |
testWhileIdle | true | 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 |
timeBetweenEvictionRunsMillis | 1分钟 | 有两个含义： (1) Destroy线程会检测连接的间隔时间，如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。 (2) testWhileIdle的判断依据，详细看testWhileIdle属性的说明 |
2. Druid是如何进行连接校验的？
Druid依靠testConnectionInternal方法进行连接校验，如果当前连接池存在validConnectionChecker，则会利用validConnectionChecker进行校验，否则将利用一些内部状态以及执行校验SQL的方式进行探活，主要的校验方式都是以执行校验SQL进行校验，而MySQL可以使用PingMethod校验连接的有效性。
/**
* 校验连接是否有效
* @param holder
* @param conn
* @return
*/
protected boolean testConnectionInternal(DruidConnectionHolder holder, Connection conn) {
//此部分似乎是为了做监控用的
String sqlFile = JdbcSqlStat.getContextSqlFile();
String sqlName = JdbcSqlStat.getContextSqlName();
if (sqlFile != null) {
JdbcSqlStat.setContextSqlFile(null);
}
if (sqlName != null) {
JdbcSqlStat.setContextSqlName(null);
}
try {
//判断当前连接池所持有的检查器是否为空
if (validConnectionChecker != null) {
//调用检查器的教研方法进行教研
boolean valid = validConnectionChecker.isValidConnection(conn, validationQuery, validationQueryTimeout);
long currentTimeMillis = System.currentTimeMillis();
//设置相关的监控参数
if (holder != null) {
holder.lastValidTimeMillis = currentTimeMillis;
holder.lastExecTimeMillis = currentTimeMillis;
}
//如果校验通过并且是MySQL的情况下
if (valid && isMySql) { // unexcepted branch
//获得MySQL服务器中这个会话最后一次执行语句时间
long lastPacketReceivedTimeMs = MySqlUtils.getLastPacketReceivedTimeMs(conn);
//如果这个值>0，即工具类返回正常结果的情况下
if (lastPacketReceivedTimeMs > 0) {
//获得MySQL的空闲时间
long mysqlIdleMillis = currentTimeMillis - lastPacketReceivedTimeMs;
//如果服务端空闲时间>timeBetweenEvictionRunsMillis，则丢弃该连接，此时校验失败
if (lastPacketReceivedTimeMs > 0 //
&& mysqlIdleMillis >= timeBetweenEvictionRunsMillis) {
discardConnection(holder);
String errorMsg = "discard long time none received connection. "
+ ", jdbcUrl : " + jdbcUrl
+ ", version : " + VERSION.getVersionNumber()
+ ", lastPacketReceivedIdleMillis : " + mysqlIdleMillis;
LOG.warn(errorMsg);
return false;
}
}
}
//如果校验成功，并且连接池中其他连接发生过异常
if (valid && onFatalError) {
//加锁并且重置状态
lock.lock();
try {
if (onFatalError) {
onFatalError = false;
}
} finally {
lock.unlock();
}
}
//返回校验结果
return valid;
}
//判断当前连接是否被关闭(DruidPooledConnection内部状态)，如果关闭则连接无效
if (conn.isClosed()) {
return false;
}
//如果当前没有配置校验语句，则认为该连接有效
if (null == validationQuery) {
return true;
}
Statement stmt = null;
ResultSet rset = null;
try {
//创建语句对象
stmt = conn.createStatement();
//设置该语句超时响应时间，如果没有配置则不进行操作
if (getValidationQueryTimeout() > 0) {
stmt.setQueryTimeout(validationQueryTimeout);
}
//执行校验语句
rset = stmt.executeQuery(validationQuery);
//如果没有返回结果，则校验失败，连接失效
if (!rset.next()) {
return false;
}
} finally {
//关闭校验时所创建的语句和返回对象
JdbcUtils.close(rset);
JdbcUtils.close(stmt);
}
//判断致命异常状态并重置
if (onFatalError) {
lock.lock();
try {
if (onFatalError) {
onFatalError = false;
}
} finally {
lock.unlock();
}
}
//如果上方分支都不存在问题，则该链接有效
return true;
} catch (Throwable ex) {
// skip
return false;
} finally {
if (sqlFile != null) {
JdbcSqlStat.setContextSqlFile(sqlFile);
}
if (sqlName != null) {
JdbcSqlStat.setContextSqlName(sqlName);
}
}
}2.1 validConnectionChecker
validConnectionChecker是Druid针对不同数据库所提供不同的检查器，是ValidConnectionChecker接口的实现类，默认提供MySql、ORACLE、SQL_SERVER、POSTGRESQL以及OCEANBASE的检查器，这些检查器中提供了默认的validationQuery，用于在没有配置validationQuery的时候进行处理。
这些检查器将在连接池初始化的时候被自动识别加载。
public void init() throws SQLException {
...省略部分代码...
initExceptionSorter();
//调用方法初始化连接检查器
initValidConnectionChecker();
validationQueryCheck();
...省略部分代码...
}Druid通过驱动类名进行判断，自动识别对应的检查器。
private void initValidConnectionChecker() {
//如果已经设置过检查器，则不继续执行
if (this.validConnectionChecker != null) {
return;
}
//获得当前驱动的类名
String realDriverClassName = driver.getClass().getName();
//对不同类型数据库进行判断并设置对应的检查器
if (JdbcUtils.isMySqlDriver(realDriverClassName)) {
this.validConnectionChecker = new MySqlValidConnectionChecker(usePingMethod);
} else if (realDriverClassName.equals(JdbcConstants.ORACLE_DRIVER)
|| realDriverClassName.equals(JdbcConstants.ORACLE_DRIVER2)) {
this.validConnectionChecker = new OracleValidConnectionChecker();
} else if (realDriverClassName.equals(JdbcConstants.SQL_SERVER_DRIVER)
|| realDriverClassName.equals(JdbcConstants.SQL_SERVER_DRIVER_SQLJDBC4)
|| realDriverClassName.equals(JdbcConstants.SQL_SERVER_DRIVER_JTDS)) {
this.validConnectionChecker = new MSSQLValidConnectionChecker();
} else if (realDriverClassName.equals(JdbcConstants.POSTGRESQL_DRIVER)
|| realDriverClassName.equals(JdbcConstants.ENTERPRISEDB_DRIVER)
|| realDriverClassName.equals(JdbcConstants.POLARDB_DRIVER)) {
this.validConnectionChecker = new PGValidConnectionChecker();
} else if (realDriverClassName.equals(JdbcConstants.OCEANBASE_DRIVER)
|| (realDriverClassName.equals(JdbcConstants.OCEANBASE_DRIVER2))) {
DbType dbType = DbType.of(this.dbTypeName);
this.validConnectionChecker = new OceanBaseValidConnectionChecker(dbType);
}
}2.2 独特的MySqlValidConnectionChecker
在MySQL检查器中，存在一个特殊的属性usePingMethod，如果开启了这个属性，MySQL检查器将不会通过执行SQL的方式对连接进行校验，而是会通过MySQL所提供的pingInternal方法发送ping进行校验，该属性通过连接池中的属性进行传递，默认为false，且暂不支持参数配置，需要自行调用set方法进行设置。
public class MySqlValidConnectionChecker extends ValidConnectionCheckerAdapter implements ValidConnectionChecker, Serializable {
public static final int DEFAULT_VALIDATION_QUERY_TIMEOUT = 1;
public static final String DEFAULT_VALIDATION_QUERY = "SELECT 1";
private static final long serialVersionUID = 1L;
private static final Log LOG = LogFactory.getLog(MySqlValidConnectionChecker.class);
private Class<?> clazz;
private Method ping;
private boolean usePingMethod = false;
public MySqlValidConnectionChecker(boolean usePingMethod){
try {
//通过反射的方式获得pingInternal的实例
clazz = Utils.loadClass("com.mysql.jdbc.MySQLConnection");
if (clazz == null) {
clazz = Utils.loadClass("com.mysql.cj.jdbc.ConnectionImpl");
}
if (clazz != null) {
ping = clazz.getMethod("pingInternal", boolean.class, int.class);
}
//如果没有加载成功的话，则依旧会使用SQL进行校验
if (ping != null && usePingMethod == true) {
this.usePingMethod = true;
}
} catch (Exception e) {
LOG.warn("Cannot resolve com.mysql.jdbc.Connection.ping method. Will use 'SELECT 1' instead.", e);
}
configFromProperties(System.getProperties());
}
public boolean isValidConnection(Connection conn, String validateQuery, int validationQueryTimeout) throws Exception {
if (conn.isClosed()) {
return false;
}
//判断是否使用ping进行校验
if (usePingMethod) {
if (conn instanceof DruidPooledConnection) {
conn = ((DruidPooledConnection) conn).getConnection();
}
if (conn instanceof ConnectionProxy) {
conn = ((ConnectionProxy) conn).getRawObject();
}
//判断连接对象和连接对象的关系是否可以转化(是一样的类/接口或超类/超接口)
if (clazz.isAssignableFrom(conn.getClass())) {
if (validationQueryTimeout <= 0) {
validationQueryTimeout = DEFAULT_VALIDATION_QUERY_TIMEOUT;
}
try {
//执行方法进行校验
ping.invoke(conn, true, validationQueryTimeout * 1000);
} catch (InvocationTargetException e) {
Throwable cause = e.getCause();
if (cause instanceof SQLException) {
throw (SQLException) cause;
}
throw e;
}
return true;
}
}
String query = validateQuery;
if (validateQuery == null || validateQuery.isEmpty()) {
query = DEFAULT_VALIDATION_QUERY;
}
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
if (validationQueryTimeout > 0) {
stmt.setQueryTimeout(validationQueryTimeout);
}
rs = stmt.executeQuery(query);
return true;
} finally {
JdbcUtils.close(rs);
JdbcUtils.close(stmt);
}
}
}3. testWhileIdle的校验时点
testOnBorrow、testOnReturn两者分别在获得连接/归还连接时进行校验，无特殊内容。
如果以字面意思来看，将会有一个线程或定时器判断链接是否空闲一段时间(timeBetweenEvictionRunsMillis)，实际这个时点却是在获得链接时进行的判断。
由于testOnBorrow和testWhileIdle都是检查连接有效性，testOnBorrow是每次获取连接必定检查，testWhileIdle是超过一定时间才检查，所以当开启testOnBorrow时，testWhileIdle将不会执行。
public DruidPooledConnection getConnectionDirect(long maxWaitMillis) throws SQLException {
int notFullTimeoutRetryCnt = 0;
for (;;) {
// handle notFullTimeoutRetry
DruidPooledConnection poolableConnection;
try {
poolableConnection = getConnectionInternal(maxWaitMillis);
} catch (GetConnectionTimeoutException ex) {
if (notFullTimeoutRetryCnt <= this.notFullTimeoutRetryCount && !isFull()) {
notFullTimeoutRetryCnt++;
if (LOG.isWarnEnabled()) {
LOG.warn("get connection timeout retry : " + notFullTimeoutRetryCnt);
}
continue;
}
throw ex;
}
//如果开启了testOnBorrow，则每次获得连接时都执行一次校验
if (testOnBorrow) {
boolean validate = testConnectionInternal(poolableConnection.holder, poolableConnection.conn);
if (!validate) {
if (LOG.isDebugEnabled()) {
LOG.debug("skip not validate connection.");
}
discardConnection(poolableConnection.holder);
continue;
}
} else {
//判断连接是否被关闭，如果被关闭，则销毁当前连接(此时Holder应该为空)
if (poolableConnection.conn.isClosed()) {
discardConnection(poolableConnection.holder); // 传入null，避免重复关闭
continue;
}
//如果开启了testWhileIdle，判断当前连接是空闲了所配置的时间，如果没有则不进行校验
if (testWhileIdle) {
//得到当前连接的持有者，便于获得统计信息
final DruidConnectionHolder holder = poolableConnection.holder;
long currentTimeMillis = System.currentTimeMillis();
//得到当前连接上次的活跃时间、上次的执行时间、上次校验存活的时间(归还连接时)
long lastActiveTimeMillis = holder.lastActiveTimeMillis;
long lastExecTimeMillis = holder.lastExecTimeMillis;
long lastKeepTimeMillis = holder.lastKeepTimeMillis;
//如果开启了checkExecuteTime参数，并且最后执行时间与最后活跃时间不一致，则认为最后的活跃时间是执行时间
if (checkExecuteTime
&& lastExecTimeMillis != lastActiveTimeMillis) {
lastActiveTimeMillis = lastExecTimeMillis;
}
//最后校验存活时间大于上次活跃时间，则取最后校验存活时间
if (lastKeepTimeMillis > lastActiveTimeMillis) {
lastActiveTimeMillis = lastKeepTimeMillis;
}
//空闲时间=当前时间-上次活跃时间
long idleMillis = currentTimeMillis - lastActiveTimeMillis;
//获得timeBetweenEvictionRunsMillis参数
long timeBetweenEvictionRunsMillis = this.timeBetweenEvictionRunsMillis;
//如果没有配置这个参数，取默认值，60000ms，即1分钟
if (timeBetweenEvictionRunsMillis <= 0) {
timeBetweenEvictionRunsMillis = DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
}
//如果空闲时间超过了timeBetweenEvictionRunsMillis或者空闲时间小于0(此时可能发生时钟回拨等问题?)
if (idleMillis >= timeBetweenEvictionRunsMillis
|| idleMillis < 0 // unexcepted branch
) {
//校验链接状态
boolean validate = testConnectionInternal(poolableConnection.holder, poolableConnection.conn);
if (!validate) {
if (LOG.isDebugEnabled()) {
LOG.debug("skip not validate connection.");
}
discardConnection(poolableConnection.holder);
continue;
}
}
}
}
if (removeAbandoned) {
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
poolableConnection.connectStackTrace = stackTrace;
poolableConnection.setConnectedTimeNano();
poolableConnection.traceEnable = true;
activeConnectionLock.lock();
try {
activeConnections.put(poolableConnection, PRESENT);
} finally {
activeConnectionLock.unlock();
}
}
if (!this.defaultAutoCommit) {
poolableConnection.setAutoCommit(false);
}
return poolableConnection;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
