package db;



import java.sql.*;

import java.util.Date;


public class connectionWithIdx {     
        ////定义带有索引的数据库连接类

  public Connection connection;                 
  
  public int idx;  
  //定义数据库连接的索引
  public long startime;   
 //thread flag.
  

  public connectionWithIdx() {        
       ////初始化connectionWithIdx类
      
   
 Connection connection = null;
 
   int idx = 0;
    
  
//  Date dt=new Date();
 
 //  startime=dt.getTime();
    
 
 }

}
2.再定义一个数据库连接管理类.
package db;



import java.sql.*;


public class dataSourceManager {   

 //

  public dataSourceManager() {
  }

 

 public Connection getConnection()  //
 
 {

    //  DatabaseLocator.getJdbcClass();
  
  try
   
 {
    
  Class.forName(DatabaseLocator.getJdbcClass());  
 //
      
     
 String url = DatabaseLocator.getJdbcUrl() ;  
 
      
     
 String pwd=DatabaseLocator.getJdbcPwd();
    
  String user=DatabaseLocator.getJdbcUser();
  
   
 
      Connection connection = DriverManager.getConnection(url,user,pwd);   
//
      
      
return connection;  
   
   //
   
 }
  
  
    catch(SQLException ex){     
                     //
    
  System.out.println("\nERROR:----- SQLException -----\n");
    
  while (ex != null) 
{
      
  System.out.println("Message:   " + ex.getMessage());
      
  System.out.println("SQLState:  " + ex.getSQLState());
    
    System.out.println("ErrorCode: " + ex.getErrorCode());
   
     ex = ex.getNextException();
      }
    
}
    catch(Exception ex ) {
    
  ex.printStackTrace();
    }
   
 return null;
  
}

}
3.再定义一个主要连接类.

package db;

import java.sql.*;


import java.util.*;

import java.util.Date;


import com.util.Reminder;



public class connectionPoolManager {

    
    
  private static connectionPoolManager instance;  
//定义服务器端连接池管理器的唯一实例
     
 
  private static int st=8;   // 连接使用时间.
(    一个不是很恰当的方法当遇到不可捕促的错误时,强行断开连接.)

  private static int poolSize = 
 DatabaseLocator.getConnpoolsize(); 
 //定义连接池的容量
     

 private Vector con_Vector;     
        //定义存放数据库连接实例的数组
      
    

  public boolean[] inUse;   
            //定义判断数据库连接是否可用的数组
      
    
  private boolean closed = false;       
 //定义判断连接池是否已经销毁的变量
      
    
  //////
     
 private Reminder reminder;           
  //定义一个计时器.

      
static synchronized public connectionPoolManager getInstance() { 
 //返回服务器端的唯一连接池管理器实例
      
  
if (instance == null) { 
             //若服务器端存在连接池管理器实例，则返回此实例，若不存在，则创建后返回实例

          instance = new connectionPoolManager();
       
 }
      

  return instance;
     
 }

     
 public connectionPoolManager() {  
    //连接池管理器初始化函数
       
 con_Vector = new Vector(poolSize); 
 //初始化存放数据库连接的数组
       
 inUse = new boolean[poolSize];
    
    try
      
  {
         
 setupConnectionPool();
       
 }
       
 catch(Exception ex)
        {
     
     ex.printStackTrace();
      
  }
    
  }

     

 private void setupConnectionPool() throws SQLException {  
//建立数据库连接池函数
       

 for (int i=0; i<poolSize; i++)    
   //调用连接数据源管理器类向连接池中加入数据库连接
    
    {
         
 Connection connection = new dataSourceManager().getConnection();
     
    con_Vector.addElement(connection);
         
 inUse[i] = false;    
             
 //设置新加入的数据库连接为未使用状态
        }
    
  }

      public connectionWithIdx getConnection()  
  //返回带有索引的数据库连接
      {
       
 if (closed)                         
 //如果连接池已销毁，则首先建立数据库连接池
      
  {
         
 try
       
   {
    
        setupConnectionPool();
        
  }
       
   catch(Exception ex)
       
   {
         
   ex.printStackTrace();
         
 }
        
  closed = false;

         
 System.out.println("连接池已开放");
       
 }
        
     
   connectionWithIdx con = null;
    

    
      
  for (int i=0; i<con_Vector.size(); i++)      
  //搜索未使用的数据库连接
        
{
        
  if(inUse[i]==false)                   
 //若存在未被使用的数据库连接，则使用此连接
      
    {
            con = new connectionWithIdx();      
 //建立带有索引的数据库连接类实例
            
con.connection = (Connection)con_Vector.elementAt(i); 
 //使用未被使用的数据库连接建立带有索引的数据库连接类实例
      
      con.idx = i;                         //为此实例数据库连接的索引赋值
    
        inUse[i] = true;   //将连接池中此数据库连接设置为已被使用状态
          
  //
            
            reminder=new Reminder(i ,st);        
// 计时器,释放连接
       
            int freeCon = 0;                  
   //判断连接池中有多少未被使用的数据库连接
            
for(int j=0; j<con_Vector.size(); j++)
            
{
            
  if(inUse[j]==false)
             
 {
              
  freeCon++;
            

  }
        
  
  }
            
System.out.println("连接池中共有" + freeCon + "个未被使用的连接");


            return con;                     
    //返回带有索引的数据库连接类实例
        
  }
    
    }
        int freeCon = 0;              
   //若所有数据库连接都处于被使用状态，则返回空值
    
    for(int i=0; i<con_Vector.size(); i++)
       
 {
    
      if(inUse[i]==false)
          {
           
 freeCon++;
          }
        }
       
 System.out.println("连接池中共有" + freeCon + "个未被使用的连接");
    
    return con;
     
 }

      
    
  public void freeConnection(int connectionIdx)  
//将使用完的数据库连接放回到连接池中
     
 {
        
  
       
 inUse[connectionIdx] = false;         
   //将连接池中此数据库连接设置为未使用状态
     
   
        int freeCon = 0;                      
   //判断连接池中有多少未被使用的数据库连接
    
 
   for(int i=0; i<con_Vector.size(); i++)
     
   {
          if(inUse[i]==false)
         
 {
    
        freeCon++;
          }
      
  }
      
  System.out.println("连接池中共有" + freeCon + "个未被使用的连接");
     
 //  closeConnection();                //试图关闭连接池
    
  }

    
  public void closeConnection()      
 //若没有用户使用此连接池中的连接，则销毁连接池

      {
        int freeCon = 0;                 
 //判断连接池中有多少未被使用的数据库连接
     
   for(int i=0; i<con_Vector.size(); i++)
     
   {
          if(inUse[i]==false)
         
 {
            freeCon++;
          }
    
    }
        if(freeCon==poolSize)          
 //若未被使用的数据库连接等于连接池的容量，则销毁连接池
    
    {
          try
          {
        
    for(int i=0; i<poolSize; i++)
          
  {
    
          ((Connection)con_Vector.elementAt(i)).close();
    
          
              inUse[i] = false;
          
  }
    
    
  }
    

      catch(Exception ex)
         
 {
       
     ex.printStackTrace();
          
}
     
     closed = true;
        
  System.out.println("连接池已关闭");
       
 }
      }
    

}

本人在实际项目中运用过,切实可用.