數據庫連接池的JAVA代碼實現

package scut.ailab.connectionpool;

import java.lang.reflect.*;

import java.sql.*;

/**

* @author youyongming

* 定義數據庫連接的代理類

*/

public class _Connection implements InvocationHandler {

//定義連接

private Connection conn = null;

//定義監控連接創建的語句

private Statement statRef = null;

private PreparedStatement prestatRef = null;

//是否支持事務標志

private boolean supportTransaction = false;

//數據庫的忙狀態

private boolean isFree = false;

//最后一次訪問時間

long lastAccessTime = 0;

//定義要接管的函數的名字

String CREATESTATE = "createStatement";

String CLOSE = "close";

String PREPARESTATEMENT = "prepareStatement";

String COMMIT = "commit";

String ROLLBACK = "rollback";

/**

* 構造函數，采用私有，防止被直接創建

* @param param 連接參數

*/

private _Connection(ConnectionParam param) {

  //記錄日至

  

   try{

   //創建連接

    Class.forName(param.getDriver()).newInstance();

    conn = DriverManager.getConnection(param.getUrl(),param.getUser(), param.getPassword());   

    DatabaseMetaData dm = null;

    dm = conn.getMetaData();

   //判斷是否支持事務

    supportTransaction = dm.supportsTransactions();

   }

   catch(Exception e)

   {

    e.printStackTrace();

   }

}

/* (non-Javadoc)

* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])

*/

public Object invoke(Object proxy, Method method, Object[] args)

   throws Throwable {

    Object obj = null;

   //判斷是否調用了close的方法，如果調用close方法則把連接置為無用狀態

    if(CLOSE.equals(method.getName()))

    {

    //設置不使用標志

     setIsFree(false);

    //檢查是否有后續工作，清除該連接無用資源

     if (statRef != null)

      statRef.close();

     if (prestatRef != null)

      prestatRef.close();

     return null;

    }

   //判斷是使用了createStatement語句

    if (CREATESTATE.equals(method.getName()))

    {

     obj = method.invoke(conn, args);

     statRef = (Statement)obj;//記錄語句

     return obj;

    }

   //判斷是使用了prepareStatement語句

    if (PREPARESTATEMENT.equals(method.getName()))

    {

     obj = method.invoke(conn, args);

     prestatRef = (PreparedStatement)obj;

     return obj;

    }

   //如果不支持事務，就不執行該事物的代碼

    if ((COMMIT.equals(method.getName())||ROLLBACK.equals(method.getName())) && (!isSupportTransaction()))

     return null;   

    obj = method.invoke(conn, args); 

   //設置最后一次訪問時間，以便及時清除超時的連接    lastAccessTime = System.currentTimeMillis();

    return obj;

}

/**

* 創建連接的工廠，只能讓工廠調用

* @param factory 要調用工廠，并且一定被正確初始化

* @param param 連接參數

* @return 連接

*/

static public _Connection getConnection(ConnectionFactory factory, ConnectionParam param)

{

   if (factory.isCreate())//判斷是否正確初始化的工廠

   {

    _Connection _conn = new _Connection(param);

    return _conn;

   }

   else

    return null;

}

public Connection getFreeConnection() {

  //返回數據庫連接conn的接管類，以便截住close方法

   Connection conn2 = (Connection)Proxy.newProxyInstance(

    conn.getClass().getClassLoader(),

    conn.getClass().getInterfaces(),this);

   return conn2;

}

/**

* 該方法真正的關閉了數據庫的連接

* @throws SQLException

*/

void close() throws SQLException{

  //由于類屬性conn是沒有被接管的連接，因此一旦調用close方法后就直接關閉連接

   conn.close();

}

   

public void setIsFree(boolean value)

{

   isFree = value;

}

public boolean isFree() {

   return isFree;

} 

/**

* 判斷是否支持事務

* @return boolean

*/

public boolean isSupportTransaction() {

   return supportTransaction;

} 

}

/*ConnectionFactory.java */

package scut.ailab.connectionpool;

/**

* @author youyongming

*

*/

import java.util.LinkedHashSet;

import java.sql.*;

import java.util.Iterator;

public class ConnectionFactory {

private static ConnectionFactory m_instance = null;

//在使用的連接池

private LinkedHashSet ConnectionPool = null;

//空閑連接池

private LinkedHashSet FreeConnectionPool = null;

//最大連接數

private int MaxConnectionCount = 4;

//最小連接數

private int MinConnectionCount = 2;

//當前連接數

private int current_conn_count = 0;

//連接參數

private ConnectionParam connparam = null;

//是否創建工廠的標志

private boolean isflag = false;

//是否支持事務

private boolean supportTransaction = false;

//定義管理策略

private int ManageType = 0;

private ConnectionFactory() {

   ConnectionPool = new LinkedHashSet();

   FreeConnectionPool = new LinkedHashSet();

}

/**

* 使用指定的參數創建一個連接池

*/

public ConnectionFactory(ConnectionParam param, FactoryParam fparam)

