Java 的JDBC 資料庫連線池實現方法

雖然 J2EE 程式設計師一般都有現成的應用伺服器所帶的JDBC 資料庫連線池，不過對於開發一般的 Java Application 、 Applet 或者 JSP、velocity 時，我們可用的JDBC 資料庫連線池並不多，並且一般效能都不好。 Java 程式設計師都很羨慕 Windows ADO ，只需要 new Connection 就可以直接從資料庫連線池中返回 Connection。並且 ADO Connection 是執行緒安全的，多個執行緒可以共用一個 Connection， 所以 ASP 程式一般都把 getConnection 放在 Global.asa 檔案中，在 IIS 啟動時建立資料庫連線。ADO 的 Connection 和 Result 都有很好的緩衝，並且很容易使用。
其實我們可以自己寫一個JDBC 資料庫連線池。寫 JDBC connection pool 的注意事項有：

1. 有一個簡單的函式從連線池中得到一個 Connection。
2. close 函式必須將 connection 放回 資料庫連線池。
3. 當資料庫連線池中沒有空閒的 connection，資料庫連線池必須能夠自動增加 connection 個數。
4. 當資料庫連線池中的 connection 個數在某一個特別的時間變得很大，但是以後很長時間只用其中一小部分，應該可以自動將多餘的 connection 關閉掉。
5. 如果可能，應該提供debug 資訊報告沒有關閉的 new Connection 。

如果要 new Connection 就可以直接從資料庫連線池中返回 Connection， 可以這樣寫( Mediator pattern ) (以下程式碼中使用了中文全形空格)：

public class EasyConnection implements java.sql.Connection{
private Connection m_delegate = null;

public EasyConnection(){
m_delegate = getConnectionFromPool();
}

public void close(){
putConnectionBackToPool(m_delegate);
}

public PreparedStatement prepareStatement(String sql) throws SQLException{
m_delegate.prepareStatement(sql);
}

//...... other method

}

看來並不難。不過不建議這種寫法，因為應該儘量避免使用 Java Interface, 關於 Java Interface 的缺點我另外再寫文章討論。大家關注的是 Connection Pool 的實現方法。下面給出一種實現方法。

import java.sql.*;
import java.lang.reflect.*;
import java.util.*;
import java.io.*;

