手写DAO框架（七）-如何保证连接可用

版权声明：本文为博客园博主「水木桶」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://www.cnblogs.com/shuimutong/p/11408219.html

背景

手写DAO框架系列前后更新了5篇文章，外加1篇使用示例，GDAO框架至此已经初具雏形，简单的使用不成问题。接下来就是对框架进行不断的优化。

顺便说一下性能

手写DAO框架（六）-后续之框架使用示例 此篇文章对GDAO的性能较少提及，这里就简单的记载一下，后续有机会再更新。

数据示例：id：14005  name：BatchName-4009  age：52，其中id是自动生成。

数据库是mariadb，和测试程序位于同一台机器

测试数据条数5000条，一次调用

userDao.add(uds[i]);

方法插入一条数据。

系统	配置	结果
macOS	2c4t，8g，固态硬盘	总耗时：8629.0ms，平均耗时：1.726ms
Win10	6c6t，24g，固态硬盘	总耗时：5153.0ms，平均耗时：1.031ms

一、当前问题分析

对于一个提供连接池功能的DAO框架，如果保存的连接失效了无法自动移除池，如果连接数据库的网络出现闪断连接无法继续使用，只能通过重启服务来达到初始化连接的目的，这样的做法显然是不够优雅的。

为了提高框架的稳定性，所以决定对框架的连接部分做一次优化。

二、需求整理

通过网上查资料，拟定了几个点。

1、自动重连

autoReconnect=true

JDBC通过配置可实现

2、连接有效性检测

a、配置连接检测语句。备注：有的数据库Driver支持ping()，可以使用。

3、连接泄露检查

当连接从连接池借出后，长时间（配置时间）不归还，将强制回收。

4、了解到的其他问题

如果连接闲置时间过长，可能被mysql主动关闭。

正常的使用-归还（连接放到队列，队列是先进先出，下次再取，形成一个循环）流程，可避免连接闲置时间过长，暂缓优化。

优化点确定

2、连接有效性检测

3、连接泄露检查

三、编码实现

博主开始写代码了，需要一段时间

连接有效性检测，根据配置来检测，代码参考MysqlValidConnectionChecker。

连接泄露检查，通过启一条线程，根据配置时间进行检查。

----------------------经过了好几天的编写，代码完成了---------------------------------------------

直接上代码。

1、增加配置

#########v03##########

#连接检测语句
checkConnectionValidationQuery=select 1
#归还连接时检测连接,true false

checkConnectionWhenReturn=true
#定时检测连接间隔时长（分钟）
periodCheckConnectionTimeMin=10
#连接泄露检测
connectionLeakCheck=true
#连接泄露检测间隔时长（分钟）
connectionLeakCheckPeriodTimeMin=10
#强制归还连接时长（小时）
forceReturnConnectionTimeHour=6

说明：

1）配置可以分为1个基础，3个部分。

1个基础是指连接检测语句，3个部分分别对应归还连接时检测连接、定时检测连接间隔时长、连接泄露检测

2）定时检测主要是防止连接中断了不能自动生成新的连接，连接间隔时长如果设为0，则不会定时检测。

