connectionfactory.java

一个Eclipse环境下的数据库连接池算法实现。

package scut.ailab.connectionpool;

/**
 * @author zhmm
 */
import java.sql.*;
import java.util.Iterator;
import java.util.LinkedHashSet;

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 Curren_conn_count = 0; // 当前连接数

	private ConnectionParam connparam = null; // 连接参数

	private boolean isflag = false; // 是否创建工厂的标志

	private boolean supportTraction = 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) {
					m_instance = new ConnectionFactory(); // newinstance
					m_instance.connparam = param;
					m_instance.MaxConnectionCount = fparam.getMaxConn();
					m_instance.MinConnectionCount = fparam.getMinConn();
					m_instance.ManageType = fparam.getManageType();
					m_instance.isflag = true;
					// 初始化创建MinConnectionCount个数的连接
					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.Curren_conn_count++;
							m_instance.supportTraction = _conn
									.isSupportTraction();

						}
					} catch (Exception e) {
						e.printStackTrace();
					}
					if (m_instance.ManageType != 0) { // 根据策略判断是否需要查询
						Thread thread = new Thread(new FactoryMangeThread(
								m_instance));
						thread.start();
					}
				}
			}
		}
	}

	/**
	 * 表示工厂是否已经创建
	 */
	public boolean isCreate() {
		return this.isflag;
	}

	/*
	 * 从连接池里取出一个空闲的连接
	 */
	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.Curren_conn_count < m_instance.MaxConnectionCount) { // 在检查是否能够分配
				int newcount = 0; // 新建连接到空闲连接池
				if (m_instance.MaxConnectionCount
						- m_instance.Curren_conn_count >= m_instance.MinConnectionCount) {
					newcount = m_instance.MinConnectionCount; // 取得要建立的数目
				} else {
					newcount = m_instance.MaxConnectionCount
							- m_instance.Curren_conn_count;
				}
				for (int i = 0; i < newcount; i++) {
					_Connection _conn = _Connection.getConnection(m_instance,
							m_instance.connparam);
					m_instance.FreeConnectionPool.add(_conn);
					m_instance.Curren_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 (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;
	}

	/*
	 * 关闭连接池中的所有连接
	 */
	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.Curren_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 free");
				m_instance.Curren_conn_count--;
			} catch (Exception e) {
				if (e instanceof SQLException) {
					excp = (SQLException) e;
				}
			}
			if (excp != null)
				throw excp;

		}
	}

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

	/*
	 * 连接池调度管理
	 */
	public void schedule() {
		Connection conn = null;
		Iterator iter = null; //在次检查是否能够分配
		{ //检查是否有已经归还的连接
			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 (m_instance.Curren_conn_count < m_instance.MaxConnectionCount) {
			int newcount = 0; //新建连接到空闲连接池
			if (m_instance.MaxConnectionCount - m_instance.Curren_conn_count >= m_instance.MinConnectionCount) {
				//取得要建立的数目
				newcount = m_instance.MinConnectionCount;
			} else {
				newcount = m_instance.MaxConnectionCount
						- m_instance.Curren_conn_count;
			}
			//创建连接
			for (int i = 0; i < newcount; i++) {
				_Connection _conn = _Connection.getConnection(m_instance,
						m_instance.connparam);
				m_instance.FreeConnectionPool.add(_conn);
				m_instance.Curren_conn_count++;
			}

		}
	}

}