public class SimpleConnetionPool {
private static LinkedList m_notUsedConnection = new LinkedList();
private static HashSet m_usedUsedConnection = new HashSet();
private static String m_url = "";
private static String m_user = "";
private static String m_password = "";
static final boolean DEBUG = true;
static private long m_lastClearClosedConnection = System.currentTimeMillis();
public static long CHECK_CLOSED_CONNECTION_TIME = 4 * 60 * 60 * 1000; //4 hours

static {
initDriver();
}

private SimpleConnetionPool() {
}

private static void initDriver() {
Driver driver = null;
//load mysql driver
try {
driver = (Driver) Class.forName("com.mysql.jdbc.Driver").newInstance();
installDriver(driver);
} catch (Exception e) {
}

//load postgresql driver
try {
driver = (Driver) Class.forName("org.postgresql.Driver").newInstance();
installDriver(driver);
} catch (Exception e) {
}
}

public static void installDriver(Driver driver) {
try {
DriverManager.registerDriver(driver);
} catch (Exception e) {
e.printStackTrace();
}
}


public static synchronized Connection getConnection() {
clearClosedConnection();
while (m_notUsedConnection.size() > 0) {
try {
ConnectionWrapper wrapper = (ConnectionWrapper) m_notUsedConnection.removeFirst();
if (wrapper.connection.isClosed()) {
continue;
}
m_usedUsedConnection.add(wrapper);
if (DEBUG) {
wrapper.debugInfo = new Throwable("Connection initial statement");
}
return wrapper.connection;
} catch (Exception e) {
}
}
int newCount = getIncreasingConnectionCount();
LinkedList list = new LinkedList();
ConnectionWrapper wrapper = null;
for (int i = 0; i < newCount; i++) {
wrapper = getNewConnection();
if (wrapper != null) {
list.add(wrapper);
}
}
if (list.size() == 0) {
return null;
}
wrapper = (ConnectionWrapper) list.removeFirst();
m_usedUsedConnection.add(wrapper);

m_notUsedConnection.addAll(list);
list.clear();

return wrapper.connection;
}

private static ConnectionWrapper getNewConnection() {
try {
Connection con = DriverManager.getConnection(m_url, m_user, m_password);
ConnectionWrapper wrapper = new ConnectionWrapper(con);
return wrapper;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

static synchronized void pushConnectionBackToPool(ConnectionWrapper con) {
boolean exist = m_usedUsedConnection.remove(con);
if (exist) {
m_notUsedConnection.addLast(con);
}
}

public static int close() {
int count = 0;

Iterator iterator = m_notUsedConnection.iterator();
while (iterator.hasNext()) {
try {
( (ConnectionWrapper) iterator.next()).close();
count++;
} catch (Exception e) {
}
}
m_notUsedConnection.clear();

iterator = m_usedUsedConnection.iterator();
while (iterator.hasNext()) {
try {
ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
wrapper.close();
if (DEBUG) {
wrapper.debugInfo.printStackTrace();
}
count++;
} catch (Exception e) {
}
}
m_usedUsedConnection.clear();

return count;
}

private static void clearClosedConnection() {
long time = System.currentTimeMillis();
//sometimes user change system time,just return
if (time < m_lastClearClosedConnection) {
time = m_lastClearClosedConnection;
return;
}
//no need check very often
if (time - m_lastClearClosedConnection < CHECK_CLOSED_CONNECTION_TIME) {
return;
}
m_lastClearClosedConnection = time;

//begin check
Iterator iterator = m_notUsedConnection.iterator();
while (iterator.hasNext()) {
ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
try {
if (wrapper.connection.isClosed()) {
iterator.remove();
}
} catch (Exception e) {
iterator.remove();
if (DEBUG) {
System.out.println("connection is closed, this connection initial StackTrace");
wrapper.debugInfo.printStackTrace();
}
}
}

//make connection pool size smaller if too big
int decrease = getDecreasingConnectionCount();
if (m_notUsedConnection.size() < decrease) {
return;
}

while (decrease-- > 0) {
ConnectionWrapper wrapper = (ConnectionWrapper) m_notUsedConnection.removeFirst();
try {
wrapper.connection.close();
} catch (Exception e) {
}
}
}

/**
* get increasing connection count, not just add 1 connection
* @return count
*/
public static int getIncreasingConnectionCount() {
int count = 1;
int current = getConnectionCount();
count = current / 4;
if (count < 1) {
count = 1;
}
return count;
}

/**
* get decreasing connection count, not just remove 1 connection
* @return count
*/
public static int getDecreasingConnectionCount() {
int count = 0;
int current = getConnectionCount();
if (current < 10) {
return 0;
}
return current / 3;
}

public synchronized static void printDebugMsg() {
printDebugMsg(System.out);
}

public synchronized static void printDebugMsg(PrintStream out) {
if (DEBUG == false) {
return;
}
StringBuffer msg = new StringBuffer();
msg.append("debug message in " + SimpleConnetionPool.class.getName());
msg.append("\r\n");
msg.append("total count is connection pool: " + getConnectionCount());
msg.append("\r\n");
msg.append("not used connection count: " + getNotUsedConnectionCount());
msg.append("\r\n");
msg.append("used connection, count: " + getUsedConnectionCount());
out.println(msg);
Iterator iterator = m_usedUsedConnection.iterator();
while (iterator.hasNext()) {
ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
wrapper.debugInfo.printStackTrace(out);
}
out.println();
}

public static synchronized int getNotUsedConnectionCount() {
return m_notUsedConnection.size();
}

public static synchronized int getUsedConnectionCount() {
return m_usedUsedConnection.size();
}

public static synchronized int getConnectionCount() {
return m_notUsedConnection.size() + m_usedUsedConnection.size();
}

public static String getUrl() {
return m_url;
}

public static void setUrl(String url) {
if (url == null) {
return;
}
m_url = url.trim();
}

public static String getUser() {
return m_user;
}

public static void setUser(String user) {
if (user == null) {
return;
}
m_user = user.trim();
}

public static String getPassword() {
return m_password;
}

public static void setPassword(String password) {
if (password == null) {
return;
}
m_password = password.trim();
}

}

class ConnectionWrapper implements InvocationHandler {
private final static String CLOSE_METHOD_NAME = "close";
public Connection connection = null;
private Connection m_originConnection = null;
public long lastAccessTime = System.currentTimeMillis();
Throwable debugInfo = new Throwable("Connection initial statement");

ConnectionWrapper(Connection con) {
this.connection = (Connection) Proxy.newProxyInstance(
con.getClass().getClassLoader(),
con.getClass().getInterfaces(), this);
m_originConnection = con;
}

void close() throws SQLException {
m_originConnection.close();
}

public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
Object obj = null;
if (CLOSE_METHOD_NAME.equals(m.getName())) {
SimpleConnetionPool.pushConnectionBackToPool(this);
}
else {
obj = m.invoke(m_originConnection, args);
}
lastAccessTime = System.currentTimeMillis();
return obj;
}
}

使用方法

public class TestConnectionPool{
public static void main(String[] args) {
SimpleConnetionPool.setUrl(DBTools.getDatabaseUrl());
SimpleConnetionPool.setUser(DBTools.getDatabaseUserName());
SimpleConnetionPool.setPassword(DBTools.getDatabasePassword());

Connection con = SimpleConnetionPool.getConnection();
Connection con1 = SimpleConnetionPool.getConnection();
Connection con2 = SimpleConnetionPool.getConnection();

//do something with con ...

try {
con.close();
} catch (Exception e) {}

try {
con1.close();
} catch (Exception e) {}

try {
con2.close();
} catch (Exception e) {}

con = SimpleConnetionPool.getConnection();
con1 = SimpleConnetionPool.getConnection();
try {
con1.close();
} catch (Exception e) {}

con2 = SimpleConnetionPool.getConnection();
SimpleConnetionPool.printDebugMsg();

}
}

執行測試程式後列印連線池中 Connection 狀態，以及正在使用的沒有關閉 Connection 資訊。