建立資料庫連線是一個比較消耗效能的操作，同時在併發量較大的情況下建立過多的連線對伺服器形成巨大的壓力。對於資源的頻繁分配﹑釋放所造成的問題，使用連線池技術是一種比較好的解決方式。

在Java中，連線池已經有很多開源實現了，在這裡使用commons-dbcp2這個包來

建立JDBC連線池：

public final class JDBCUtil{
    private static DataSource myDataSource=null;
    private JDBCUtil(){
    }
    static {
        try{
            Properties pro=new Properties();
            InputStream is=JDBCUtil.class.getClassLoader().getResourceAsStream("mysqlPoolConf.properties");
            pro.load(is);
            myDataSource=BasicDataSourceFactory.createDataSource(pro);
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }
    public static Connection getConnection()throws SQLException{
        return myDataSource.getConnection();
    }
    public static void close(Connection conn){
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}
 

使用很簡單：

(1)    建立DataSource物件例項myDataSource

(2)    通過myDataSource的getConnection()方法獲得資料庫連線並使用

(3)    用完後呼叫連線close()方法來歸還連線。

當然，這人我們不禁心存疑問，呼叫連線close()方法不是不是將連線關閉了嗎？那連接回到連線池又是怎麼實現的？一起來跟著原始碼看看連線池的實現過程：

首先是連線池配置檔案mysqlPoolConf.properties：

為連線池的一些屬性配置，這裡只列舉了一些常用的：

#連線設定
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://172.16.20.242:3306/test?characterEncoding=utf8
username=root
password=123456
#<!-- 初始化連線 -->
initialSize=20
#<!-- 最大空閒連線 -->
maxIdle=20
#<!-- 最小空閒連線 -->
minIdle=5
#最大連線數量
maxActive=100
#是否在自動回收超時連線的時候列印連線的超時錯誤
logAbandoned=true
#是否自動回收超時連線
removeAbandoned=true
#超時時間(以秒數為單位)
#設定超時時間有一個要注意的地方，超時時間=現在的時間-程式中建立Connection的時間，如果 maxActive比較大，比如超過100，那麼removeAbandonedTimeout可以設定長一點比如180，也就是三分鐘無響應的連線進行回收，當然應用的不同設定長度也不同。
removeAbandonedTimeout=180
#<!-- 超時等待時間以毫秒為單位 -->
#maxWait代表當Connection用盡了，多久之後進行回收丟失連線
maxWait=1000
 

跟隨原始碼看看連線池的實現邏輯：

BasicDataSourceFactory為一個工廠類，在呼叫它的方法createDataSource(Properties properties)時，通過createDataSource()建立了一個PoolingDataSource物件的例項

createDataSource()原始碼如下，我在原始碼中加了一部分註釋：

protected DataSource createDataSource() throws SQLException {
    if (closed) {
        throw new SQLException("Data source is closed");
    }
    // Return the pool if we have already created it
    // This is double-checked locking. This is safe since dataSource is
    // volatile and the code is targeted at Java 5 onwards.
    if (dataSource != null) {//檢查dataSource是否已經關閉
        return dataSource;
    }
    synchronized (this) {//同步程式碼塊，避免多個執行緒來同時建立連線池
        //如果dataSource已經建立，直接返回, 由於同步程式碼塊需要獲得鎖，
            //可能其他執行緒已經建立了dataSource，再釋放鎖，
        //因此，在獲得鎖之後還需要再判斷一下,這一點在平時程式設計中容易忽略。
        if (dataSource != null) {
            return dataSource;
        }
        jmxRegister();//jmx註冊，不影響整體流程
        // create factory which returns raw physical connections
        //呼叫createConnectionFactory()建立JDBC連線工廠driverConnectionFactory，這個工廠使用資料庫驅動來建立最底層的JDBC連線(即物理連線)
        ConnectionFactory driverConnectionFactory = createConnectionFactory();
        // Set up the poolable connection factory
        //呼叫createConnectionPool()建立資料來源使用的連線池，連線池顧名思義就是快取JDBC連線的地方。
        boolean success = false;
        PoolableConnectionFactory poolableConnectionFactory;//連線池工廠，儲存了一系列的狀態資訊 和 JDBC連線工廠
        try {
            poolableConnectionFactory = createPoolableConnectionFactory(driverConnectionFactory);
            poolableConnectionFactory.setPoolStatements(poolPreparedStatements);
            poolableConnectionFactory.setMaxOpenPrepatedStatements(maxOpenPreparedStatements);
            success = true;
        } catch (SQLException se) {
            throw se;
        } catch (RuntimeException rte) {
            throw rte;
        } catch (Exception ex) {
            throw new SQLException("Error creating connection factory", ex);
        }
        if (success) {
            // create a pool for our connections
            //建立 GenericObjectPool<PoolableConnection>類的例項
            //GenericObjectPool是apach-commons-pool包的一個通用物件池類，其建構函式引數是一個物件工廠例項
            createConnectionPool(poolableConnectionFactory);
        }
        // Create the pooling data source to manage connections
        DataSource newDataSource; 
        success = false;
        try {
            newDataSource = createDataSourceInstance();//建立了一個PoolingDataSource的例項
            newDataSource.setLogWriter(logWriter);
            success = true;
        } catch (SQLException se) {
            throw se;
        } catch (RuntimeException rte) {
            throw rte;
        } catch (Exception ex) {
            throw new SQLException("Error creating datasource", ex);
        } finally {
            if (!success) {
                closeConnectionPool();
            }
        }
        // If initialSize > 0, preload the pool
        try {
            for (int i = 0 ; i < initialSize ; i++) {
                connectionPool.addObject();//初始化initialSize個JDBC連線
            }
        } catch (Exception e) {
            closeConnectionPool();
            throw new SQLException("Error preloading the connection pool", e);
        }
        // If timeBetweenEvictionRunsMillis > 0, start the pool's evictor task
        startPoolMaintenance();
        dataSource = newDataSource;
        return dataSource;
    }
}
 

在這一步建立了一個池化連線類工廠的例項，真正的連線是由這個工廠建立並放入連線池，GenericObjectPool是連線池的具體管理者，它是在commons-pool2這個包中實現的一個通用的物件池，GenericObjectPool負責連線池的管理(包括初始化連線，將多餘的空閒連線關閉等)。之後，在使用需要使用資料庫的Connection的時候，通過PoolingDataSource的getConnection() 方法獲得一個連線，getConnection()方法實現如下：

public Connection getConnection() throws SQLException {
    try {
        //_pool是在BasicDataSource建立的GenericObjectPool<PoolableConnection> connectionPool這個例項
        C conn = _pool.borrowObject();//從JDBC連線池中獲得一個JDBC連線
        if (conn == null) {
            return null;
        }
        //PoolGuardConnectionWrapper是DBCP對JDBC Connection這個類的一個封裝
        return new PoolGuardConnectionWrapper<>(conn);
    } catch(SQLException e) {
        throw e;
    } catch(NoSuchElementException e) {
        throw new SQLException("Cannot get a connection, pool error " + e.getMessage(), e);
    } catch(RuntimeException e) {
        throw e;
    } catch(Exception e) {
        throw new SQLException("Cannot get a connection, general error", e);
    }
}

_pool.borrowObject()得到是PoolableConnection物件的例項，其繼承自DelegatingConnection。

PoolGuardConnectionWrapper繼承了DelegatingConnection這個類且對父類並沒有做太多的改動。DelegatingConnection實現了java.sql.Connection介面，createStatement(),prepareStatement(),commit(),rollback()這些方法和我們以往

通過DriverManager.getConnection()得到的Connection使用方法是一致的。

重點在呼叫colse()方法時，並不是真正的關閉了連線，而是對連線做了狀態清理後將

通過GenericObjectPool的returnObject方法將其歸還至連線池了，看看原始碼就明白了。

先看看DelegatingConnection這個類實現的close方法，主要是做了Statement和ResultSet的清理：

public void close() throws SQLException {
    if (!_closed) {
        closeInternal();
    }
}
protected final void closeInternal() throws SQLException {
    try {
        passivate();
    } finally {
        if (_conn != null) {
            try {
                _conn.close();
            } finally {
                _closed = true;
            }
        } else {
            _closed = true;
        }
    }
}
protected void passivate() throws SQLException {
    // The JDBC spec requires that a Connection close any open
    // Statement's when it is closed.
    // DBCP-288. Not all the traced objects will be statements
    //關閉  Statement and ResultSet
    List<AbandonedTrace> traces = getTrace();
    if(traces != null && traces.size() > 0) {
        Iterator<AbandonedTrace> traceIter = traces.iterator();
        while (traceIter.hasNext()) {
            Object trace = traceIter.next();
            if (trace instanceof Statement) {
                ((Statement) trace).close();
            } else if (trace instanceof ResultSet) {
                // DBCP-265: Need to close the result sets that are
                // generated via DatabaseMetaData
                ((ResultSet) trace).close();
            }
        }
        clearTrace();
    }
    setLastUsed(0);
}

PoolableConnection對close()方法進行了複寫：

/**
 * Returns me to my pool.
 */
 @Override
public synchronized void close() throws SQLException {
    if (isClosedInternal()) {
        // already closed
        return;
    }
    boolean isUnderlyingConectionClosed;
    try {
        isUnderlyingConectionClosed = getDelegateInternal().isClosed();
    } catch (SQLException e) {
        try {
            _pool.invalidateObject(this);
        } catch(IllegalStateException ise) {
            passivate();//在這個方法內部還是呼叫的父類DelegatingConnection的passivate()方法
            getInnermostDelegate().close();
        } catch (Exception ie) {
            // DO NOTHING the original exception will be rethrown
        }
        throw new SQLException("Cannot close connection (isClosed check failed)", e);
    }
     
    if (isUnderlyingConectionClosed) {
        try {
            _pool.invalidateObject(this);
        } catch(IllegalStateException e) {
            passivate();
            getInnermostDelegate().close();
        } catch (Exception e) {
            throw new SQLException("Cannot close connection (invalidating pooled object failed)", e);
        }
    } else {
        try {
            _pool.returnObject(this);
        } catch(IllegalStateException e) {
            passivate();
            getInnermostDelegate().close();
        } catch(SQLException e) {
            throw e;
        } catch(RuntimeException e) {
            throw e;
        } catch(Exception e) {
            throw new SQLException("Cannot close connection (return to pool failed)", e);
        }
    }
}
@Override
protected void passivate()throws SQLException {
    super.passivate();
    setClosedInternal(true);
}

基本邏輯是呼叫父類的passivate()方法做狀態清理，然後將連線歸還給連線池。因此，回到本篇開始的地方，呼叫close()方法是不會關閉該連線的。

最後，DBCP這個包大致的框架結構如下

主要有以下幾點：

1、 實現池化連線物件PoolableConnection，這個即是我們操作資料的連線物件

2、 池化連線物件工廠類PoolableConnectionFactory，池化連線物件的建立工廠

3、 BasicDataSource工廠類BasicDataSourceFactory，用以建立PoolingDataSource類的例項

4、 PoolingDataSource使用PoolableConnectionFactory建立池化連線，並使用GenericObjectPool作為池物件的管理者。

5、 由於一個connection可以對應多個statement，PoolableConnection內部使用KeyedObjectPool來管理這些statement。

個人理解，不足或者錯誤之處敬請指出~~~