基于JDBC的数据库连接池技术研究与应用

Java应用程序访问数据库的基本原理

　　在Java语言中，JDBC（Java DataBase Connection）是应用程序与数据库沟通的桥梁,

　　即Java语言通过JDBC技术访问数据库。JDBC是一种“开放”的方案，它为数据库应用开发人员﹑数据库前台工具开发人员提供了一种标准的应用程序设计接口，使开发人员可以用纯Java语言编写完整的数据库应用程序。JDBC提供两种API，分别是面向开发人员的API和面向底层的JDBC驱动程序API，底层主要通过直接的JDBC驱动和JDBC-ODBC桥驱动实现与数据库的连接。

　　一般来说，Java应用程序访问数据库的过程（如图1所示）是：

　　①装载数据库驱动程序；

　　②通过JDBC建立数据库连接；

　　③访问数据库，执行SQL语句；

　　④断开数据库连接。

图1 Java数据库访问机制

　　JDBC作为一种数据库访问技术，具有简单易用的优点。但使用这种模式进行Web应用

　　程序开发，存在很多问题：首先，每一次Web请求都要建立一次数据库连接。建立连接是一个费时的活动，每次都得花费0.05s～1s的时间，而且系统还要分配内存资源。这个时间对于一次或几次数据库操作，或许感觉不出系统有多大的开销。可是对于现在的Web应用，尤其是大型电子商务网站，同时有几百人甚至几千人在线是很正常的事。在这种情况下，频繁的进行数据库连接操作势必占用很多的系统资源，网站的响应速度必定下降，严重的甚至会造成服务器的崩溃。不是危言耸听，这就是制约某些电子商务网站发展的技术瓶颈问题。其次，对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将不得不重启数据库。还有，这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。
数据库连接池（connection pool）的工作原理

　　1、基本概念及原理

　　由上面的分析可以看出，问题的根源就在于对数据库连接资源的低效管理。我们知道，

　　对于共享资源，有一个很著名的设计模式：资源池（Resource Pool）。该模式正是为了解决资源的频繁分配﹑释放所造成的问题。为解决上述问题，可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量﹑使用情况，为系统开发﹑测试及性能调整提供依据。连接池的基本工作原理见下图2。

图2 连接池的基本工作原理

　　2、服务器自带的连接池

　　JDBC的API中没有提供连接池的方法。一些大型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere等提供了连接池的机制，但是必须有其第三方的专用类方法支持连接池的用法。

　　 连接池关键问题分析

　　1、并发问题

　　为了使连接管理服务具有最大的通用性，必须考虑多线程环境，即并发问题。这个问题相对比较好解决，因为Java语言自身提供了对并发管理的支持，使用synchronized关键字即可确保线程是同步的。使用方法为直接在类方法前面加上synchronized关键字，如：

public synchronized Connection getConnection（）

2、多数据库服务器和多用户

　　对于大型的企业级应用，常常需要同时连接不同的数据库（如连接Oracle和Sybase）。如何连接不同的数据库呢？我们采用的策略是：设计一个符合单例模式的连接池管理类，在连接池管理类的唯一实例被创建时读取一个资源文件，其中资源文件中存放着多个数据库的url地址（<poolName.url>）﹑用户名（<poolName.user>）﹑密码（<poolName.password>）等信息。如tx.url=172.21.15.123：5000/tx_it，tx.user=yang，tx.password=yang321。根据资源文件提供的信息，创建多个连接池类的实例，每一个实例都是一个特定数据库的连接池。连接池管理类实例为每个连接池实例取一个名字，通过不同的名字来管理不同的连接池。

　　对于同一个数据库有多个用户使用不同的名称和密码访问的情况，也可以通过资源文件处理，即在资源文件中设置多个具有相同url地址，但具有不同用户名和密码的数据库连接信息。

　　3、事务处理

　　我们知道，事务具有原子性，此时要求对数据库的操作符合“ALL-ALL-NOTHING”原则,即对于一组SQL语句要么全做，要么全不做。

　　在Java语言中，Connection类本身提供了对事务的支持，可以通过设置Connection的AutoCommit属性为false,然后显式的调用commit或rollback方法来实现。但要高效的进行Connection复用，就必须提供相应的事务支持机制。可采用每一个事务独占一个连接来实现，这种方法可以大大降低事务管理的复杂性。

