---
title: "一个完备的数据库连接池类(bczt)"
author: "winzenghua"
date: "2005-11-30T10:21:00Z"
tags: []
slug: "bczt"
draft: false
lastmod: "2005-11-30T10:21:00Z"
id: 988079
url: "https://java4gis.iteye.com/blog/988079"
---

import java.io.\*;  
import java.sql.\*;  
import java.util.\*;  
import java.util.Date;

/\**  
\* 管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接  
\* 池的访问.客户程序可以调用getInstance()方法访问本类的唯一实例.  
\*/

public class DBConnectionManager {  
static private DBConnectionManager instance; // 唯一实例  
static private int clients;

private Vector drivers = new Vector();  
private PrintWriter log;  
private Hashtable pools = new Hashtable();

/\**  
\* 返回唯一实例.如果是第一次调用此方法,则创建实例  
\*  
\* @return DBConnectionManager 唯一实例  
\*\*/  
static synchronized public DBConnectionManager getInstance() {  
if (instance == null) {  
instance = new DBConnectionManager();  
}  
clients++;  
return instance;  
}

/\**  
\* 建构函数私有以防止其它对象创建本类实例  
\*/  
private DBConnectionManager() {  
init();  
}

/\**  
\* 将连接对象返回给由名字指定的连接池  
\*  
\* @param name 在属性文件中定义的连接池名字  
\* @param con 连接对象  
\*\*/  
public void freeConnection(String name, Connection con) {  
DBConnectionPool pool = (DBConnectionPool) pools.get(name);  
if (pool != null) {  
pool.freeConnection(con);  
}  
}

/\**  
\* 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数  
\* 限制,则创建并返回新连接  
\*  
\* @param name 在属性文件中定义的连接池名字  
\* @return Connection 可用连接或null  
\*/  
public Connection getConnection(String name) {  
DBConnectionPool pool = (DBConnectionPool) pools.get(name);  
if (pool != null) {  
return pool.getConnection();  
}  
return null;  
}

/\**  
\* 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制,  
\* 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.  
\*  
\* @param name 连接池名字  
\* @param time 以毫秒计的等待时间  
\* @return Connection 可用连接或null  
\*/  
public Connection getConnection(String name, long time) {  
DBConnectionPool pool = (DBConnectionPool) pools.get(name);  
if (pool != null) {  
return pool.getConnection(time);  
}  
return null;  
}

/\**  
\* 关闭所有连接,撤销驱动程序的注册  
\*/  
public synchronized void release() {  
// 等待直到最后一个客户程序调用  
if (--clients != 0) {  
return;  
}

Enumeration allPools = pools.elements();  
while (allPools.hasMoreElements()) {  
DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();  
pool.release();  
}  
Enumeration allDrivers = drivers.elements();  
while (allDrivers.hasMoreElements()) {  
Driver driver = (Driver) allDrivers.nextElement();  
try {  
DriverManager.deregisterDriver(driver);  
log("撤销JDBC驱动程序 " + driver.getClass().getName() + "的注册");  
}  
catch (SQLException e) {  
log(e, "无法撤销下列JDBC驱动程序的注册: " + driver.getClass().getName());  
}  
}  
}

/\**  
\* 根据指定属性创建连接池实例.  
\*  
\* @param props 连接池属性  
\*/  
private void createPools(Properties props) {  
Enumeration propNames = props.propertyNames();  
while (propNames.hasMoreElements()) {  
String name = (String) propNames.nextElement();  
if (name.endsWith(".url")) {  
String poolName = name.substring(0, name.lastIndexOf("."));  
String url = props.getProperty(poolName + ".url");  
if (url == null) {  
log("没有为连接池" + poolName + "指定URL");  
continue;  
}  
String user = props.getProperty(poolName + ".user");  
String password = props.getProperty(poolName + ".password");  
String maxconn = props.getProperty(poolName + ".maxconn", "0");  
int max;  
try {  
max = Integer.valueOf(maxconn).intValue();  
}  
catch (NumberFormatException e) {  
log("错误的最大连接数限制: " + maxconn + " .连接池: " + poolName);  
max = 0;  
}  
DBConnectionPool pool =  
new DBConnectionPool(poolName, url, user, password, max);  
pools.put(poolName, pool);  
log("成功创建连接池" + poolName);  
}  
}  
}

/\**  
\* 读取属性完成初始化  
\*/  
private void init() {  
InputStream is = getClass().getResourceAsStream("/db.properties");  
Properties dbProps = new Properties();  
try {  
dbProps.load(is);  
}  
catch (Exception e) {  
System.err.println("不能读取属性文件. " +  
"请确保db.properties在CLASSPATH指定的路径中");  
return;  
}  
String logFile = dbProps.getProperty("logfile", "DBConnectionManager.log");  
try {  
log = new PrintWriter(new FileWriter(logFile, true), true);  
}  
catch (IOException e) {  
System.err.println("无法打开日志文件: " + logFile);  
log = new PrintWriter(System.err);  
}  
loadDrivers(dbProps);  
createPools(dbProps);  
}

/\**  
\* 装载和注册所有JDBC驱动程序  
\*  
\* @param props 属性  
\*/  
private void loadDrivers(Properties props) {  
String driverClasses = props.getProperty("drivers");  
StringTokenizer st = new StringTokenizer(driverClasses);  
while (st.hasMoreElements()) {  
String driverClassName = st.nextToken().trim();  
try {  
Driver driver = (Driver)  
Class.forName(driverClassName).newInstance();  
DriverManager.registerDriver(driver);  
drivers.addElement(driver);  
log("成功注册JDBC驱动程序" + driverClassName);  
}  
catch (Exception e) {  
log("无法注册JDBC驱动程序: " +  
driverClassName + ", 错误: " + e);  
}  
}  
}

/\**  
\* 将文本信息写入日志文件  
\*/  
private void log(String msg) {  
log.println(new Date() + ": " + msg);  
}

/\**  
\* 将文本信息与异常写入日志文件  
\*/  
private void log(Throwable e, String msg) {  
log.println(new Date() + ": " + msg);  
e.printStackTrace(log);  
}

/\**  
\* 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最  
\* 大连接数为止.在返回连接给客户程序之前,它能够验证连接的有效性.  
\*/  
class DBConnectionPool {  
private int checkedOut;  
private Vector freeConnections = new Vector();  
private int maxConn;  
private String name;  
private String password;  
private String URL;  
private String user;

/\**  
\* 创建新的连接池  
\*  
\* @param name 连接池名字  
\* @param URL 数据库的JDBC URL  
\* @param user 数据库帐号,或 null  
\* @param password 密码,或 null  
\* @param maxConn 此连接池允许建立的最大连接数  
\*/  
public DBConnectionPool(String name, String URL, String user,  
String password,  
int maxConn) {  
this.name = name;  
this.URL = URL;  
this.user = user;  
this.password = password;  
this.maxConn = maxConn;  
}

/\**  
\* 将不再使用的连接返回给连接池  
\*  
\* @param con 客户程序释放的连接  
\*/  
public synchronized void freeConnection(Connection con) {  
// 将指定连接加入到向量末尾  
freeConnections.addElement(con);  
checkedOut--;  
notifyAll();  
}

/\**  
\* 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接  
\* 数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之,  
\* 然后递归调用自己以尝试新的可用连接.  
\*/  
public synchronized Connection getConnection() {  
Connection con = null;  
if (freeConnections.size() &gt; 0) {  
// 获取向量中第一个可用连接  
con = (Connection) freeConnections.firstElement();  
freeConnections.removeElementAt(0);  
try {  
if (con.isClosed()) {  
log("从连接池" + name + "删除一个无效连接");  
// 递归调用自己,尝试再次获取可用连接  
con = getConnection();  
}  
}  
catch (SQLException e) {  
log("从连接池" + name + "删除一个无效连接");  
// 递归调用自己,尝试再次获取可用连接  
con = getConnection();  
}  
}  
else if (maxConn == 0 || checkedOut &lt; maxConn) {  
con = newConnection();  
}  
if (con != null) {  
checkedOut++;  
}  
return con;  
}

/\**  
\* 从连接池获取可用连接.可以指定客户程序能够等待的最长时间  
\* 参见前一个getConnection()方法.  
\*  
\* @param timeout 以毫秒计的等待时间限制  
\*/  
public synchronized Connection getConnection(long timeout) {  
long startTime = new Date().getTime();  
Connection con;  
while ( (con = getConnection()) == null) {  
try {  
wait(timeout);  
}  
catch (InterruptedException e) {}  
if ( (new Date().getTime() - startTime) &gt;= timeout) {  
// wait()返回的原因是超时  
return null;  
}  
}  
return con;  
}

/\**  
\* 关闭所有连接  
\*/  
public synchronized void release() {  
Enumeration allConnections = freeConnections.elements();  
while (allConnections.hasMoreElements()) {  
Connection con = (Connection) allConnections.nextElement();  
try {  
con.close();  
log("关闭连接池" + name + "中的一个连接");  
}  
catch (SQLException e) {  
log(e, "无法关闭连接池" + name + "中的连接");  
}  
}  
freeConnections.removeAllElements();  
}

/\**  
\* 创建新的连接  
/\*\*/  
private Connection newConnection() {  
Connection con = null;  
try {  
if (user == null) {  
con = DriverManager.getConnection(URL);  
}  
}  
catch (Exception e) {  
log("无法取得新连接");  
}  
return con;  
}  
}  
}

