Java操作數據庫——手動實現數據庫連接池

摘要：本文主要學習了如何手動實現一個數據庫連接池，以及在這基礎上的一些改進。

部分內容來自以下博客：

https://blog.csdn.net/soonfly/article/details/72731144

一個簡單的數據庫連接池

連接池工具類

連接池使用了線程安全的隊列存儲連接資源，保證了線程安全。

提供了獲取連接和釋放連接的方法，實現了連接資源的循環使用。

在對線程進行技術時，使用原子類，保證了線程計數在多線程環境下的安全。

代碼如下：

public class DataPoolUtils {
    // 活動連接，使用線程安全的隊列
    private static LinkedBlockingQueue<Connection> busy = new LinkedBlockingQueue<Connection>();
    // 空閑連接，使用線程安全的隊列
    private static LinkedBlockingQueue<Connection> idle = new LinkedBlockingQueue<Connection>();
    // 已創建連接數，使用原子操作類實現線程安全
    private static AtomicInteger createCount = new AtomicInteger(0);
    // 最大連接數
    private static int maxConnection = 5;
    // 最大等待毫秒數
    private static int maxWaitTimeout = 1000;
    
    /**
     * 創建連接
     * @return
     * @throws Exception 
     */
    private Connection createConnection() throws Exception {
        Properties pros = new Properties();
        InputStream is = DataPoolUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
        pros.load(is);
        String driverClass = pros.getProperty("driverClass");
        Class.forName(driverClass);
        String url = pros.getProperty("url");
        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        return DriverManager.getConnection(url, user, password);
    }
    
    /**
     * 關閉連接
     * @param connection
     */
    private void closeConnection(Connection connection) {
        try {
            if (!connection.isClosed()) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 獲取連接
     * @return
     * @throws Exception 
     */
    public Connection getConnection() throws Exception {
        // 嘗試獲取空閑連接
        Connection connection = idle.poll();
        if (connection == null) {
            // 嘗試創建連接，使用雙重CAS檢查現有連接數是否小於最大連接數
            if (createCount.get() < maxConnection) {
                if (createCount.incrementAndGet() <= maxConnection) {
                    connection = createConnection();
                } else {
                    createCount.decrementAndGet();
                }
            }
            // 嘗試等待獲取空閑連接，實現超時等待機制
            if (connection == null) {
                connection = idle.poll(maxWaitTimeout, TimeUnit.MILLISECONDS);
                if (connection == null) {
                    throw new Exception("獲取連接超時");
                }
            }
        }
        busy.offer(connection);
        return connection;
    }
    
    /**
     * 歸還連接
     * @param connection
     */
    public void releaseConnection(Connection connection) {
        // 處理空連接
        if (connection == null) {
            createCount.decrementAndGet();
            return;
        }
        // 處理移除失敗的連接
        boolean removeResult = busy.remove(connection);
        if (!removeResult) {
            closeConnection(connection);
            createCount.decrementAndGet();
            return;
        }
        // 處理已經關閉的連接
        try {
            if (connection.isClosed()) {
                createCount.decrementAndGet();
                return;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // 處理添加失敗的連接
        boolean offerResult = idle.offer(connection);
        if (!offerResult) {
            closeConnection(connection);
            createCount.decrementAndGet();
            return;
        }
    }
}

測試連接池的業務類

為了能夠實現線程的循環使用，需要調用線程池的釋放連接資源的方法，而不是將連接資源直接關閉。

代碼如下：

public class TestPool {
    // 根據配置文件里的名稱創建連接池
    private static DataPoolUtils pool = new DataPoolUtils();

    /**
     * 主程序
     */
    public static void main(String[] args) {
        // 模擬多次對數據庫的查詢操作
        for (int i = 0; i < 6; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    select();
                }
            }, "線程" + i).start();
        }
    }

    /**
     * 查詢程序
     */
    public static void select() {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        // 獲取連接並執行SQL
        try {
            conn = pool.getConnection();
            pstmt = conn.prepareStatement("select * from student where id = 906");
            rs = pstmt.executeQuery();
            while (rs.next()) {
                System.out.println(Thread.currentThread().getName() + "\t" + rs.getString(1) + "\t" + rs.getString(2) + "\t" + rs.getString("address"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 釋放資源
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            /*
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            */
            pool.releaseConnection(conn);
        }
    }
}

使用動態代理修改原生連接的關閉方法

改進說明

簡單的數據庫連接池已經有了，但是在使用的時候如果調用了原生的關閉方法，會導致連接不能重復使用。

利用之前學過的動態代理進行改進，使調用關閉方法的時候執行的仍然是連接池里的釋放資源的方法。

在 DataPoolUtils 工具類里添加動態代理的相關內部類：

/**
 * 代理處理類
 */
class ConnectionInvocationHandler implements InvocationHandler{
    private Connection connection;
    private DataPoolUtils dpu;

    public ConnectionInvocationHandler(DataPoolUtils dpu, Connection connection) {
        this.dpu = dpu;
        this.connection = connection;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // 對原生的關閉方法進行修改
        if(method.getName().equals("close")){
            dpu.releaseConnection(connection);
            return null;
        }else{
            return method.invoke(connection, args);
        }
    }
}

修改 DataPoolUtils 工具類中 public Connection getConnection() 方法的返回值，將返回值改為使用動態代理后的值：

return (Connection) Proxy.newProxyInstance(
        Connection.class.getClassLoader(), 
        new Class[] { Connection.class }, 
        new ConnectionInvocationHandler(this, connection));

修改 TestPool 業務類中的 public static void select() 方法，將釋放連接改為關閉連接：

try {
    conn.close();
} catch (SQLException e) {
    e.printStackTrace();
}

注意說明

在工具類的 getConnection() 方法中返回代理類，而不是在工具類的 createConnection() 方法中返回，是因為通過后者得到的對象是要放到活動隊列里的，如果在后者中返回代理對象，那么就會導致活動隊列里的對象都是代理對象。

那么在執行代理對象的 close() 方法時，經過動態代理后，實際上是執行的是被代理對象的 releaseConnection() 方法，也就是將被代理對象從活動隊列放到空閑隊列，但因為活動隊列里存放的都是代理對象，導致無法通過被代理對象從活動隊列將代理對象放到空閑隊列，進而導致連接資源並沒有得到循環利用。