　　4、连接池的分配与释放

　　连接池的分配与释放，对系统的性能有很大的影响。合理的分配与释放，可以提高连接的复用度，从而降低建立新连接的开销，同时还可以加快用户的访问速度。

　　对于连接的管理可使用空闲池。即把已经创建但尚未分配出去的连接按创建时间存放到一个空闲池中。每当用户请求一个连接时，系统首先检查空闲池内有没有空闲连接。如果有就把建立时间最长（通过容器的顺序存放实现）的那个连接分配给他（实际是先做连接是否有效的判断，如果可用就分配给用户，如不可用就把这个连接从空闲池删掉，重新检测空闲池是否还有连接）；如果没有则检查当前所开连接池是否达到连接池所允许的最大连接数（maxConn）,如果没有达到，就新建一个连接，如果已经达到，就等待一定的时间（timeout）。如果在等待的时间内有连接被释放出来就可以把这个连接分配给等待的用户，如果等待时间超过预定时间timeout,则返回空值（null）。系统对已经分配出去正在使用的连接只做计数，当使用完后再返还给空闲池。对于空闲连接的状态，可开辟专门的线程定时检测，这样会花费一定的系统开销，但可以保证较快的响应速度。也可采取不开辟专门线程，只是在分配前检测的方法。

　　5、连接池的配置与维护

　　连接池中到底应该放置多少连接，才能使系统的性能最佳？系统可采取设置最小连接数（minConn）和最大连接数（maxConn）来控制连接池中的连接。最小连接数是系统启动时连接池所创建的连接数。如果创建过多，则系统启动就慢，但创建后系统的响应速度会很快；如果创建过少，则系统启动的很快，响应起来却慢。这样，可以在开发时，设置较小的最小连接数，开发起来会快，而在系统实际使用时设置较大的，因为这样对访问客户来说速度会快些。最大连接数是连接池中允许连接的最大数目，具体设置多少，要看系统的访问量，可通过反复测试，找到最佳点。

　　如何确保连接池中的最小连接数呢？有动态和静态两种策略。动态即每隔一定时间就对连接池进行检测，如果发现连接数量小于最小连接数，则补充相应数量的新连接,以保证连接池的正常运转。静态是发现空闲连接不够时再去检查。
连接池的实现

　　1、连接池模型

　　本文讨论的连接池包括一个连接池类（DBConnectionPool）和一个连接池管理类（DBConnetionPoolManager）。连接池类是对某一数据库所有连接的“缓冲池”，主要实现以下功能：①从连接池获取或创建可用连接；②使用完毕之后，把连接返还给连接池；③在系统关闭前，断开所有连接并释放连接占用的系统资源；④还能够处理无效连接（原来登记为可用的连接，由于某种原因不再可用，如超时，通讯问题），并能够限制连接池中的连接总数不低于某个预定值和不超过某个预定值。

　　连接池管理类是连接池类的外覆类（wrapper）,符合单例模式，即系统中只能有一个连接池管理类的实例。其主要用于对多个连接池对象的管理，具有以下功能：①装载并注册特定数据库的JDBC驱动程序；②根据属性文件给定的信息，创建连接池对象；③为方便管理多个连接池对象，为每一个连接池对象取一个名字，实现连接池名字与其实例之间的映射；④跟踪客户使用连接情况，以便需要是关闭连接释放资源。连接池管理类的引入主要是为了方便对多个连接池的使用和管理，如系统需要连接不同的数据库，或连接相同的数据库但由于安全性问题，需要不同的用户使用不同的名称和密码。

　　2、连接池实现

　　下面给出连接池类和连接池管理类的主要属性及所要实现的基本接口：

public class DBConnectionPool implements TimerListener{
private int checkedOut;//已被分配出去的连接数
private ArrayList freeConnections = new ArrayList();//容器，空闲池，根据//创建时间顺序存放已创建但尚未分配出去的连接
private int minConn;//连接池里连接的最小数量
private int maxConn;//连接池里允许存在的最大连接数
private String name;//为这个连接池取个名字，方便管理
private String password;//连接数据库时需要的密码
private String url;//所要创建连接的数据库的地址
private String user;//连接数据库时需要的用户名
public Timer timer;//定时器
public DBConnectionPool(String name, String URL, String user, String
password, int maxConn)//公开的构造函数
public synchronized void freeConnection(Connection con) //使用完毕之后，//把连接返还给空闲池
public synchronized Connection getConnection(long timeout)//得到一个连接，//timeout是等待时间
public synchronized void release()//断开所有连接，释放占用的系统资源
private Connection newConnection()//新建一个数据库连接
public synchronized void TimerEvent() //定时器事件处理函数

}

