connectionfactory.java

此为连接池实现程序

/**
 * @author 肖建军
 * 定义数据库连接池的类
 */

package com.sunrise.chnl.sql;

import java.util.LinkedHashSet;
import java.util.Iterator;
import java.sql.SQLException;
import java.sql.Connection;
import com.sunrise.chnl.obj.PublicBean;

public class ConnectionFactory {
  private static ConnectionFactory m_instance = null;
  //在线连接池
  private LinkedHashSet OnlineConnectionPool = null;
  //空闲连接池
  private LinkedHashSet FreeConnectionPool = null;
  //最大连接数
  private int MaxPoolSize = 5;
  //初始连接数
  private int InitPoolSize = 2;
  //当前连接数
  private int CurrPoolSize = 0;
  //当前空闲连接数
  private int FreePoolSize = 0;
  //当前在线连接数
  private int OnlinePoolSize = 0;
  //连接参数
  private ConnectionParam connparam = null;
  //是否创建工厂的标志
  private boolean isflag = false;
  //是否支持事务
  private boolean supportTransaction = false;
  //管理策略（0静态管理，1动态管理）
  private int ManagePolicy = 0;
  //在线连接休眠超时时长(ms)
  private long TimeOut = 0;
  //数据处理信息
  private String MessageInfo = "0";
  //连接池监控线程
  private Thread thread = null;

  private ConnectionFactory() {
    MessageInfo = "0";
    OnlineConnectionPool = new LinkedHashSet();
    FreeConnectionPool = new LinkedHashSet();
  }

  /**
   * 使用指定的参数创建一个连接池
   */
  public ConnectionFactory(ConnectionParam param, FactoryParam fparam) {
    MessageInfo = "0";
    try{
      //不允许参数为空
      if ( (param == null) || (fparam == null)){
        MessageInfo = "参数配置错误";
        PublicBean.writelog("ERR-CF0001：失败原因：" + MessageInfo,0);
        return;
      }
      if (m_instance == null) {
        synchronized (ConnectionFactory.class) {
          if (m_instance == null) { //new instance
            //参数定制
            m_instance = new ConnectionFactory();
            m_instance.connparam = param;
            m_instance.MaxPoolSize = fparam.getMaxPoolSize();
            m_instance.InitPoolSize = fparam.getInitPoolSize();
            m_instance.TimeOut = fparam.getTimeOut()*60*1000;
            m_instance.ManagePolicy = fparam.getManagePolicy();
            m_instance.isflag = true;
            //初始化，创建InitPoolSize个连接
            try {
              for (int i = 0; i < m_instance.InitPoolSize; i++) {
                ConnectionHome _conn = ConnectionHome.getConnection(m_instance,m_instance.connparam);
                if (_conn == null) continue;
                //加入空闲连接池
                m_instance.FreeConnectionPool.add(_conn);
                m_instance.FreePoolSize ++;
                m_instance.CurrPoolSize ++;
                //标志是否支持事务
                m_instance.supportTransaction = _conn.isSupportTransaction();
              }
            }
            catch (Exception e) {
              MessageInfo = e.toString();
              PublicBean.writelog("ERR-CF0002：失败原因：" + MessageInfo,0);
            }
            //根据策略判断是否进行动态管理
            if (m_instance.ManagePolicy != 0) {
              thread = new Thread(new FactoryMangeThread(m_instance));
              thread.start();
            }
          }
        }
      }
    }catch(Exception e){
      MessageInfo = e.toString();
      PublicBean.writelog("ERR-CF0003：失败原因：" + MessageInfo,0);
    }
  }

  /**
   * 标志工厂是否已经创建
   * @return boolean
   */
  public boolean isCreate() {
    return m_instance.isflag;
  }

  /**
   * 从连接池中取一个空闲的连接
   * @return Connection
   * @throws SQLException
   */
  public synchronized Connection getFreeConnection() {
    Connection conn = null;
    //获取空闲连接
    Iterator iter = m_instance.FreeConnectionPool.iterator();
    try{
      while (iter.hasNext()) {
        ConnectionHome _conn = (ConnectionHome) iter.next();
        //找到未用连接
        if (!_conn.getOnline()) {
          conn = _conn.getFreeConnection();
          _conn.setOnline(true);
          //移出空闲区
          m_instance.FreeConnectionPool.remove(_conn);
          m_instance.FreePoolSize --;
          //加入连接池
          m_instance.OnlineConnectionPool.add(_conn);
          m_instance.OnlinePoolSize ++;
          break;
        }
      }
    }catch(Exception e){
      MessageInfo = e.toString();
      PublicBean.writelog("ERR-CF0004：失败原因：" + MessageInfo,0);
    }
    try{
      //检查空闲池是否为空
      if (m_instance.FreeConnectionPool.isEmpty()) {
        //再检查是否能够分配
        if (m_instance.CurrPoolSize < m_instance.MaxPoolSize) {
          //新建连接到空闲连接池
          int newcount = 0;
          //取得要建立的数目
          if (m_instance.MaxPoolSize - m_instance.CurrPoolSize >= m_instance.InitPoolSize) {
            newcount = m_instance.InitPoolSize;
          }
          else {
            newcount = m_instance.MaxPoolSize - m_instance.CurrPoolSize;
          }
          //创建连接
          for (int i = 0; i < newcount; i++) {
            ConnectionHome _conn = ConnectionHome.getConnection(m_instance,m_instance.connparam);
            m_instance.FreeConnectionPool.add(_conn);
            m_instance.CurrPoolSize ++;
            m_instance.FreePoolSize ++;
          }
        }
        else {
          //如果不能新建，检查是否有已经归还的连接
          iter = m_instance.OnlineConnectionPool.iterator();
          while (iter.hasNext()) {
            ConnectionHome _conn = (ConnectionHome) iter.next();
            if (!_conn.getOnline()) {
              conn = _conn.getFreeConnection();
              _conn.setOnline(false);
              m_instance.OnlineConnectionPool.remove(_conn);
              m_instance.OnlinePoolSize --;
              m_instance.FreeConnectionPool.add(_conn);
              m_instance.FreePoolSize ++;
              break;
            }
          }
        }
      }
    }catch(Exception e){
      MessageInfo = e.toString();
      PublicBean.writelog("ERR-CF0005：失败原因：" + MessageInfo,0);
    }
    try{
      //再次检查是否能分配连接
      if (conn == null) {
        iter = m_instance.FreeConnectionPool.iterator();
        while (iter.hasNext()) {
          ConnectionHome _conn = (ConnectionHome) iter.next();
          if (!_conn.getOnline()) {
            conn = _conn.getFreeConnection();
            _conn.setOnline(true);
            m_instance.FreeConnectionPool.remove(_conn);
            m_instance.FreePoolSize --;
            m_instance.OnlineConnectionPool.add(_conn);
            m_instance.OnlinePoolSize ++;
            break;
          }
        }
        if (conn == null) //如果不能则说明无连接可用
          MessageInfo = "没有可用的数据库连接";
          PublicBean.writelog("ERR-CF0006：失败原因：" + MessageInfo, 0);
      }
    }catch(Exception e){
      MessageInfo = e.toString();
      PublicBean.writelog("ERR-CF0007：失败原因：" + MessageInfo,0);
    }
    return conn;
  }

