JDBC 连接池代码列子.docx
《JDBC 连接池代码列子.docx》由会员分享，可在线阅读，更多相关《JDBC 连接池代码列子.docx（25页珍藏版）》请在冰豆网上搜索。
JDBC连接池代码列子
Java代码
importjava.sql.*;
importjava.lang.reflect.*;
importorg.omg.CORBA.portable.InvokeHandler;
importfreemarker.template.utility.ObjectConstructor;
/**
*定义数据库连接的代理类
*
*@authormark
*
*/
publicclassConnectionProxyimplementsInvocationHandler{
//定义连接
privateConnectionconn=null;
//定义监控连接创建的语句
privateStatementstatRef=null;
privatePreparedStatementpreStatRef=null;
//是否支持事务标志
privatebooleansupportTransaction=false;
//数据库的忙状态
privatebooleanisFree=false;
//最后一次访问时间
longlastAccessTime=0;
//定义要接管的函数的名字
StringCREATESTATE="createStatement";
StringCLOSE="close";
StringPREPARESTATEMENT="prepareStatement";
StringCOMMIT="commit";
StringROLLBACK="rollbakc";
/**
*构造函数，采用私有，防止被直接创建
*
*@paramparam
*连接参数
*/
privateConnectionProxy（ConnectionParamparam）{
//记录日志
try{
//创建连接
Class.forName（"oracle.jdbc.driver.OracleDriver"）;
conn=DriverManager.getConnection（"jdbc:
oracle:
thin:
@10.8.1.234:
1521:
WF4PPDB","PP42","PP42"）;
DatabaseMetaDatadm=null;
dm=conn.getMetaData（）;
//判断是否支持事务
supportTransaction=dm.supportsTransactions（）;
}catch（Exceptionex）{
ex.printStackTrace（）;
}
}
publicObjectinvoke（Objectproxy,Methodmethod,Object[]args）
throwsThrowable{
Objectobj=null;
//判断是否调用了close的方法，如果调用close方法则把连接置为无用状态
if（CLOSE.equals（method.getName（）））{
//设置不使用标志
setFree（false）;
if（statRef!
=null）
statRef.close（）;
if（preStatRef!
=null）
preStatRef.close（）;
returnnull;
}
//判断是使用了createStatement语句
if（CREATESTATE.equals（method.getName（）））{
try{
obj=method.invoke（conn,args）;
statRef=（Statement）obj;
returnobj;
}catch（ClassCastExceptionex）{
ex.printStackTrace（）;
}
}
//判断是使用了prepareStatement语句
if（PREPARESTATEMENT.equals（method.getName（）））{
obj=method.invoke（conn,args）;
preStatRef=（PreparedStatement）obj;
returnobj;
}
//如果不支持事务，就不执行该事物的代码
if（（COMMIT.equals（method.getName（））||ROLLBACK.equals（method
.getName（）））
&&（!
isSupportTransaction（）））{
returnnull;
}
obj=method.invoke（conn,args）;
//设置最后一次访问时间，以便及时清除超时的连接
lastAccessTime=System.currentTimeMillis（）;
returnobj;
}
/**
*创建连接的工厂，只能让工厂调用
*
*@paramfactory
*要调用工厂，并且一定被正确初始化
*@paramparam
*连接参数
*@return连接
*/
publicstaticConnectionProxygetConnection（ConnectionFactoryfactory,
ConnectionParamparam）{
//判断是否正确初始化的工厂
if（factory.isCreate（））{
ConnectionProxy_conn=newConnectionProxy（param）;
return_conn;
}else{
returnnull;
}
}
publicConnectiongetFreeConnection（）{
//返回数据库连接conn的接管类，以便截住close方法
Connectioncn=（Connection）Proxy.newProxyInstance（conn.getClass（）
.getClassLoader（）,conn.getClass（）.getInterfaces（）,this）;
returncn;
}
/**
*该方法真正的关闭了数据库的连接
*
*@throwsSQLException
*/
publicvoidclose（）throwsSQLException{
//由于类属性conn是没有被接管的连接，因此一旦调用close方法后就直接关闭连接
conn.close（）;
}
publicvoidsetFree（booleanisFree）{
this.isFree=isFree;
}
publicbooleanisFree（）{
returnisFree;
}
/**
*判断是否支持事务
*
*@returnboolean
*/
publicbooleanisSupportTransaction（）{
returnsupportTransaction;
}
}
importjava.sql.Connection;
importjava.sql.SQLException;
importjava.util.*;
publicclassConnectionFactory{
privatestaticConnectionFactorym_instance=null;
//在使用的连接池
privateLinkedHashSetConnectionPool=null;
//空闲连接池
privateLinkedHashSetFreeConnectionPool=null;
//最大连接数
privateintMaxConnectionCount=10;
//最小连接数S
privateintMinConnectionCount=2;
//当前连接数
privateintcurrent_conn_count=0;
//连接参数
privateConnectionParamconnparam=null;
//是否创建工厂的标志
privatebooleanisflag=false;
//是否支持事务
privatebooleansupportTransaction=false;
//定义管理策略
privateintManageType=0;
/**
*构造器
*/
privateConnectionFactory（）{
ConnectionPool=newLinkedHashSet（）;
FreeConnectionPool=newLinkedHashSet（）;
}
/**
*使用指定的参数创建一个连接池
*
*@throwsSQLException
*/
publicConnectionFactory（ConnectionParamparam,FactoryParamfparam）
throwsSQLException{
if（（param==null）||（fparam==null））
thrownewSQLException（"ConnectionParam和FactoryParam不能为空"）;
if（m_instance==null）{
synchronized（ConnectionFactory.class）{
if（m_instance==null）{
//参数定制
m_instance=newConnectionFactory（）;
connparam=param;
m_instance.MaxConnectionCount=fparam
.getMaxConnectionCount（）;
m_instance.MinConnectionCount=fparam
.getMinConnectionCount（）;
m_instance.ManageType=fparam.getManageType（）;
m_instance.isflag=true;
//初始化，创建MinConnectionCount个连接
System.out.println（"connectionfactory创建！
"）;
try{
for（inti=0;iConnectionProxyconn=ConnectionProxy
.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（Exceptionex）{
ex.printStackTrace（）;
}
//根据策略判断是否需要查询
if（m_instance.ManageType!
=0）{
Threadt=newThread（newFactoryManageThread（
m_instance））;
t.start（）;
}
}
}
}
}
/**
*标志工厂是否已经创建
*
*@returnboolean
*/
publicbooleanisCreate（）{
returnm_instance.isflag;
}
/**
*从连接池中取一个空闲的连接
*
*@returnConnection
*@throwsSQLException
*/
publicsynchronizedConnectiongetFreeConnection（）throwsSQLException{
Connectioncn=null;
//获取空闲连接
Iteratorir=m_instance.FreeConnectionPool.iterator（）;
while（ir.hasNext（））{
ConnectionProxyconn=（ConnectionProxy）ir.next（）;
//找到未用的连接
if（!
conn.isFree（））{
cn=conn.getFreeConnection（）;
conn.setFree（true）;
//移出空闲区
m_instance.FreeConnectionPool.remove（conn）;
//加入连接池
m_instance.ConnectionPool.add（conn）;
break;
}
}
//检查空闲池是否为空
if（m_instance.FreeConnectionPool.isEmpty（））{
//再检查是否能够分配
if（m_instance.current_conn_count//新建连接到空闲连接池
intnewCount=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（inti=0;iConnectionProxy_conn=ConnectionProxy.getConnection（
m_instance,connparam）;
m_instance.FreeConnectionPool.add（_conn）;
m_instance.current_conn_count++;
}
}else{
//如果不能新建，检查是否有已经归还的连接
ir=m_instance.ConnectionPool.iterator（）;
while（ir.hasNext（））{
ConnectionProxy_conn=（ConnectionProxy）ir.next（）;
if（!
_conn.isFree（））{
cn=_conn.getFreeConnection（）;
_conn.setFree（false）;
m_instance.ConnectionPool.remove（_conn）;
m_instance.FreeConnectionPool.add（_conn）;
break;
}
}
}
}
//再次检查是否能分配连接
if（cn==null）{
ir=m_instance.FreeConnectionPool.iterator（）;
while（ir.hasNext（））{
ConnectionProxy_conn=（ConnectionProxy）ir.next（）;
if（!
_conn.isFree（））{
cn=_conn.getFreeConnection（）;
_conn.setFree（true）;
m_instance.FreeConnectionPool.remove（_conn）;
m_instance.ConnectionPool.add（_conn）;
break;
}
}
if（cn==null）
//如果不能则说明无连接可用
thrownewSQLException（"没有可用的数据库连接"）;
}
System.out.println（"GetConnection"）;
returncn;
}
/**
*关闭该连接池中的所有数据库连接
*
*@throwsSQLException
*/
publicsynchronizedvoidclose（）throwsSQLException{
this.isflag=false;
SQLExceptionsqlError=null;
//关闭空闲池
Iteratorir=m_instance.FreeConnectionPool.iterator（）;
while（ir.hasNext（））{
try{
（（ConnectionProxy）ir.next（））.close（）;
System.out.println（"Closeconnection:
Free"）;
m_instance.current_conn_count--;
}catch（Exceptionex）{
if（exinstanceofSQLException）{
sqlError=（SQLException）ex;
}
}
}
//关闭在使用的连接池
ir=m_instance.ConnectionPool.iterator（）;
while（ir.hasNext（））{
try{
（（ConnectionProxy）ir.next（））.close（）;
System.out.println（"Closeconnection:
Using"）;
}catch（Exceptionex）{
if（exinstanceofSQLException）{
sqlError=（SQLException）ex;
}
}
}
if（sqlError!
=null）
throwsqlError;
}
/**
*返回是否支持事务
*
*@returnboolean
*/
publicbooleanisSupportTransaction（）{
returnm_instance.supportTransaction;
}
/**
*连接池调度管理
*
*/
publicvoidschedule（）{
Connectioncn=null;
//再检查是否能够分配
Iteratorir=null;
//检查是否有已经归还的连接
ir=m_instance.ConnectionPool.iterator（）;
while（ir.hasNext（））{
ConnectionProxy_conn=（ConnectionProxy）ir.next（）;
if（!
_conn.isFree（））{
cn=_conn.getFreeConnection（）;
_conn.setFree（false）;
m_instance.ConnectionPool.remove（_conn）;
m_instance.FreeConnectionPool.add（_conn）;
break;
}
}
if（m_instance.current_conn_count//新建连接到空闲连接池
intnewCount=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（inti=0;iConnectionProxy_conn=ConnectionProxy.getConnection（
m_instance,connparam）;
m_instance.
升级会员 