public class DBConnectionManager {
static private DBConnectionManager instance;//连接池管理类的唯一实例
static private int clients;//客户数量
private ArrayList drivers = new ArrayList();//容器，存放数据库驱动程序

private HashMap pools = new HashMap ();//以name/value的形式存取连接池//对象的名字及连接池对象
static synchronized public DBConnectionManager getInstance()//如果唯一的//实例instance已经创建，直接返回这个实例;否则，调用私有构造函数，创//建连接池管理类的唯一实例

private DBConnectionManager()//私有构造函数,在其中调用初始化函数init()

public void freeConnection(String name, Connection con)// 释放一个连接，//name是一个连接池对象的名字

public Connection getConnection(String name)//从名字为name的连接池对象//中得到一个连接

public Connection getConnection(String name, long time)//从名字为name

//的连接池对象中取得一个连接，time是等待时间

public synchronized void release()//释放所有资源

private void createPools(Properties props)//根据属性文件提供的信息，创建//一个或多个连接池

private void init()//初始化连接池管理类的唯一实例，由私有构造函数调用

private void loadDrivers(Properties props)//装载数据库驱动程序

}

　　3、连接池使用

　　上面所实现的连接池在程序开发时如何应用到系统中呢？下面以Servlet为例说明连接池的使用。

　　Servlet的生命周期是：在开始建立servlet时，调用其初始化（init）方法。之后每个用户请求都导致一个调用前面建立的实例的service方法的线程。最后，当服务器决定卸载一个servlet时，它首先调用该servlet的 destroy方法。

　　根据servlet的特点，我们可以在初始化函数中生成连接池管理类的唯一实例（其中包括创建一个或多个连接池）。如：

public void init() throws ServletException
{
　connMgr = DBConnectionManager.getInstance();
}

　　然后就可以在service方法中通过连接池名称使用连接池，执行数据库操作。最后在destroy方法中释放占用的系统资源，如：

public void destroy() {
　connMgr.release(); super.destroy();
}

*******************************************************************************************************************

package ql.jdbc;

/**
* @(#)ConnectionPool
* 该连接池被用于个人数据库开发中，以提高访问数据库的
* 整体性能。
* qixiaorui，学习于04.4.23号。该代码为原作者Karl Moss于98.3.11
* 编写。经过个人部分修改
*/

import java.sql.*;
import java.util.Properties;
import java.util.Vector;