2、主要代码

 package me.lovegao.gdao.connection;

 import java.sql.Connection;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Properties;
 import java.util.Queue;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;

 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.math.NumberUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import me.lovegao.gdao.bean.SystemConstant;
 import me.lovegao.gdao.util.ConnectionUtil;

 /**
  * 第二版简易连接池实现<br/>
  * 主要增加连接有效性检测，包括归还连接时检测，定时检测连接
  *
  * @author simple
  *
  */
 public class SimpleV2ConnectionPool extends SimpleConnectionPool {
     private final static Logger log = LoggerFactory.getLogger(SimpleV2ConnectionPool.class);
     private ExecutorService ES;
     // 归还连接时检测连接，这步最好做成异步的，避免影响归还速度
     private boolean checkConnectionWhenReturn = false;
     // 连接检测语句
     private String checkConnectionValidationQuery;
     // 定时检测连接的时间（分钟）
     private int periodCheckConnectionTimeMin;
     /** 待检测连接 **/
     private volatile Queue<Connection> TO_CHECK_CONNECTION_POOL;
     //查询超时时间
     private final int QUERY_TIMEOUT_SECONDS;
     //连接泄露检测
     private boolean checkConnectionLeak = false;
     //连接泄露检测间隔时长-分钟
     private int checkConnectionLeakPeriodTimeMin = 30;
     //强制归还连接时长（小时）
     private double forceReturnConnectionTimeHour;
     //连接最大空闲时长（小时）
 //    private double connectionMaxIdleTimeHour;
     /**连接最后借出时间**/
     private Map<Integer, Long> CONNECTION_OUT_TIME_MAP_POOL = null;

     public SimpleV2ConnectionPool(Properties properties) throws Exception {
         super(properties);
         QUERY_TIMEOUT_SECONDS = super.getQueryTimeoutSecond();
         initProp(properties);
         initCheck();
     }

     private void initProp(Properties properties) {
         //连接有效性检测配置
         if (properties.containsKey(SystemConstant.STR_CHECK_CONNECTION_VALIDATION_QUERY)) {
             checkConnectionValidationQuery = properties
                     .getProperty(SystemConstant.STR_CHECK_CONNECTION_VALIDATION_QUERY);
             String checkWhenReturn = properties.getProperty(SystemConstant.STR_CHECK_CONNECTION_WHEN_RETURN);
             if (checkWhenReturn.toLowerCase().equals("true")) {
                 checkConnectionWhenReturn = true;
             }
             if (properties.containsKey(SystemConstant.STR_PERIOD_CHECK_CONNECTION_TIME_MIN)) {
                 String periodTimeStr = properties.getProperty(SystemConstant.STR_PERIOD_CHECK_CONNECTION_TIME_MIN);
                 if (StringUtils.isNumeric(periodTimeStr)) {
                     periodCheckConnectionTimeMin = Integer.parseInt(periodTimeStr);
                 }
             }
         }
         //连接泄露检测配置
         if (properties.containsKey(SystemConstant.STR_CONNECTION_LEAK_CHECK)) {
             String leakCheckStr = properties.getProperty(SystemConstant.STR_CONNECTION_LEAK_CHECK);
             if (leakCheckStr.toLowerCase().equals("true")) {
                 String leakCheckPeriodTimeStr = properties.getProperty(SystemConstant.STR_CONNECTION_LEAK_CHECK_PERIOD_TIME_MIN);
                 if (StringUtils.isNumeric(leakCheckPeriodTimeStr)) {
                     checkConnectionLeakPeriodTimeMin = Integer.parseInt(leakCheckPeriodTimeStr);
                 }
                 String forceReturnTimeStr = properties.getProperty(SystemConstant.STR_FORCE_RETURN_CONNECTION_TIME_HOUR);
                 if (NumberUtils.isNumber(forceReturnTimeStr)) {
                     forceReturnConnectionTimeHour = Double.parseDouble(forceReturnTimeStr);
                     if(forceReturnConnectionTimeHour > 0) {
                         checkConnectionLeak = true;
                     }
                 }
                 //最大空闲检测，功能上和定时检测连接重复，暂时不开发。

                 //需要同时配置（强制归还时间）才能检测连接泄露
                 if(forceReturnConnectionTimeHour > 0) {
                     checkConnectionLeak = true;
                 }
             }
         }
         StringBuilder infoSb = new StringBuilder();
         infoSb.append("SimpleV2ConnectionPoolInitDone------")
             .append(",checkConnectionValidationQuery:").append(checkConnectionValidationQuery)
             .append(",checkConnectionWhenReturn:").append(checkConnectionWhenReturn)
             .append(",periodCheckConnectionTimeMin:").append(periodCheckConnectionTimeMin)
             .append(",checkConnectionLeak:").append(checkConnectionLeak)
             .append(",checkConnectionLeakPeriodTimeMin:").append(checkConnectionLeakPeriodTimeMin)
             .append(",forceReturnConnectionTimeHour:").append(forceReturnConnectionTimeHour);
         System.out.println(infoSb.toString());
     }

     @Override
     public Connection getConnection() throws Exception {
         Connection conn = super.getConnection();
         if(checkConnectionLeak) {
             int connHashCode = conn.hashCode();
             CONNECTION_OUT_TIME_MAP_POOL.put(connHashCode, System.currentTimeMillis());
         }
         return conn;
     }

     @Override
     public void returnConnection(Connection conn) {
         //检测连接泄露
         if(checkConnectionLeak) {
             int connHashCode = conn.hashCode();
             //连接超时过长，已经被主动移除
             if(!CONNECTION_OUT_TIME_MAP_POOL.containsKey(connHashCode)) {
                 return;
             } else {
                 CONNECTION_OUT_TIME_MAP_POOL.remove(connHashCode);
             }
         }
         //检测归还连接
         if (checkConnectionWhenReturn) {
             if(TO_CHECK_CONNECTION_POOL.isEmpty()) {
                 synchronized(TO_CHECK_CONNECTION_POOL) {
                     if(TO_CHECK_CONNECTION_POOL.isEmpty()) {
                         TO_CHECK_CONNECTION_POOL.add(conn);
                         TO_CHECK_CONNECTION_POOL.notifyAll();
                     } else {
                         TO_CHECK_CONNECTION_POOL.add(conn);
                     }
                 }
             } else {
                 TO_CHECK_CONNECTION_POOL.add(conn);
             }
         } else {
             superReturnConnection(conn);
         }
     }

     @Override
     public void closeConnectionPool() {
         if(ES != null) {
             ES.shutdownNow();
         }
         super.closeConnectionPool();
     }

     private void superReturnConnection(Connection conn) {
         super.returnConnection(conn);
     }

     private Connection superGetByConnectionHashCode(int hashCode) {
         return super.getByConnectionHashCode(hashCode);
     }

     // 初始化检查
     private void initCheck() {
         int threadPoolSize = 0;
         if(checkConnectionWhenReturn) {
             threadPoolSize += 2;
             TO_CHECK_CONNECTION_POOL = new ConcurrentLinkedQueue();
         }
         if(periodCheckConnectionTimeMin > 0) {
             threadPoolSize++;
         }
         //需要同时配置（强制归还时间、最大空闲时间）才能检测连接泄露
         if(checkConnectionLeak) {
             threadPoolSize++;
             CONNECTION_OUT_TIME_MAP_POOL = new ConcurrentHashMap();
         }
         if(threadPoolSize > 0) {
             ES = Executors.newFixedThreadPool(threadPoolSize);
             // 检查归还连接
             if(checkConnectionWhenReturn) {
                 //启两个线程同时检测
                 for(int i=0; i<2; i++) {
                     ES.execute(new ReturnConnectionCheck());
                 }
             }
             //定时检测连接
             if (periodCheckConnectionTimeMin > 0) {
                 ES.execute(new ConnectionPeriodCheck());
             }
             //连接泄露检测
             if(checkConnectionLeak) {
                 ES.execute(new ConnectionLeakCheck());
             }
         }
     }

     /**
      * 连接泄露定时检测
      * @author simple
      *
      */
     class ConnectionLeakCheck implements Runnable {
         int sleepTimeMs = checkConnectionLeakPeriodTimeMin * 60 * 1000;
         @Override
         public void run() {
             Set<Integer> preConnHashCodeSet = new HashSet();
             while (true) {
                 if(ES.isShutdown()) {
                     break;
                 }
                 try {
                     Thread.sleep(sleepTimeMs);
                 } catch (Exception e) {
                     log.error("ConnectionLeakCheckSleepException", e);
                 }
                 try {
                     checkConnectionLeak(preConnHashCodeSet);
                 } catch (Exception e) {
                     log.error("ConnectionLeakCheckException", e);
                 }
             }
         }
     }

     //检测连接泄露
     private void checkConnectionLeak(Set<Integer> preConnHashCodeSet) throws Exception {
         if(CONNECTION_OUT_TIME_MAP_POOL.size() < 1) {
             preConnHashCodeSet = new HashSet();
         } else {
             Iterator<Entry<Integer, Long>> connHashCodeIt = CONNECTION_OUT_TIME_MAP_POOL.entrySet().iterator();
             //先对比前后两次的连接，如果有相同的，再检测相同的连接
             if(preConnHashCodeSet.size() == 0) {
                 while(connHashCodeIt.hasNext()) {
                     preConnHashCodeSet.add(connHashCodeIt.next().getKey());
                 }
             } else {
                 StringBuilder logSb = new StringBuilder();
                 long timeFlag = (long) (System.currentTimeMillis() - forceReturnConnectionTimeHour * 3600 * 1000);
                 logSb.append("ConnectionLeakCheck---")
                     .append(",timeFlag:").append(timeFlag)
                     .append(",forceReturnConnectionTimeHour:").append(forceReturnConnectionTimeHour);
                 List<Integer> toCloseConnectionHashCodeList = new ArrayList();
                 logSb.append(",toCloseConn,{");
                 //过滤出两次集合重合，且已经超时的元素
                 while(connHashCodeIt.hasNext()) {
                     Entry<Integer, Long> connEntry = connHashCodeIt.next();
                     int connHashCode = connEntry.getKey();
                     if(preConnHashCodeSet.contains(connHashCode) && connEntry.getValue() < timeFlag) {
                         toCloseConnectionHashCodeList.add(connHashCode);
                         logSb.append(connHashCode).append(":").append(connEntry.getValue()).append(",");
                     }
                 }
                 logSb.append("}");
                 if(toCloseConnectionHashCodeList.size() > 0) {
                     for(Integer connHashCode : toCloseConnectionHashCodeList) {
                         Connection conn = superGetByConnectionHashCode(connHashCode);
                         if(conn != null) {
                             try {
                                 conn.close();
                             } catch (SQLException e) {
                                 log.error("closeConnectionException", e);
                             }
                             CONNECTION_OUT_TIME_MAP_POOL.remove(connHashCode);
                             superReturnConnection(conn);
                         }
                     }
                 }
                 log.info(logSb.toString());
                 //进行过一次检测之后，对之前存储的进行初始化
                 preConnHashCodeSet = new HashSet();
             }
         }
     }

     /**
      * 归还连接检测
      * @author simple
      *
      */
     class ReturnConnectionCheck implements Runnable {
         @Override
         public void run() {
             while (true) {
                 if(ES.isShutdown()) {
                     break;
                 }
                 Connection toCheckConn = TO_CHECK_CONNECTION_POOL.poll();
                 if (toCheckConn == null) {
                     try {
                         synchronized(TO_CHECK_CONNECTION_POOL) {
                             TO_CHECK_CONNECTION_POOL.wait();
                         }
                     } catch (InterruptedException e) {
                         log.error("checkReturnConnectionWaitException", e);
                     }
                 } else {
                     boolean canUse = ConnectionUtil.isValidConnection(toCheckConn, checkConnectionValidationQuery,
                             QUERY_TIMEOUT_SECONDS);
                     if (!canUse) {
                         try {
                             toCheckConn.close();
                         } catch (SQLException e) {
                             log.error("checkReturnConnectionCloseConnException", e);
                         }
                     }
                     superReturnConnection(toCheckConn);
                 }
             }
         }
     }

     /**
      * 连接定时检测
      * @author simple
      *
      */
     class ConnectionPeriodCheck implements Runnable {
         int sleepTimeMs = periodCheckConnectionTimeMin * 60 * 1000;
         @Override
         public void run() {
             while (true) {
                 if(ES.isShutdown()) {
                     break;
                 }
                 try {
                     Thread.sleep(sleepTimeMs);
                 } catch (Exception e) {
                     log.error("checkReturnConnectionSleepException", e);
                 }
                 while(true) {
                     //是否继续检测
                     boolean continueCheck = false;
                     Connection toCheckConn = null;
                     try {
                         toCheckConn = getConnection();
                         if (toCheckConn != null) {
                             boolean canUse = ConnectionUtil.isValidConnection(toCheckConn,
                                     checkConnectionValidationQuery, QUERY_TIMEOUT_SECONDS);
                             if (!canUse) {
                                 toCheckConn.close();
                                 //连接不可用，继续检测其他连接是否正常
                                 continueCheck = true;
                                 log.info("oneConnectionCannotUse,closeIt.....");
                             }
                         }
                     } catch (Exception e) {
                         log.error("checkReturnConnectionException", e);
                         continueCheck = true;
                     } finally {
                         if (toCheckConn != null) {
                             superReturnConnection(toCheckConn);
                         }
                     }
                     if(continueCheck) {
                         log.info("checkOneConnectionCannotUse,beginToCheckOtherConnection....");
                         try {
                             Thread.sleep(500);
                         } catch (InterruptedException e) {
                             log.error("checkReturnConnectionWaitException", e);
                         }
                     } else {
                         break;
                     }
                 }
             }
         }
     }
 }

