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("連接池已關閉");
       
 }
      }
    

}

本人在實際項目中運用過,切實可用.