public class ConnectionPool
 implements ql.timer.TimerListener{
 //数据库驱动程序名，如"jdbc.odbc.JdbcOdbcDriver"
 String sJdbcDriver;
 //数据库连接字符串
 String sJdbcConnectionURL;
 //连接池最小连接数
 int iConnectionPoolSize;
 //连接池最大连接数
 int iConnectionPoolMax;
 //每一个连接最多的使用次数
 int iConnectionUseCount;
 //连接超时（秒计）
 int iConnectionTimedOut;
 //数据库连接中用到的其他属性，如用户名或密码等
 Properties propJdbcProperties;
 //数据库连接池，存放的是ConnectionObject对象
 Vector vPool;
 //JDBC驱动程序本身允许的最大连接数
 int iMaxConnections=-1;
 //自定义的时间对象，用来记录超时
 ql.timer.Timer timer;
 /**
 * 根据配置文件ql/jdbc/ConnectionPool.cfg中相关内容
 * 初始化连接池
 * @return true 如果初始化成功，则返回为真。
 */
 public boolean initialize() throws Exception{
 return initialize("ql/jdbc/ConnectionPool.cfg");
 }
 public boolean initialize(String filename)
 throws Exception{
 //从配置文件中加载建立数据库连接需要的参数，任何
 //附加的配置参数都将自动作为该连接需要的参数
 boolean ret=loadConfig(filename);
 //如果配置文件没有错误
 if(ret){
 //建立连接池
 createPool();
 //设置记时器，并启动线程
 timer=new ql.timer.Timer(this,20);
 timer.start();
 }
 return ret;
 }
 /**
 * 根据给定的大小更新连接池
 */
 public synchronized void fillPool(int size){
 boolean useProperties=true;
 String user=null;
 String pass=null;

 //如果属性定义中存在用户名和密码
 if(propJdbcProperties!=null){
 if(propJdbcProperties.size()==2){
 user=getPropertyIgnoreCase(propJdbcProperties,"user");
 pass=getPropertyIgnoreCase(propJdbcProperties,"password");
 if(user!=null && pass!=null){
 useProperties=false;
 }
 }
 }
 while(vPool.size()<size){
 ConnectionObject co=new ConnectionObject();
 if(useProperties){
 try{
 co.con=DriverManager.getConnection(sJdbcConnectionURL,
 propJdbcProperties);
 }catch(Exception ex){}
 }
 else{
 try{
 co.con=DriverManager.getConnection(sJdbcConnectionURL,
 user,pass);
 }catch(Exception ex){}
 }
 //获取JDBC驱动程序允许的最大连接数
 if(vPool.size()==0){
 try{
 java.sql.DatabaseMetaData dmd=co.con.getMetaData();
 iMaxConnections=dmd.getMaxConnections();
 }catch(Exception ex){}
 }
 if(iMaxConnections>0 &&
 size>iMaxConnections){
 trace("警告：您设置的连接池大小超出了JDBC允许的最大连接数="+iMaxConnections);
 }
 co.inUse=false;
 //为Connection对象设置最近一次访问的时间
 touch(co);
 vPool.addElement(co);
 }
 }
 /**
 * 重新更新指定的连接，或者当该连接的使用计数达到规定的最大次数
 */
 public synchronized void close(java.sql.Connection con)
 {
 int index = find(con);
 if(index != -1) {
 ConnectionObject co = (ConnectionObject)
 vPool.elementAt(index);
 if((iConnectionUseCount>0) &&
 (co.useCount>=iConnectionUseCount)){
 trace("连接使用次数超界="+iConnectionUseCount);
 removeFromPool(index);
 }
 else {
 //！！将连接扔给连接池，保持为一个新的未使用的连接
 //注意关闭并不是释放内存，而是合理而高效地使用他们
 //这样的设计方法可以大大减少因为建立数据库连接而浪费的时间。
 touch(co);
 co.inUse = false;
 }
 }
 }
 /**
 * D销毁连接池和打开的所有连接、所有使用的内存资源
 */
 public void destroy(){
 try {
 if (timer!=null) {
 timer.stop();
 timer=null;
 }
 if (vPool!=null) {
 for(int i=0;i<vPool.size();i++){
 close((ConnectionObject)vPool.elementAt(i));
 }
 }
 vPool = null;
 }
 catch (Exception ex) {
 ex.printStackTrace();
 }
 }
 /**
 * >从连接池中获取一个可用的连接。如果没有则创建一个
 * 建立连接数目受配置文件中相关属性的限制
 */
 public synchronized java.sql.Connection getConnection(){
 if (vPool==null) return null;

 java.sql.Connection con=null;
 ConnectionObject connectionObject=null;
 int poolSize=vPool.size();

 for(int i=0;i<poolSize;i++){
 ConnectionObject co=(ConnectionObject)
 vPool.elementAt(i);
 if(co.isAvailable()){
 connectionObject=co;
 break;
 }
 }
 //如果取出的对象为空，则生成一个
 if(connectionObject==null){
 if((iConnectionPoolMax><0)||
 ((iConnectionPoolMax>0)&&
 (poolSize<iConnectionPoolMax))){
 int i=addConnection();
 if (i>=0){
 connectionObject=(ConnectionObject)
 vPool.elementAt(i);
 }
 }
 else {
 trace("最大连接超界");
 }
 }

 if(connectionObject!=null){
 connectionObject.inUse=true;
 connectionObject.useCount++;
 touch(connectionObject);
 con=connectionObject.con;
 }
 return con;
 }

 /**
 * 往连接池里增加一个新的连接
 * 如果成功，返回当前索引，否则返回-1
 */
 private int addConnection()
 {
 int index=-1;
 try {
 int size =vPool.size()+1;
 fillPool(size);
 if(size==vPool.size()){
 index=size-1;
 }
 }
 catch(Exception ex){
 ex.printStackTrace();
 }
 return index;
 }
 /**
 * 打印连接池中所有连接的详细信息
 */
 public void printPool()
 {
 System.out.println("--连接池--");
 if(vPool!=null){
 for(int i=0;i<vPool.size();i++){
 ConnectionObject co=(ConnectionObject)
 vPool.elementAt(i);
 System.out.println("第"+i+"个连接="+co);
 }
 }
 }

 /**
 * 该方法将被时钟每隔一定时间调用一次
 * 主要用来维护连接池的完整，清除不再使用的ConnectionObject
 * 按照最小数目生成新的ConnectionObject
 */
 public synchronized void TimerEvent(Object object){
 if (vPool == null) return;
 long now = System.currentTimeMillis();
 // 删除超时的连接
 for (int i=vPool.size()-1; i>=0; i--){
 ConnectionObject co = (ConnectionObject)
 vPool.elementAt(i);
 // 如果连接没有被使用或者最近一直没有被使用，则移除
 if (!co.inUse) {
 if ((iConnectionTimedOut>0) &&
 (co.lastAccess+(iConnectionTimedOut*1000)<now)) {
 removeFromPool(i);
 }
 }
 }
 // 移除所有关闭了的连接
 for(int i=vPool.size()-1;i>=0;i--){
 ConnectionObject co = (ConnectionObject)
 vPool.elementAt(i);
 try {
 if (co.con.isClosed()) {
 trace("连接已经因为不明原因被关闭");
 removeFromPool(i);
 }
 }
 catch (Exception ex) {
 }
 }
 // 重新维持连接池最小连接数
 try {
 if (vPool != null) {
 if (vPool.size()><iConnectionPoolSize){
 fillPool(iConnectionPoolSize);
 }
 }
 }
 catch (Exception ex) {
 ex.printStackTrace();
 }
 }
 /**
 * >返回给定连接对象在连接池里的索引值
 */
 private int find(java.sql.Connection con)
 {
 int index = -1;
 if((con!=null) && (vPool!=null)){
 for(int i=0;i<vPool.size();i++){
 ConnectionObject co=(ConnectionObject)
 vPool.elementAt(i);
 if (co.con==con){
 index=i;
 break;
 }
 }
 }
 return index;
 }
 /**
 * >将指定索引的ConnectionObject对象从连接池中移出
 */
 private synchronized void removeFromPool(int index){
 if (vPool!=null) {
 if (index<vPool.size()) {
 ConnectionObject co=(ConnectionObject)
 vPool.elementAt(index);
 close(co);
 vPool.removeElementAt(index);
 }
 }
 }
 /**
 * >关闭指定的ConnectionObject对象
 */
 private void close(ConnectionObject connectionObject){
 if(connectionObject!=null){
 if(connectionObject.con!=null) {
 try {
 connectionObject.con.close();
 }
 catch (Exception ex) {
 }
 connectionObject.con = null;
 }
 }
 }

 /**
 * 加载配置文件，如果配置文件有错误，则返回假
 */
 private boolean loadConfig(String filename)
 throws Exception{
 boolean ret=false;

 ClassLoader cl=getClass().getClassLoader();
 java.io.InputStream in;
 if(cl!=null){
 in=cl.getResourceAsStream(filename);
 }
 else{
 in=ClassLoader.getSystemResourceAsStream(filename);
 }
 if(in==null){
 throw new Exception("你定义的配置文件"+filename+"没有找到。");
 }
 else{
 try{
 //从挂接了文件的流中将内容读入Properties对象
 propJdbcProperties=new Properties();
 propJdbcProperties.load(in);

 sJdbcDriver=consume(propJdbcProperties,"JDBCDriver");
 sJdbcConnectionURL=consume(propJdbcProperties,"JDBCConnectionURL");
 iConnectionPoolSize=consumeInt(propJdbcProperties,"ConnectionPoolSize");
 iConnectionPoolMax=consumeInt(propJdbcProperties,"ConnectionPoolMax");
 iConnectionTimedOut=consumeInt(propJdbcProperties,"ConnectionTimedOut");
 iConnectionUseCount=consumeInt(propJdbcProperties,"ConnectionUseCount");

 ret=true;
 }catch(Exception ex){}
 finally{
 if(in!=null){
 try{
 in.close();
 }
 catch(Exception ex){
 }
 }
 }
 }
 return ret;
 }
 /**
 * 为ConnectionObject对象设置最近一次的访问时间
 */
 private void touch(ConnectionObject co){
 if(co!=null){
 co.lastAccess=System.currentTimeMillis();
 }
 }
 /**
 * 从Properties对象中获取一个指定名称的值
 * 如果找不到，返回假
 */
 private String getPropertyIgnoreCase(java.util.Properties prop,String name){
 if(prop==null || name==null) return null;
 String value=null;
 java.util.Enumeration enum=prop.propertyNames();
 while(enum.hasMoreElements()){
 String pName=(String) enum.nextElement();
 if (pName.equalsIgnoreCase(name)){
 value=prop.getProperty(pName);
 break;
 }
 }
 return value;
 }
 /**
 * 从Properties对象中取出相关内容的值，以字符串方式返回
 */
 private String consume(Properties prop,String key){
 String s=null;
 if(prop!=null && key!=null){
 s=prop.getProperty(key);
 if (s!=null){
 prop.remove(key);
 }
 }
 return s;
 }
 /**
 * 从Properties对象中取出相关内容的值，以整型数方式返回
 */
 private int consumeInt(Properties prop,String key){
 int n=-1;
 String value=consume(prop,key);

 if(value!=null){
 try{
 n=Integer.parseInt(value);
 }
 catch(Exception ex){
 }
 }
 return n;
 }
 /**
 * 初始化数据库连接池，同时计时器对象也被建立，以便
 * 监听超时的发生
 */
 private void createPool() throws Exception{
 if(sJdbcDriver==null){
 throw new Exception("属性JDBCDriver没有找到");
 }
 if(sJdbcConnectionURL==null){
 throw new Exception("属性JDBCConnectionURL没有找到");
 }
 if(iConnectionPoolSize<0){
 throw new Exception("属性ConnectionPoolSize没有找到");
 }
 if(iConnectionPoolSize==0){
 throw new Exception("属性ConnectionPoolSize非法");
 }

 if(iConnectionPoolSize<iConnectionPoolMax){
 iConnectionPoolMax=-1;
 }
 if(iConnectionTimedOut><0){
 //默认超时为三十分钟
 iConnectionTimedOut=30;
 }

 //将获取到的参数显示到控制台
 trace("JDBCDriver="+sJdbcDriver);
 trace("JDBCConnectionURL="+sJdbcConnectionURL);
 trace("ConnectionPoolSize="+iConnectionPoolSize);
 trace("ConnectionPoolMax="+iConnectionPoolMax);
 trace("ConnectionTiemdOut="+iConnectionTimedOut+"minutes");
 trace("ConnectionUseCount="+iConnectionUseCount);
 java.util.Enumeration enu=propJdbcProperties.keys();
 while(enu.hasMoreElements()){
 String key=(String) enu.nextElement();
 String value=propJdbcProperties.getProperty(key);
 trace("(JDBC)"+key+"="+value);
 }

 trace("注册JDBC驱动程序："+sJdbcDriver);
 java.sql.Driver d=(java.sql.Driver)
 Class.forName(sJdbcDriver).newInstance();
 vPool=new java.util.Vector();
 //更新连接池
 fillPool(iConnectionPoolSize);
 }

 /**
 * 显示字符串到控制台
 */
 private void trace(String s){
 //System.out.println("连接池:>"+s);
 }

}

/**
* 该类是包中私有类，定义了连接池中每一个单独的连接
*/
class ConnectionObject{
public java.sql.Connection con;
// 该连接当前是否在使用
public boolean inUse;
//最近一次访问的时间
public long lastAccess;
//该连接已经被使用了多少次
public int useCount;

/**
 * 确定该连接是否可用，条件是：不为空，没有被关闭且没有被使用
 * 如果可用则返回真
 */
public boolean isAvailable(){
 boolean available = false;
 try {
 if (con != null) {
 if (!inUse &&
 !con.isClosed()) {
 available = true;
 }
 }
 }
 catch (Exception ex) {
 }
 return available;
}
public String toString()
 {
 return "Connection=" + con + ",inUse=" + inUse +
 ",lastAccess=" + lastAccess + ",useCount=" + useCount;
 }
}