3、主要思路

1）归还连接时检测连接的思路

归还连接的时候，如果不采用异步，那么归还连接的线程必须等待连接确认完毕之后才能继续执行，这样做感觉性能不是最优的。

所以引入了异步，归还连接时，连接直接放到一个待检测的容器里，不需要等待检测完之后再返回。

待检测连接由检测线程异步进行检测。检测现场从待检测容器里取连接进行检测，必然会出现空的情况。

出现了空的情况怎么做好呢，是在那里自旋等待？是休眠一段时间再检测？还是等待呢？

自旋等待，浪费计算资源；休眠的话，休眠时长不好确定，谁知道下一毫秒会发生什么？万一因为连接未及时检测出现了连接用尽，岂不是很尴尬？

所以，我选择了等待，当线程归还时，主动唤醒等待线程。

代码实现之后，测试的时候，我发现运行报错。wait()、notifyAll()方法不是那样用的，需要获取锁。

添加了锁之后，为了尽量减少同步带来的性能损失，我采取了写单例时经常提到的双重检查：我不需要每次都要拿锁、通知，只需要在待检测连接池是空的时候才需要进行拿锁、通知。、

2）连接泄露检测的思路

连接泄露检测，主要是为了防止连接被借出去之后，很久都没有归还的情景。

很久不归还，这个连接还占着连接池的坑，却没法被复用，所以需要进行检测。

