几种Java数据库连接池实现（三）<1>

package pool;
import java.lang.reflect.*;
import java.sql.*;
/**
*
* 定义数据库连接的代理类
*
*/
public class _Connection implements InvocationHandler {
// 定义连接
private Connection conn = null;
// 定义监控连接创建的语句
private Statement statRef = null;
private PreparedStatement prestatRef = null;
// 是否支持事务标志
private boolean supportTransaction = false;
// 数据库的忙状态
private boolean isFree = false;
// 最后一次访问时间
long lastAccessTime = 0;
// 定义要接管的函数的名字
String CREATESTATE = "createStatement";
String CLOSE = "close";
String PREPARESTATEMENT = "prepareStatement";
String COMMIT = "commit";
String ROLLBACK = "rollback";
/**
* 构造函数，采用私有，防止被直接创建
*
* @param param
* 连接参数
*/
private _Connection(ConnectionParam param) { // 记录日志
try {
// 创建连接
Class.forName(param.getDriver()).newInstance();
conn = DriverManager.getConnection(param.getUrl(), param.getUser(),
param.getPassword());
DatabaseMetaData dm = null;
dm = conn.getMetaData();
// 判断是否支持事务
supportTransaction = dm.supportsTransactions();
} catch (Exception e) {
e.printStackTrace();
}
}
/*
* (non-Javadoc)
* @see java.lang.reflect.InvocationHandler#invoke
* (java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object obj = null;
// 判断是否调用了close的方法，如果调用close方法则把连接置为无用状态
if (CLOSE.equals(method.getName())) {
// 设置不使用标志
setIsFree(false);
// 检查是否有后续工作，清除该连接无用资源
if (statRef != null)
statRef.close();
if (prestatRef != null)
prestatRef.close();
return null;
}
// 判断是使用了createStatement语句
if (CREATESTATE.equals(method.getName())) {
obj = method.invoke(conn, args);
statRef = (Statement) obj;// 记录语句
return obj;
}
// 判断是使用了prepareStatement语句
if (PREPARESTATEMENT.equals(method.getName())) {
obj = method.invoke(conn, args);
prestatRef = (PreparedStatement) obj;
return obj;
}
// 如果不支持事务，就不执行该事物的代码
if ((COMMIT.equals(method.getName()) || ROLLBACK.equals(method
.getName()))
&& (!isSupportTransaction()))
return null;
obj = method.invoke(conn, args);
// 设置最后一次访问时间，以便及时清除超时的连接
lastAccessTime = System.currentTimeMillis();
return obj;
}

/**
* 创建连接的工厂，只能让工厂调用
* @param factory
* 要调用工厂，并且一定被正确初始化
* @param param
* 连接参数
* @return 连接
*
*/
public static _Connection getConnection(ConnectionFactory factory,
ConnectionParam param) {
if (factory.isCreate()) {// 判断是否正确初始化的工厂
_Connection _conn = new _Connection(param);
return _conn;
} else {
return null;
}
}
public Connection getFreeConnection() {
// 返回数据库连接conn的接管类，以便截住close方法
Connection conn2 = (Connection) Proxy.newProxyInstance(conn.getClass()
.getClassLoader(), conn.getClass().getInterfaces(), this);
return conn2;
}
/**
*
* 该方法真正的关闭了数据库的连接
*
* @throws SQLException
*
*/
void close() throws SQLException {
// 由于类属性conn是没有被接管的连接，因此一旦调用close方法后就直接关闭连接
conn.close();
}
public void setIsFree(boolean value) {
isFree = value;
}
public boolean isFree() {
return isFree;
}
/**
*
* 判断是否支持事务
*
* @return boolean
*
*/
public boolean isSupportTransaction() {
return supportTransaction;
}
}