   throws SQLException 

{

  //不允許參數為空

   if ((param == null)||(fparam == null))

    throw new SQLException("ConnectionParam和FactoryParam不能為空");

   if (m_instance == null)

   {

    synchronized(ConnectionFactory.class){

     if (m_instance == null)

     {

     //new instance

     //參數定制

      m_instance = new ConnectionFactory();

      m_instance.connparam = param;

      m_instance.MaxConnectionCount = fparam.getMaxConn();

      m_instance.MinConnectionCount = fparam.getMinConn();

      m_instance.ManageType = fparam.getType();

      m_instance.isflag = true;

     //初始化，創建MinConnectionCount個連接

      System.out.println("connection factory 創建！");

      try{

       for (int i=0; i < m_instance.MinConnectionCount; i++)

       {

        _Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);

        if (_conn == null) continue;

        System.out.println("connection創建");

        m_instance.FreeConnectionPool.add(_conn);//加入空閑連接池

        m_instance.current_conn_count ++;

       //標志是否支持事務

        m_instance.supportTransaction = _conn.isSupportTransaction();    

       }

      }

      catch(Exception e)

      {

       e.printStackTrace();

      }

     //根據策略判斷是否需要查詢

      if (m_instance.ManageType != 0)

      {

       Thread t = new Thread(new FactoryMangeThread(m_instance));

       t.start();

      } 

     }

    }

   }

}

/**

* 標志工廠是否已經創建

* @return boolean

*/ 

public boolean isCreate()

{

   return m_instance.isflag;

}

/**

* 從連接池中取一個空閑的連接

* @return Connection

* @throws SQLException

*/

public synchronized Connection getFreeConnection() 

   throws SQLException

{

   Connection conn = null;

  //獲取空閑連接

   Iterator iter = m_instance.FreeConnectionPool.iterator(;

   while(iter.hasNext()){

    _Connection _conn = (_Connection)iter.next();

   //找到未用連接

    if(!_conn.isFree()){

     conn = _conn.getFreeConnection();

     _conn.setIsFree(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)

    {

   //新建連接到空閑連接池

     int newcount = 0 ;

    //取得要建立的數目

     if (m_instance.MaxConnectionCount - m_instance.current_conn_count >=m_instance.MinConnectionCount)

     {

      newcount = m_instance.MinConnectionCount;

     }

     else

     {

      newcount = m_instance.MaxConnectionCount - m_instance.current_conn_count;

     }

     //創建連接

     for (int i=0;i      {

      _Connection _conn = _Connection.getConnection(m_instance, m_instance.connparam);

      m_instance.FreeConnectionPool.add(_conn);

      m_instance.current_conn_count ++;

     }

    }

    else

    {//如果不能新建，檢查是否有已經歸還的連接

     iter = m_instance.ConnectionPool.iterator();

     while(iter.hasNext()){

      _Connection _conn = (_Connection)iter.next();

      if(!_conn.isFree()){

       conn = _conn.getFreeConnection();

       _conn.setIsFree(false);

       m_instance.ConnectionPool.remove(_conn); 

       m_instance.FreeConnectionPool.add(_conn);   

       break;

      }

     }    

    }

   }//if (FreeConnectionPool.isEmpty())

//再次檢查是否能分配連接

   if(conn == null){

    iter = m_instance.FreeConnectionPool.iterator();

    while(iter.hasNext()){

     _Connection _conn = (_Connection)iter.next();

     if(!_conn.isFree()){

      conn = _conn.getFreeConnection();

      _conn.setIsFree(true);

      m_instance.FreeConnectionPool.remove(_conn); 

      m_instance.ConnectionPool.add(_conn);   

      break;

     }

    }

    if(conn == null)//如果不能則說明無連接可用

     throw new SQLException("沒有可用的數據庫連接");

   }

   System.out.println("get connection");

   return conn;

}

/**

* 關閉該連接池中的所有數據庫連接

* @throws SQLException

*/

public synchronized void close() throws SQLException

{

   this.isflag = false;

   SQLException excp = null;

  //關閉空閑池

   Iterator iter = m_instance.FreeConnectionPool.iterator();

   while(iter.hasNext()){

    try{

     ((_Connection)iter.next()).close();

     System.out.println("close connection:free");

     m_instance.current_conn_count --;

    }catch(Exception e){

     if(e instanceof SQLException)

      excp = (SQLException)e;

    }

   }

  //關閉在使用的連接池

   iter = m_instance.ConnectionPool.iterator();

   while(iter.hasNext()){

    try{

     ((_Connection)iter.next()).close();

     System.out.println("close connection:inused");

     m_instance.current_conn_count --;

    }catch(Exception e){

     if(e instanceof SQLException)

      excp = (SQLException)e;

    }

   }  

   if(excp != null)

    throw excp;

} 

/**

* 返回是否支持事務

* @return boolean

*/

public boolean isSupportTransaction() {

   return m_instance.supportTransaction;

}  

/**

* 連接池調度管理

*

*/

public void schedule()