检测需要确定的就是，取出多久算久？然后就是，多久检测一次？

具体实现的时候，还有一个问题，就是强制归还的连接应该怎么归还？直接放回连接池吗？万一连接真的还在被别的线程使用怎么办？

所以这里，我采取先把连接关闭了，然后再归还。

3）定时检测连接的思路

为了保持连接池的连接都是最终可用的，所以需要对连接池的连接进行定时的检测。

如果连接不可用，就把连接关闭，然后从连接池去除。

4、测试代码

1）配置

##驱动名称
driverName=com.mysql.jdbc.Driver
##连接url
connectionUrl=jdbc:mysql://localhost:3306/simple?autoReconnect=true&useServerPrepStmts=false&rewriteBatchedStatements=true&connectTimeout=1000&useUnicode=true&characterEncoding=utf-8
##用户名
userName=simple
##用户密码
userPassword=123456
##初始化连接数
initConnectionNum=10
##最大连接数
maxConnectionNum=50
##最大查询等待时间
maxQueryTime=3
#########v03##########
#归还连接时检测连接,true false
checkConnectionWhenReturn=true
#连接检测语句
checkConnectionValidationQuery=select 1
#定时检测连接间隔时长（分钟）
periodCheckConnectionTimeMin=1
#连接泄露检测
connectionLeakCheck=false
#连接泄露检测间隔时长（分钟）
connectionLeakCheckPeriodTimeMin=1
#强制归还连接时长（小时）
forceReturnConnectionTimeHour=0.01