package pool;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class ConnectionFactory {
private static ConnectionFactory m_instance = null;
// 在使用的连接池
private LinkedHashSet<_Connection> ConnectionPool = null;
// 空闲连接池
private LinkedHashSet<_Connection> FreeConnectionPool = null;
// 最大连接数
private int MaxConnectionCount = 4;
// 最小连接数
private int MinConnectionCount = 2;
// 当前连接数
private int current_conn_count = 0;
// 连接参数
private ConnectionParam connparam = null;
// 是否创建工厂的标志
private boolean isflag = false;
// 是否支持事务
private boolean supportTransaction = false;
// 定义管理策略
private int ManageType = 0;
private ConnectionFactory() {
ConnectionPool = new LinkedHashSet<_Connection>();
FreeConnectionPool = new LinkedHashSet<_Connection>();
}
/**
*
* 使用指定的参数创建一个连接池
*
*/
public ConnectionFactory(ConnectionParam param, FactoryParam fparam)
throws SQLException {
// 不允许参数为空
if ((param == null) || (fparam == null))
throw new SQLException("ConnectionParam和FactoryParam不能为空");
if (m_instance == null) {
synchronized (ConnectionFactory.class) {
if (m_instance == null) {
// new instance
// 参数定制
m_instance = new ConnectionFactory();
m_instance.connparam = param;
m_instance.MaxConnectionCount = fparam.getMaxConn();
m_instance.MinConnectionCount = fparam.getMinConn();
m_instance.ManageType = fparam.getType();
m_instance.isflag = true;
// 初始化，创建MinConnectionCount个连接
System.out.println("connection factory 创建！");
try {
for (int i = 0; i < m_instance.MinConnectionCount; i++) {
_Connection _conn = _Connection.getConnection(
m_instance, m_instance.connparam);
if (_conn == null)
continue;
System.out.println("connection创建");
m_instance.FreeConnectionPool.add(_conn);// 加入空闲连接池
m_instance.current_conn_count++;
// 标志是否支持事务
m_instance.supportTransaction = _conn
.isSupportTransaction();
}
} catch (Exception e) {
e.printStackTrace();
}
// 根据策略判断是否需要查询
if (m_instance.ManageType != 0) {
Thread t = new Thread(
new FactoryMangeThread(m_instance));
t.start();
}
}
}
}
}

/**
*
* 标志工厂是否已经创建
*
* @return boolean
*
*/
public boolean isCreate() {
return m_instance.isflag;
}

/**
*
* 从连接池中取一个空闲的连接
*
* @return Connection
*
* @throws SQLException
*
*/
public synchronized Connection getFreeConnection() throws SQLException {
Connection conn = null;
// 获取空闲连接
Iterator iter = m_instance.FreeConnectionPool.iterator();
while (iter.hasNext()) {
_Connection _conn = (_Connection) iter.next();
// 找到未用连接
if (!_conn.isFree()) {
conn = _conn.getFreeConnection();
_conn.setIsFree(true);
// 移出空闲区
m_instance.FreeConnectionPool.remove(_conn);
// 加入连接池
m_instance.ConnectionPool.add(_conn);
break;
}
}
// 检查空闲池是否为空
if (m_instance.FreeConnectionPool.isEmpty()) {
// 再检查是否能够分配
if (m_instance.current_conn_count < m_instance.MaxConnectionCount) {
// 新建连接到空闲连接池
int newcount = 0;
// 取得要建立的数目
if (m_instance.MaxConnectionCount
- m_instance.current_conn_count >= m_instance.MinConnectionCount) {
newcount = m_instance.MinConnectionCount;
} else {
newcount = m_instance.MaxConnectionCount
- m_instance.current_conn_count;
}
// 创建连接
for (int i = 0; i < newcount; i++) {
_Connection _conn = _Connection.getConnection(m_instance,
m_instance.connparam);
m_instance.FreeConnectionPool.add(_conn);
m_instance.current_conn_count++;
}
} else {// 如果不能新建，检查是否有已经归还的连接
iter = m_instance.ConnectionPool.iterator();
while (iter.hasNext()) {
_Connection _conn = (_Connection) iter.next();
if (!_conn.isFree()) {
conn = _conn.getFreeConnection();
_conn.setIsFree(false);
m_instance.ConnectionPool.remove(_conn);
m_instance.FreeConnectionPool.add(_conn);
break;
}
}
}
}// if (FreeConnectionPool.isEmpty())
// 再次检查是否能分配连接
if (conn == null) {
iter = m_instance.FreeConnectionPool.iterator();
while (iter.hasNext()) {
_Connection _conn = (_Connection) iter.next();
if (!_conn.isFree()) {
conn = _conn.getFreeConnection();
_conn.setIsFree(true);
m_instance.FreeConnectionPool.remove(_conn);
m_instance.ConnectionPool.add(_conn);
break;
}
}
if (conn == null)// 如果不能则说明无连接可用
throw new SQLException("没有可用的数据库连接");
}
System.out.println("get connection");
return conn;
}

/**
*
* 关闭该连接池中的所有数据库连接
*
* @throws SQLException
*
*/
public synchronized void close() throws SQLException {
this.isflag = false;
SQLException excp = null;
// 关闭空闲池
Iterator iter = m_instance.FreeConnectionPool.iterator();
while (iter.hasNext()) {
try {
((_Connection) iter.next()).close();
System.out.println("close connection:free");
m_instance.current_conn_count--;
} catch (Exception e) {
if (e instanceof SQLException)
excp = (SQLException) e;
}
}
// 关闭在使用的连接池
iter = m_instance.ConnectionPool.iterator();
while (iter.hasNext()) {
try {
((_Connection) iter.next()).close();
System.out.println("close connection:inused");
m_instance.current_conn_count--;
} catch (Exception e) {
if (e instanceof SQLException)
excp = (SQLException) e;
}
}
if (excp != null)
throw excp;
}

/**
*
* 返回是否支持事务
*
* @return boolean
*
*/
public boolean isSupportTransaction() {
return m_instance.supportTransaction;
}

/**
*
* 连接池调度管理
*
*
*
*/
public void schedule() {
//Connection conn = null;
// 再检查是否能够分配
Iterator iter = null;
// 检查是否有已经归还的连接
iter = m_instance.ConnectionPool.iterator();
while (iter.hasNext()) {
_Connection _conn = (_Connection) iter.next();
if (!_conn.isFree()) {
//conn = _conn.getFreeConnection();
_conn.setIsFree(false);
m_instance.ConnectionPool.remove(_conn);
m_instance.FreeConnectionPool.add(_conn);
break;
}
}

if (m_instance.current_conn_count < m_instance.MaxConnectionCount) {
// 新建连接到空闲连接池
int newcount = 0;
// 取得要建立的数目
if (m_instance.MaxConnectionCount - m_instance.current_conn_count >= m_instance.MinConnectionCount) {
newcount = m_instance.MinConnectionCount;
} else {
newcount = m_instance.MaxConnectionCount
- m_instance.current_conn_count;
}
// 创建连接
for (int i = 0; i < newcount; i++) {
_Connection _conn = _Connection.getConnection(m_instance,
m_instance.connparam);
m_instance.FreeConnectionPool.add(_conn);
m_instance.current_conn_count++;
}
}
}
}

