新建 文本文档.txt

数据库连接池的JAVA代码实现,超完美版

数据库连接池的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()