dbconnpool.txt

一个经试用效果非常不错的数据库连接池

* 当前没有可用的数据库连接，本函数则根据 incrementalConnections 设置 

* 的值创建几个数据库连接，并放入连接池中。 

* 如果创建后，所有的连接仍都在使用中，则返回 null 

* @return 返回一个可用的数据库连接 

*/ 

private Connection getFreeConnection() throws SQLException { 

// 从连接池中获得一个可用的数据库连接 

Connection conn = findFreeConnection(); 

if (conn == null) { 

// 如果目前连接池中没有可用的连接 

// 创建一些连接 

createConnections(incrementalConnections); 

// 重新从池中查找是否有可用连接 

conn = findFreeConnection(); 

if (conn == null) { 

// 如果创建连接后仍获得不到可用的连接，则返回 null 

return null; 

} 

} 

return conn; 

} 

/** 

* 查找连接池中所有的连接，查找一个可用的数据库连接， 

* 如果没有可用的连接，返回 null 

* 

* @return 返回一个可用的数据库连接 

*/ 

private Connection findFreeConnection() throws SQLException { 

Connection conn = null; 

PooledConnection pConn = null; 

// 获得连接池向量中所有的对象 

Enumeration enum = connections.elements(); 

// 遍历所有的对象，看是否有可用的连接 

while (enum.hasMoreElements()) { 

pConn = (PooledConnection) enum.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;// 返回找到到的可用连接 

} 

/** 

* 测试一个连接是否可用，如果不可用，关掉它并返回 false 

* 否则可用返回 true 

* 

* @param conn 需要测试的数据库连接 

* @return 返回 true 表示此连接可用， false 表示不可用 

*/ 

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; 

} 

/** 

* 此函数返回一个数据库连接到连接池中，并把此连接置为空闲。 

* 所有使用连接池获得的数据库连接均应在不使用此连接时返回它。 

* 

* @param 需返回到连接池中的连接对象 

*/ 

public void returnConnection(Connection conn) { 

// 确保连接池存在，如果连接没有创建（不存在），直接返回 

if (connections == null) { 

System.out.println(" 连接池不存在，无法返回此连接到连接池中 !"); 

return; 

} 

PooledConnection pConn = null; 

Enumeration enum = connections.elements(); 

// 遍历连接池中的所有连接，找到这个要返回的连接对象 

while (enum.hasMoreElements()) { 

pConn = (PooledConnection) enum.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 enum = connections.elements(); 

while (enum.hasMoreElements()) { 

// 获得一个连接对象 

pConn = (PooledConnection) enum.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 enum = connections.elements(); 

while (enum.hasMoreElements()) { 

pConn = (PooledConnection) enum.nextElement(); 

// 如果忙，等 5 秒 

if (pConn.isBusy()) { 

wait(5000); // 等 5 秒 

} 

//5 秒后直接关闭它 

closeConnection(pConn.getConnection()); 

// 从连接池向量中删除它 

connections.removeElement(pConn); 

} 

// 置连接池为空 

connections = null; 

} 

/** 

* 关闭一个数据库连接 

* 

* @param 需要关闭的数据库连接 

*/ 

private void closeConnection(Connection conn) { 

try { 

conn.close(); 

}catch (SQLException e) { 

System.out.println(" 关闭数据库连接出错： "+e.getMessage()); 

} 

} 

/** 

* 使程序等待给定的毫秒数 

* 

* @param 给定的毫秒数 

*/ 

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; 

} 

} 

}