package pool;

import java.io.Serializable;

public class ConnectionParam implements Serializable {
private static final long serialVersionUID = 1L;

private String driver; // 数据库驱动程序

private String url; // 数据连接的URL

private String user; // 数据库用户名

private String password; // 数据库密码

/**
*
* 唯一的构造函数，需要指定连接的四个必要参数
*
* @param driver
* 数据驱动
*
* @param url
* 数据库连接url
*
* @param user
* 用户名
*
* @param password
* 密码
*
*/
public ConnectionParam(String driver, String url, String user,
String password) {
this.driver = driver;
this.url = url;
this.user = user;
this.password = password;
}

public String getDriver() {
return driver;
}

public String getPassword() {
return password;
}

public String getUrl() {
return url;
}

public String getUser() {
return user;
}

public void setDriver(String driver) {
this.driver = driver;
}

public void setPassword(String password) {
this.password = password;
}

public void setUrl(String url) {
this.url = url;
}

public void setUser(String user) {
this.user = user;
}

/**
*
* @see java.lang.Object#clone()
*
*/
public Object clone() {
ConnectionParam param = new ConnectionParam(driver, url, user, password);
return param;
}

/**
*
* @see java.lang.Object#equals(java.lang.Object)
*
*/
public boolean equals(Object obj) {
if (obj instanceof ConnectionParam) {
ConnectionParam param = (ConnectionParam) obj;
return ((driver.compareToIgnoreCase(param.getDriver()) == 0)
&& (url.compareToIgnoreCase(param.getUrl()) == 0)
&& (user.compareToIgnoreCase(param.getUser()) == 0) && (password
.compareToIgnoreCase(param.getPassword()) == 0));
}
return false;
}
}