下面是JavaDoc文档：

Class DBConnectionManager  
public class DBConnectionManager  
管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接 池的访问.客户程序可以调用getInstance()方法访问本类的唯一实例.  
Constructor Detail  
DBConnectionManagerprivate DBConnectionManager()  
建构函数私有以防止其它对象创建本类实例

\--------------------------------------------------------------------------------  
Method Detail  
getInstancepublic static synchronized DBConnectionManager getInstance()  
返回唯一实例.如果是第一次调用此方法,则创建实例  
Returns:  
DBConnectionManager 唯一实例

\--------------------------------------------------------------------------------  
freeConnectionpublic void freeConnection(java.lang.String name,  
java.sql.Connection con)  
将连接对象返回给由名字指定的连接池  
Parameters:  
name - 在属性文件中定义的连接池名字  
con - 连接对象

\--------------------------------------------------------------------------------  
getConnectionpublic java.sql.Connection getConnection(java.lang.String name)  
获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数 限制,则创建并返回新连接  
Parameters:  
name - 在属性文件中定义的连接池名字  
Returns:  
Connection 可用连接或null

\--------------------------------------------------------------------------------  
getConnectionpublic java.sql.Connection getConnection(java.lang.String name,  
long time)  
获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制, 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.  
Parameters:  
name - 连接池名字  
time - 以毫秒计的等待时间  
Returns:  
Connection 可用连接或null