2）测试代码

package me.lovegao.gdao.connpool;

import java.sql.Connection;
import java.util.Properties;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import me.lovegao.gdao.bean.SystemConstant;
import me.lovegao.gdao.connection.IConnectionPool;
import me.lovegao.gdao.connection.SimpleV2ConnectionPool;

public class V2ConnectionPoolTest {
    private final static Logger log = LoggerFactory.getLogger(V2ConnectionPoolTest.class);

    public static void main(String[] args) throws Exception {
        String dbPath = "mysql2.properties";
        log.info("hello-----------------");
        log.warn("hello-----------------");
        periodCheckConnection(dbPath);
    }

    /**
     * 连接泄露检测
     * @param dbPath
     * @throws Exception
     */
    public static void checkConnectionLeak(String dbPath) throws Exception {
        Properties dbProp = CommonUtil.loadProp(dbPath);
        dbProp.setProperty(SystemConstant.STR_PERIOD_CHECK_CONNECTION_TIME_MIN, "10");
        dbProp.setProperty(SystemConstant.STR_CONNECTION_LEAK_CHECK, "true");
        IConnectionPool connPool = new SimpleV2ConnectionPool(dbProp);
        Connection conn = connPool.getConnection();
        Thread.sleep(240000);
        connPool.returnConnection(conn);
        Thread.sleep(61000);
        connPool.closeConnectionPool();
    }

    /**
     * 连接定时检测
     * @param dbPath
     * @throws Exception
     */
    public static void periodCheckConnection(String dbPath) throws Exception {
        Properties dbProp = CommonUtil.loadProp(dbPath);
        dbProp.setProperty(SystemConstant.STR_PERIOD_CHECK_CONNECTION_TIME_MIN, "1");
        IConnectionPool connPool = new SimpleV2ConnectionPool(dbProp);
        Thread.sleep(120000);
        Connection conn = connPool.getConnection();
        connPool.returnConnection(conn);
        Thread.sleep(2061000);
//        connPool.closeConnectionPool();
    }

    /**
     * 归还连接检测
     * @param dbPath
     * @throws Exception
     */
    public static void checkWhenReturn(String dbPath) throws Exception {
        Properties dbProp = CommonUtil.loadProp(dbPath);
        IConnectionPool connPool = new SimpleV2ConnectionPool(dbProp);
        Connection conn = connPool.getConnection();
        conn.close();
        connPool.returnConnection(conn);
        Thread.sleep(20000);
        connPool.closeConnectionPool();
    }

}

我是分布执行的测试，通过debug来校验的流程，面对这种项目，不知道单测该如何写。

我是通过中间把数据库关了，又打开，来连接定时检测的。结果证明没有问题。

框架优化版本已提交到git：https://github.com/shuimutong/gdao.git，欢迎指点

相关测试代码：https://github.com/shuimutong/useDemo.git  ./gdao-demo下。

-----------------------本文完------------------------------