JDBC 连接池代码列子Word文件下载.docx
《JDBC 连接池代码列子Word文件下载.docx》由会员分享，可在线阅读，更多相关《JDBC 连接池代码列子Word文件下载.docx（25页珍藏版）》请在冰豆网上搜索。
;
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"
"
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!
preStatRef.close（）;
returnnull;
//判断是使用了createStatement语句
if（CREATESTATE.equals（method.getName（）））{
obj=method.invoke（conn,args）;
statRef=（Statement）obj;
returnobj;
}catch（ClassCastExceptionex）{
//判断是使用了prepareStatement语句
if（PREPARESTATEMENT.equals（method.getName（）））{
preStatRef=（PreparedStatement）obj;
//如果不支持事务，就不执行该事物的代码
if（（COMMIT.equals（method.getName（））||ROLLBACK.equals（method
.getName（）））
&
&
（!
isSupportTransaction（）））{
//设置最后一次访问时间，以便及时清除超时的连接
lastAccessTime=System.currentTimeMillis（）;
*创建连接的工厂，只能让工厂调用
*@paramfactory
*要调用工厂，并且一定被正确初始化
*@return连接
publicstaticConnectionProxygetConnection（ConnectionFactoryfactory,
ConnectionParamparam）{
//判断是否正确初始化的工厂
if（factory.isCreate（））{
ConnectionProxy_conn=newConnectionProxy（param）;
return_conn;
}else{
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;
//是否支持事务
//定义管理策略
privateintManageType=0;
*构造器
privateConnectionFactory（）{
ConnectionPool=newLinkedHashSet（）;
FreeConnectionPool=newLinkedHashSet（）;
*使用指定的参数创建一个连接池
publicConnectionFactory（ConnectionParamparam,FactoryParamfparam）
throwsSQLException{
if（（param==null）||（fparam==null））
thrownewSQLException（"
ConnectionParam和FactoryParam不能为空"
if（m_instance==null）{
synchronized（ConnectionFactory.class）{
//参数定制
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创建！
"
for（inti=0;
i<
m_instance.MinConnectionCount;
i++）{
ConnectionProxyconn=ConnectionProxy
.getConnection（m_instance,m_instance.connparam）;
if（conn==null）
continue;
connection创建"
m_instance.FreeConnectionPool.add（conn）;
//加入空闲连接池
m_instance.current_conn_count++;
//标志是否支持事务
m_instance.supportTransaction=conn
.isSupportTransaction（）;
//根据策略判断是否需要查询
if（m_instance.ManageType!
=0）{
Threadt=newThread（newFactoryManageThread（
m_instance））;
t.start（）;
*标志工厂是否已经创建
publicbooleanisCreate（）{
returnm_instance.isflag;
*从连接池中取一个空闲的连接
*@returnConnection
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<
m_instance.MaxConnectionCount）{
//新建连接到空闲连接池
intnewCount=0;
//取得要建立的数目
if（m_instance.MaxConnectionCount
-m_instance.current_conn_count>
=m_instance.MinConnectionCount）{
newCount=m_instance.MinConnectionCount;
newCount=m_instance.MaxConnectionCount
-m_instance.current_conn_count;
newCount;
ConnectionProxy_conn=ConnectionProxy.getConnection（
m_instance,connparam）;
m_instance.FreeConnectionPool.add（_conn）;
//如果不能新建，检查是否有已经归还的连接
ir=m_instance.ConnectionPool.iterator（）;
ConnectionProxy_conn=（ConnectionProxy）ir.next（）;
_conn.isFree（））{
cn=_conn.getFreeConnection（）;
_conn.setFree（false）;
m_instance.ConnectionPool.remove（_conn）;
//再次检查是否能分配连接
if（cn==null）{
ir=m_instance.FreeConnectionPool.iterator（）;
_conn.setFree（true）;
m_instance.FreeConnectionPool.remove（_conn）;
m_instance.ConnectionPool.add（_conn）;
if（cn==null）
//如果不能则说明无连接可用
没有可用的数据库连接"
GetConnection"
*关闭该连接池中的所有数据库连接
publicsynchronizedvoidclose（）throwsSQLException{
this.isflag=false;
SQLExceptionsqlError=null;
//关闭空闲池
（（ConnectionProxy）ir.next（））.close（）;
Closeconnection:
Free"
m_instance.current_conn_count--;
if（exinstanceofSQLException）{
sqlError=（SQLException）ex;
//关闭在使用的连接池
Using"
if（sqlError!
throwsqlError;
*返回是否支持事务
returnm_instance.supportTransaction;
*连接池调度管理
publicvoidschedule（）{
Iteratorir=null;
//检查是否有已经归还的连接
if（m_instance.MaxConnectionCount-m_instance.current_conn_count>
m_instance.
升级会员 