>  轉載 ：https://www.cnblogs.com/tobey/articles/5810682.html  本文主要有解釋，可參考

```
//
//    一個效果非常不錯的JAVA資料庫連線池.
//    from:http://www.jxer.com/home/?uid-195-action-viewspace-itemid-332
//    雖然現在用APACHE COMMONS DBCP可以非常方便的建立資料庫連線池，
//    但是像這篇文章把資料庫連線池的內部原理寫的這麼透徹，注視這麼完整，
//    真是非常難得，讓開發人員可以更深層次的理解資料庫連線池，真是非常感
//    謝這篇文章的作者。
//
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Vector;
@SuppressWarnings("rawtypes")
public class ConnectionPool {

private String jdbcDriver = ""; // 資料庫驅動
    private String dbUrl = ""; // 資料 URL
    private String dbUsername = ""; // 資料庫使用者名稱
    private String dbPassword = ""; // 資料庫使用者密碼
    private String testTable = ""; // 測試連線是否可用的測試表名，預設沒有測試表
    private int initialConnections = 10; // 連線池的初始大小
    private int incrementalConnections = 5; // 連線池自動增加的大小
    private int maxConnections = 50; // 連線池最大的大小

private Vector connections = null; // 存放連線池中資料庫連線的向量 , 初始時為 null
    // 它中存放的物件為 PooledConnection 型

public ConnectionPool(String jdbcDriver, String dbUrl, String dbUsername,
                          String dbPassword) {

this.jdbcDriver = jdbcDriver;
        this.dbUrl = dbUrl;
        this.dbUsername = dbUsername;
        this.dbPassword = dbPassword;
    }

public int getInitialConnections() {
        return this.initialConnections;
    }

public void setInitialConnections(int initialConnections) {
        this.initialConnections = initialConnections;
    }

public int getIncrementalConnections() {
        return this.incrementalConnections;
    }

public void setIncrementalConnections(int incrementalConnections) {
        this.incrementalConnections = incrementalConnections;
    }

public int getMaxConnections() {
        return this.maxConnections;
    }

public void setMaxConnections(int maxConnections) {
        this.maxConnections = maxConnections;
    }

public String getTestTable() {
        return this.testTable;
    }

public void setTestTable(String testTable) {
        this.testTable = testTable;
    }

public synchronized void createPool() throws Exception {
        // 確保連線池沒有建立
        // 假如連線池己經建立了，儲存連線的向量 connections 不會為空
        if (connections != null) {
            return; // 假如己經建立，則返回
        }
        // 例項化 JDBC Driver 中指定的驅動類例項
        Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
        DriverManager.registerDriver(driver); // 註冊 JDBC 驅動程式
        // 建立儲存連線的向量 , 初始時有 0 個元素
        connections = new Vector();
        // 根據 initialConnections 中設定的值，建立連線。
        createConnections(this.initialConnections);
        System.out.println(" 資料庫連線池建立成功！ ");
    }

@SuppressWarnings("unchecked")
    private void createConnections(int numConnections) throws SQLException {
        // 迴圈建立指定數目的資料庫連線
        for (int x = 0; x < numConnections; x++) {
            // 是否連線池中的資料庫連線的數量己經達到最大？最大值由類成員 maxConnections
            // 指出，假如 maxConnections 為 0 或負數，表示連線數量沒有限制。
            // 假如連線數己經達到最大，即退出。
            if (this.maxConnections > 0 &&
                this.connections.size() >= this.maxConnections) {
                break;
            }
            //add a new PooledConnection object to connections vector
            // 增加一個連線到連線池中（向量 connections 中）
            try {
                connections.addElement(new PooledConnection(newConnection()));
            } catch (SQLException e) {
                System.out.println(" 建立資料庫連線失敗！ " + e.getMessage());
                throw new SQLException();
            }
            System.out.println(" 資料庫連線己建立 ......");
        }
    }

private Connection newConnection() throws SQLException {
        // 建立一個資料庫連線
        Connection conn = DriverManager.getConnection(dbUrl, dbUsername,
                dbPassword);
        // 假如這是第一次建立資料庫連線，即檢查資料庫，獲得此資料庫答應支援的
        // 最大客戶連線數目
        //connections.size()==0 表示目前沒有連線己被建立
        if (connections.size() == 0) {
            DatabaseMetaData metaData = conn.getMetaData();
            int driverMaxConnections = metaData.getMaxConnections();
            // 資料庫返回的 driverMaxConnections 若為 0 ，表示此資料庫沒有最大
            // 連線限制，或資料庫的最大連線限制不知道
            //driverMaxConnections 為返回的一個整數，表示此資料庫答應客戶連線的數目
            // 假如連線池中設定的最大連線數量大於資料庫答應的連線數目 , 則置連線池的最大
            // 連線數目為資料庫答應的最大數目
            if (driverMaxConnections > 0 &&
                this.maxConnections > driverMaxConnections) {
                this.maxConnections = driverMaxConnections;
            }
        }
        return conn; // 返回建立的新的資料庫連線
    }

public synchronized Connection getConnection() throws SQLException {
        // 確保連線池己被建立
        if (connections == null) {
            return null; // 連線池還沒建立，則返回 null
        }
        Connection conn = getFreeConnection(); // 獲得一個可用的資料庫連線
        // 假如目前沒有可以使用的連線，即所有的連線都在使用中
        while (conn == null) {
            // 等一會再試
            wait(250);
            conn = getFreeConnection(); // 重新再試，直到獲得可用的連線，假如
            //getFreeConnection() 返回的為 null
            // 則表明建立一批連線後也不可獲得可用連線
        }
        return conn; // 返回獲得的可用的連線
    }

private Connection getFreeConnection() throws SQLException {
        // 從連線池中獲得一個可用的資料庫連線
        Connection conn = findFreeConnection();
        if (conn == null) {
            // 假如目前連線池中沒有可用的連線
            // 建立一些連線
            createConnections(incrementalConnections);
            // 重新從池中查詢是否有可用連線
            conn = findFreeConnection();
            if (conn == null) {
                // 假如建立連線後仍獲得不到可用的連線，則返回 null
                return null;
            }
        }
        return conn;
    }

@SuppressWarnings("resource")
    private Connection findFreeConnection() throws SQLException {
        Connection conn = null;
        PooledConnection pConn = null;
        // 獲得連線池向量中所有的物件
        Enumeration enumerate = connections.elements();
        // 遍歷所有的物件，看是否有可用的連線
        while (enumerate.hasMoreElements()) {
            pConn = (PooledConnection) enumerate.nextElement();
            if (!pConn.isBusy()) {
                // 假如此物件不忙，則獲得它的資料庫連線並把它設為忙
                conn = pConn.getConnection();
                pConn.setBusy(true);
                // 測試此連線是否可用
                if (!testConnection(conn)) {
                    // 假如此連線不可再用了，則建立一個新的連線，
                    // 並替換此不可用的連線物件，假如建立失敗，返回 null
                    try {
                        conn = newConnection();
                    } catch (SQLException e) {
                        System.out.println(" 建立資料庫連線失敗！ " + e.getMessage());
                        return null;
                    }
                    pConn.setConnection(conn);
                }
                break; // 己經找到一個可用的連線，退出
            }
        }
        return conn; // 返回找到到的可用連線
    }

private boolean testConnection(Connection conn) {
        try {
            // 判定測試表是否存在
            if (testTable.equals("")) {
                // 假如測試表為空，試著使用此連線的 setAutoCommit() 方法
                // 來判定連線否可用（此方法只在部分資料庫可用，假如不可用 ,
                // 丟擲異常）。注重：使用測試表的方法更可靠
                conn.setAutoCommit(true);
            } else { // 有測試表的時候使用測試表測試
                //check if this connection is valid
                Statement stmt = conn.createStatement();
                stmt.execute("select count(*) from " + testTable);
            }
        } catch (SQLException e) {
            // 上面丟擲異常，此連線己不可用，關閉它，並返回 false;
            closeConnection(conn);
            return false;
        }
        // 連線可用，返回 true
        return true;
    }

public void returnConnection(Connection conn) {
        // 確保連線池存在，假如連線沒有建立（不存在），直接返回
        if (connections == null) {
            System.out.println(" 連線池不存在，無法返回此連線到連線池中 !");
            return;
        }
        PooledConnection pConn = null;
        Enumeration enumerate = connections.elements();
        // 遍歷連線池中的所有連線，找到這個要返回的連線物件
        while (enumerate.hasMoreElements()) {
            pConn = (PooledConnection) enumerate.nextElement();
            // 先找到連線池中的要返回的連線物件
            if (conn == pConn.getConnection()) {
                // 找到了 , 設定此連線為空閒狀態
                pConn.setBusy(false);
                break;
            }
        }
    }

public synchronized void refreshConnections() throws SQLException {
        // 確保連線池己創新存在
        if (connections == null) {
            System.out.println(" 連線池不存在，無法重新整理 !");
            return;
        }
        PooledConnection pConn = null;
        Enumeration enumerate = connections.elements();
        while (enumerate.hasMoreElements()) {
            // 獲得一個連線物件
            pConn = (PooledConnection) enumerate.nextElement();
            // 假如物件忙則等 5 秒 ,5 秒後直接重新整理
            if (pConn.isBusy()) {
                wait(5000); // 等 5 秒
            }
            // 關閉此連線，用一個新的連線代替它。
            closeConnection(pConn.getConnection());
            pConn.setConnection(newConnection());
            pConn.setBusy(false);
        }
    }

public synchronized void closeConnectionPool() throws SQLException {
        // 確保連線池存在，假如不存在，返回
        if (connections == null) {
            System.out.println(" 連線池不存在，無法關閉 !");
            return;
        }
        PooledConnection pConn = null;
        Enumeration enumerate = connections.elements();
        while (enumerate.hasMoreElements()) {
            pConn = (PooledConnection) enumerate.nextElement();
            // 假如忙，等 5 秒
            if (pConn.isBusy()) {
                wait(5000); // 等 5 秒
            }
            //5 秒後直接關閉它
            closeConnection(pConn.getConnection());
            // 從連線池向量中刪除它
            connections.removeElement(pConn);
        }
        // 置連線池為空
        connections = null;
    }

private void closeConnection(Connection conn) {
        try {
            conn.close();
        } catch (SQLException e) {
            System.out.println(" 關閉資料庫連線出錯： " + e.getMessage());
        }
    }

private void wait(int mSeconds) {
        try {
            Thread.sleep(mSeconds);
        } catch (InterruptedException e) {
        }
    }

class PooledConnection {
        Connection connection = null; // 資料庫連線
        boolean busy = false; // 此連線是否正在使用的標誌，預設沒有正在使用
        // 建構函式，根據一個 Connection 構造一個 PooledConnection 物件
        public PooledConnection(Connection connection) {
            this.connection = connection;
        }

// 返回此物件中的連線
        public Connection getConnection() {
            return connection;
        }

// 設定此物件的，連線
        public void setConnection(Connection connection) {
            this.connection = connection;
        }

// 獲得物件連線是否忙
        public boolean isBusy() {
            return busy;
        }

// 設定物件的連線正在忙
        public void setBusy(boolean busy) {
            this.busy = busy;
        }
    }

public static void main(String[] args) {

ConnectionPool connPool= new ConnectionPool("oracle.jdbc.OracleDriver",
                                     "jdbc:oracle:thin:@*:1521:orcl"
                                     , "*", "*");
        try {
            connPool.createPool();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        try {
            Connection conn = connPool.getConnection();
            PreparedStatement preparedStatement=conn.prepareStatement("select * from user_files_flow");
            ResultSet result=preparedStatement.executeQuery();
            while (result.next()) {
                System.out.println(result.getString("id"));
            }
            System.out.println(conn);
        } catch (SQLException ex1) {
            ex1.printStackTrace();
        }

}

}
```

【JDBC】java連線池模擬測試連線Oracle資料庫指令碼參考

相關文章