数据库连接池的应用.docx
《数据库连接池的应用.docx》由会员分享，可在线阅读，更多相关《数据库连接池的应用.docx（18页珍藏版）》请在冰豆网上搜索。
数据库连接池的应用
应用数据库连接池共用到三个文件。
文件一：
主要的功能为：
标明要连接的数据库的名称，用户名，密码。
drivers=net.sourceforge.jtds.jdbc.Driver
logfile=c:
\\DBConnectionManager2.log
idb.url=jdbc:
jtds:
sqlserver:
//localhost:
1433/;DatabaseName=book
book为自己的数据库名。
idb.maxconn=2
2用于指定建立的最大的连接条数。
idb.user=sa
sa代表数据库的用户名。
idb.password=""
数据库的密码。
改好后保存，会形成新的文件：
此文件的作用是：
没有什么作用。
只是用EditPlus找开此中会形成这样的一个文件。
如果要对此文件进行了修改。
那么要重启apach.
文件二：
里面是连接池的编写程序，主要是以备后面调用。
在DOS当中运行此文件，运行方法：
1、选转到D盘：
方法：
D：
然后打回车。
2、利用cd的方法转到cnbook\web-inf\classes>此处不能转到db下再执行.java文件。
3、javacdb\DBConnectionManager.java然后javaDBConnectionManager后就会形成相应的class文件。
（此处必须这样写，因为里面含有两个类，有一个类在运行时会用到另一个类，在文件三中才用这个解释方法：
在文件三编译时会用到文件二中生成的两个类，所以只要到转到classes即可，而此处只需转到db下，然后javacDBConnectionManager.java对它进行编译就会生成两个.classes文件。
）
在DOS中运可生成两个class文件。
因为。
java文件中有两个类，所以形成两个。
Class文件，分别为：
packagedb;
importjava.io.*;
importjava.sql.*;
importjava.util.*;
importjava.util.Date;
/**连接池
*管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接
*池的访问.客户程序可以调用getInstance（）方法访问本类的唯一实例.
*/
publicclassDBConnectionManager{
staticprivateDBConnectionManagerinstance;//唯一实例
staticprivateintclients;
privateVectordrivers=newVector（）;
privatePrintWriterlog;
privateHashtablepools=newHashtable（）;
/**
*返回唯一实例.如果是第一次调用此方法,则创建实例
*
*@returnDBConnectionManager唯一实例
*/
staticsynchronizedpublicDBConnectionManagergetInstance（）{
if（instance==null）{
instance=newDBConnectionManager（）;
}
clients++;
returninstance;
}
/**
*建构函数私有以防止其它对象创建本类实例
*/
privateDBConnectionManager（）{
init（）;
}
/**
*将连接对象返回给由名字指定的连接池
*
*@paramname在属性文件中定义的连接池名字
*@paramcon连接对象
*/
publicvoidfreeConnection（Stringname,Connectioncon）{
DBConnectionPoolpool=（DBConnectionPool）pools.get（name）;
if（pool!
=null）{
pool.freeConnection（con）;
}
}
/**
*获得一个可用的（空闲的）连接.如果没有可用连接,且已有连接数小于最大连接数
*限制,则创建并返回新连接
*
*@paramname在属性文件中定义的连接池名字
*@returnConnection可用连接或null
*/
publicConnectiongetConnection（Stringname）{
DBConnectionPoolpool=（DBConnectionPool）pools.get（name）;
if（pool!
=null）{
returnpool.getConnection（）;
}
returnnull;
}
/**
*获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制,
*则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.
*
*@paramname连接池名字
*@paramtime以毫秒计的等待时间
*@returnConnection可用连接或null
*/
publicConnectiongetConnection（Stringname,longtime）{
DBConnectionPoolpool=（DBConnectionPool）pools.get（name）;
if（pool!
=null）{
returnpool.getConnection（time）;
}
returnnull;
}
/**
*关闭所有连接,撤销驱动程序的注册
*/
publicsynchronizedvoidrelease（）{
//等待直到最后一个客户程序调用
if（--clients!
=0）{
return;
}
EnumerationallPools=pools.elements（）;
while（allPools.hasMoreElements（））{
DBConnectionPoolpool=（DBConnectionPool）allPools.nextElement（）;
pool.release（）;
}
EnumerationallDrivers=drivers.elements（）;
while（allDrivers.hasMoreElements（））{
Driverdriver=（Driver）allDrivers.nextElement（）;
try{
DriverManager.deregisterDriver（driver）;
log（"撤销JDBC驱动程序"+driver.getClass（）.getName（）+"的注册"）;
}
catch（SQLExceptione）{
log（e,"无法撤销下列JDBC驱动程序的注册:
"+driver.getClass（）.getName（））;
}
}
}
/**
*根据指定属性创建连接池实例.
*
*@paramprops连接池属性
*/
privatevoidcreatePools（Propertiesprops）{
EnumerationpropNames=props.propertyNames（）;
while（propNames.hasMoreElements（））{
Stringname=（String）propNames.nextElement（）;
if（name.endsWith（".url"））{
StringpoolName=name.substring（0,name.lastIndexOf（"."））;
Stringurl=props.getProperty（poolName+".url"）;
if（url==null）{
log（"没有为连接池"+poolName+"指定URL"）;
continue;
}
Stringuser=props.getProperty（poolName+".user"）;
Stringpassword=props.getProperty（poolName+".password"）;
Stringmaxconn=props.getProperty（poolName+".maxconn","0"）;
intmax;
try{
max=Integer.valueOf（maxconn）.intValue（）;
}
catch（NumberFormatExceptione）{
log（"错误的最大连接数限制:
"+maxconn+".连接池:
"+poolName）;
max=0;
}
DBConnectionPoolpool=
newDBConnectionPool（poolName,url,user,password,max）;
pools.put（poolName,pool）;
log（"成功创建连接池"+poolName）;
}
}
}
/**
*读取属性完成初始化
*/
privatevoidinit（）{
InputStreamis=getClass（）.getResourceAsStream（"db.properties"）;
PropertiesdbProps=newProperties（）;
try{
dbProps.load（is）;
}
catch（Exceptione）{
System.err.println（"不能读取属性文件."+
"请确保db.properties在CLASSPATH指定的路径中"）;
return;
}
StringlogFile=dbProps.getProperty（"logfile","DBConnectionManager.log"）;
try{
log=newPrintWriter（newFileWriter（logFile,true）,true）;
}
catch（IOExceptione）{
System.err.println（"无法打开日志文件:
"+logFile）;
log=newPrintWriter（System.err）;
}
loadDrivers（dbProps）;
createPools（dbProps）;
}
/**
*装载和注册所有JDBC驱动程序
*
*@paramprops属性
*/
privatevoidloadDrivers（Propertiesprops）{
StringdriverClasses=props.getProperty（"drivers"）;
StringTokenizerst=newStringTokenizer（driverClasses）;
while（st.hasMoreElements（））{
StringdriverClassName=st.nextToken（）.trim（）;
try{
Driverdriver=（Driver）
Class.forName（driverClassName）.newInstance（）;
DriverManager.registerDriver（driver）;
drivers.addElement（driver）;
log（"成功注册JDBC驱动程序"+driverClassName）;
}
catch（Exceptione）{
log（"无法注册JDBC驱动程序:
"+
driverClassName+",错误:
"+e）;
}
}
}
/**
*将文本信息写入日志文件
*/
privatevoidlog（Stringmsg）{
log.println（newDate（）+":
"+msg）;
}
/**
*将文本信息与异常写入日志文件
*/
privatevoidlog（Throwablee,Stringmsg）{
log.println（newDate（）+":
"+msg）;
e.printStackTrace（log）;
}
/**
*此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最
*大连接数为止.在返回连接给客户程序之前,它能够验证连接的有效性.
*/
classDBConnectionPool{
privateintcheckedOut;
privateVectorfreeConnections=newVector（）;
privateintmaxConn;
privateStringname;
privateStringpassword;
privateStringURL;
privateStringuser;
/**
*创建新的连接池
*
*@paramname连接池名字
*@paramURL数据库的JDBCURL
*@paramuser数据库帐号,或null
*@parampassword密码,或null
*@parammaxConn此连接池允许建立的最大连接数
*/
publicDBConnectionPool（Stringname,StringURL,Stringuser,Stringpassword,
intmaxConn）{
this.name=name;
this.URL=URL;
this.user=user;
this.password=password;
this.maxConn=maxConn;
}
/**
*将不再使用的连接返回给连接池
*
*@paramcon客户程序释放的连接
*/
publicsynchronizedvoidfreeConnection（Connectioncon）{
//将指定连接加入到向量末尾
log（"释放前"+freeConnections.size（））;
freeConnections.addElement（con）;
checkedOut--;
notifyAll（）;
log（"释放后"+freeConnections.size（））;
}
/**
*从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接
*数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之,
*然后递归调用自己以尝试新的可用连接.
*/
publicsynchronizedConnectiongetConnection（）{
Connectioncon=null;
if（freeConnections.size（）>0）{
//获取向量中第一个可用连接
con=（Connection）freeConnections.firstElement（）;
freeConnections.removeElementAt（0）;
try{
if（con.isClosed（））{
log（"从连接池"+name+"删除一个无效连接"）;
//递归调用自己,尝试再次获取可用连接
con=getConnection（）;
}
}
catch（SQLExceptione）{
log（"从连接池"+name+"删除一个无效连接"）;
//递归调用自己,尝试再次获取可用连接
con=getConnection（）;
}
}
elseif（maxConn==0||checkedOutcon=newConnection（）;
}
if（con!
=null）{
checkedOut++;
}
log（"获取连接前"+freeConnections.size（））;
returncon;
}
/**
*从连接池获取可用连接.可以指定客户程序能够等待的最长时间
*参见前一个getConnection（）方法.
*
*@paramtimeout以毫秒计的等待时间限制
*/
publicsynchronizedConnectiongetConnection（longtimeout）{
longstartTime=newDate（）.getTime（）;
Connectioncon;
while（（con=getConnection（））==null）{
try{
wait（timeout）;
}
catch（InterruptedExceptione）{}
if（（newDate（）.getTime（）-startTime）>=timeout）{
//wait（）返回的原因是超时
returnnull;
}
}
returncon;
}
/**
*关闭所有连接
*/
publicsynchronizedvoidrelease（）{
EnumerationallConnections=freeConnections.elements（）;
while（allConnections.hasMoreElements（））{
Connectioncon=（Connection）allConnections.nextElement（）;
try{
con.close（）;
log（"关闭连接池"+name+"中的一个连接"）;
}
catch（SQLExceptione）{
log（e,"无法关闭连接池"+name+"中的连接"）;
}
}
freeConnections.removeAllElements（）;
}
/**
*创建新的连接
*/
privateConnectionnewConnection（）{
Connectioncon=null;
try{
if（user==null）{
con=DriverManager.getConnection（URL）;
}
else{
con=DriverManager.getConnection（URL,user,password）;
}
log（"连接池"+name+"创建一个新的连接"）;
}
catch（SQLExceptione）{
log（e,"无法创建下列URL的连接:
"+URL）;
returnnull;
}
returncon;
}
}
}
文件三：
主要用于连接数据库。
编缉方法：
在dos当中转到cnbook\web-inf\classes>javacdb\dbconn.java就会形成.class文件
。
为什么此时路径只需写到classes即可。
因为在dbconn.java编译中用到了db包中的文件二中的己运行成功的两个文件（即上面的两个.class文件。
）所以如果把路径写到db后再运行就会提示找不到所要引用的文件。
packagedb;
importjava.sql.*;
importdb.DBConnectionManager;
publicclassdbconn
{
DBConnectionManagerdba=null;
Connectionconn=null;
ResultSetrs=null;
Statementstmt=null;
publicdbconn（）
{
try{
dba=DBConnectionManager.getInstance（）;
conn=dba.getConnection（"idb"）;
}
catch（Exceptione）{
System.out.println（e.toString（））;
}
}
publicResultSetQuery（Stringsql）
{
try{
stmt=conn.createStatement（ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE）;
rs=stmt.executeQuery（sql）;
}
catch（Exceptione）
{
System.out.println（e.toString（））;
}
finally{
returnrs;
}
}
publicintUpdate（Stringsql）
{inti=0;
try
{
stmt=conn.createStatement（ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE）;
i=stmt.executeUpdate（sql）;
}
catch（Exceptione）
{
System.out.println（e.toString（））;
}
returni;
}
publicvoidclose（）
{
try{
dba.freeConnection（"idb",conn）;
}
catch（Exceptione）
{
dba.freeConnection（"idb",conn）;
System.out.println（e.toString（））;
}
}
}
建了
文件之后会在c盘生成一个DBConnectionManager2文件。
此文件的作用是用于查看数据库连接池是否连接成功。
SatAug1215:
20:
53CST2000:
成功注册JDBC驱动程序net.sourceforge.jtds.jdbc.Driver
升级会员 