  /**
   * @return 当前连接数
   */
  public int getCurrentPoolSize(){
    return m_instance.CurrPoolSize;
  }

  /**
   * @return 当前未空闲的连接数
   */
  public int getFreePoolSize(){
    return m_instance.FreePoolSize;
  }

  /**
   * @return 当前在线的连接数
   */
  public int getOnlinePoolSize(){
    return m_instance.OnlinePoolSize;
  }

  public String getMessageInfo(){
    return MessageInfo;
  }


  /**
   * 关闭该连接池中的所有数据库连接
   * @throws SQLException
   */
  public synchronized void close() throws SQLException {
    this.isflag = false;
    SQLException excp = null;
    //关闭空闲池
    Iterator iter = m_instance.FreeConnectionPool.iterator();
    while(iter.hasNext()){
      try{
        ((ConnectionHome)iter.next()).close();
        m_instance.CurrPoolSize --;
        m_instance.FreePoolSize --;
      }catch(Exception e){
      	if(e instanceof SQLException)
      	excp = (SQLException)e;
      }
    }
    //关闭在使用的连接池
    iter = m_instance.OnlineConnectionPool.iterator();
    while(iter.hasNext()){
      try{
        ((ConnectionHome)iter.next()).close();
        m_instance.CurrPoolSize --;
        m_instance.OnlinePoolSize --;
      }catch(Exception e){
      	if(e instanceof SQLException)
      	excp = (SQLException)e;
      }
    }
    //关闭连接池监控线程
    if(thread != null){
      thread.stop();
    }
    if(excp != null){
      MessageInfo = excp.toString();
      PublicBean.writelog("ERR-CF0008：失败原因：" + MessageInfo, 0);
    }
  }

  /**
   * 返回是否支持事务
   * @return boolean
   */
  public boolean isSupportTransaction(){
    return m_instance.supportTransaction;
  }

  /**
   * 连接池调度管理
   *
   */
  public void schedule(){
    Connection conn = null;
    //再检查是否能够分配
    Iterator iter = null;
    //检查是否有已经归还的连接
    iter = m_instance.OnlineConnectionPool.iterator();
    while(iter.hasNext()){
      ConnectionHome _conn = (ConnectionHome)iter.next();
      //检查连接休眠时长是否超时，如果超时则强制关闭连接
      long currTime = System.currentTimeMillis();
      if(m_instance.TimeOut > 0 && (currTime - _conn.getLastAccessTime() > m_instance.TimeOut)){
        _conn.setOnline(false);
      }
      if(!_conn.getOnline()){
        conn = _conn.getFreeConnection();
        _conn.setOnline(false);
        m_instance.OnlineConnectionPool.remove(_conn);
        m_instance.OnlinePoolSize --;
        m_instance.FreeConnectionPool.add(_conn);
        m_instance.FreePoolSize ++;
        break;
      }
    }
    //检查空闲池是否为空
    if (m_instance.FreeConnectionPool.isEmpty()) {
      if (m_instance.CurrPoolSize < m_instance.MaxPoolSize) {
        //新建连接到空闲连接池
        int newcount = 0 ;
        //取得要建立的数目
        if (m_instance.MaxPoolSize - m_instance.CurrPoolSize >=m_instance.InitPoolSize){
      	  newcount = m_instance.InitPoolSize;
        }
        else{
          newcount = m_instance.MaxPoolSize - m_instance.CurrPoolSize;
        }
        //创建连接
        for (int i=0;i <newcount; i++){
          ConnectionHome _conn = ConnectionHome.getConnection(m_instance,
              m_instance.connparam);
          m_instance.FreeConnectionPool.add(_conn);
          m_instance.CurrPoolSize ++;
          m_instance.FreePoolSize ++;
        }
      }
    }
  }
}