\--------------------------------------------------------------------------------  
releasepublic synchronized void release()  
关闭所有连接,撤销驱动程序的注册

\--------------------------------------------------------------------------------  
createPoolsprivate void createPools(java.util.Properties props)  
根据指定属性创建连接池实例.  
Parameters:  
props - 连接池属性

\--------------------------------------------------------------------------------  
initprivate void init()  
读取属性完成初始化

\--------------------------------------------------------------------------------  
loadDriversprivate void loadDrivers(java.util.Properties props)  
装载和注册所有JDBC驱动程序  
Parameters:  
props - 属性

\--------------------------------------------------------------------------------  
logprivate void log(java.lang.String msg)  
将文本信息写入日志文件

\--------------------------------------------------------------------------------  
logprivate void log(java.lang.Throwable e,  
java.lang.String msg)  
将文本信息与异常写入日志文件

引起注意的：  
1.不用log4j写日志文件的方法：  
String logFile = dbProps.getProperty("logfile", "DBConnectionManager.log");  
try {  
log = new PrintWriter(new FileWriter(logFile, true), true);  
}  
catch (IOException e) {  
System.err.println("无法打开日志文件: " + logFile);  
log = new PrintWriter(System.err);  
}  
2.数据库连接池类中大部分方法都定义为synchronized  
3.在数据库连接池中有数量控制连接数  
4.Properties类是Hashtable的子类，典型用途如此文件所说可以load一个文件，这个文件是键值对形式。  
InputStream is = getClass().getResourceAsStream("/db.properties");  
Properties dbProps = new Properties();  
try {  
dbProps.load(is);  
}  
catch (Exception e) {  
System.err.println("不能读取属性文件. " +  
"请确保db.properties在CLASSPATH指定的路径中");  
return;  
}