cpool.java

用java编写的一个连接池的程序

package Pool;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Iterator;
import java.util.Vector;

public class CPool implements Pool

{

    private static final String USED="used";
    private static final String FREE="free";

	private Vector pools = new Vector();
	
	private Vector monitor = new Vector();

	private int minConn;

	private int maxConn;

	private String driver;

	private String password;

	private String url;

	private String user;

	public CPool(String driver, String url, String user, String password,
			int minConn, int maxConn) {
		this.driver = driver;
		this.url = url;
		this.user = user;
		this.password = password;
		this.minConn = minConn;
		this.maxConn = maxConn;
	}

	public void startPool() throws Exception {
		for (int i = minConn; i > 0; i--) {
			
			pools.add((PoolConnection) createConnection());
		}
	}

	public void stopPool() {
		Iterator iter = pools.iterator();
		while (iter.hasNext()) {
			PoolConnection pconn = (PoolConnection) iter.next();
			try {
				pconn.getJdbcConnection().close();
				pools.remove(pconn);
				System.out.println("关闭连接池中的一个连接");
			} catch (SQLException e) {
				System.out.println("无法关闭连接池中的连接");
			}
		}
		pools.clear();

	}

	public void resetConnection() {

		if (pools.size() > minConn) {
			synchronized (pools) {
				for (int i = 0; i < pools.size() - minConn; i++) {
					PoolConnection pconn = (PoolConnection) pools.get(i);
					try {
						pconn.getJdbcConnection().close();
						pools.remove(pconn);

					} catch (SQLException e) {
					}
					pools.remove(0);
				}
			}
		}
	}

	/**
	 * 
	 * 获取数据库连接
	 * 
	 * 如果当前池中有可用连接，则将池中最后一个返回，如果没有，则新建一个返回
	 * 
	 */

	public synchronized Connection getConnection() throws Exception

	{

		if (pools == null)

		{

			this.startPool();

		}

		PoolConnection pconn;

		if (pools.isEmpty())

		{

			pconn = createConnection();
			monitor.add(pconn);

		}

		else

		{

			int last_idx = pools.size() - 1;

			pconn = (PoolConnection) pools.get(last_idx);

			pools.remove(pools.get(last_idx));
			pconn.setStatus(USED);
			monitor.add(pconn);
			

		}
        pconn.setLastestUseTime(new Timestamp(System.currentTimeMillis()));
		return new MyConnection(this, pconn);

	}

	/**
	 * 
	 * 将使用完毕的数据库连接放回备用池。
	 * 
	 * 
	 * 
	 * 判断当前池中连接数是否已经超过阀值（POOL_MAX_SIZE），
	 * 
	 * 如果超过，则关闭该连接。
	 * 
	 * 否则放回池中以备下次重用。
	 * 
	 */

	public synchronized void releaseConnection(PoolConnection pconn)

	{
        
		if (pools.size() > maxConn)

		{

			try {

				pconn.getJdbcConnection().close();
				pools.remove(pconn);
			

			}

			catch (SQLException e)

			{

				e.printStackTrace();

			}

		}

		else

		{
			pconn.setUsedTime(pconn.getUsedTime()+System.currentTimeMillis()-pconn.getLastestUseTime().getTime());
			pconn.setStatus(FREE);
			pools.add(pconn);
			monitor.remove(pconn);
			

		}

	}

	/**
	 * 
	 * 创建数据库连接
	 * 
	 * 
	 * 
	 * @return Connection
	 * @throws Exception
	 * 
	 * @throws DBException
	 * 
	 */

	private PoolConnection createConnection() throws Exception

	{

		Connection conn;
		PoolConnection pconn = new PoolConnection();
		try

		{

			Class.forName(driver);

			conn = DriverManager.getConnection(url, user, password);

		}

		catch (ClassNotFoundException e)

		{

			throw new Exception(
					"ClassNotFoundException when loading JDBC Driver");

		}

		catch (SQLException e)

		{

			throw new Exception("SQLException when loading JDBC Driver");

		}
		pconn.setJdbcConnection(conn);
		pconn.setCreatedTime(new Timestamp(System.currentTimeMillis()));
		return pconn;
	}

	public Vector getMonitor() {
		return monitor;
	}

	public void setMonitor(Vector monitor) {
		this.monitor = monitor;
	}

	public Vector getPools() {
		return pools;
	}

	public void setPools(Vector pools) {
		this.pools = pools;
	}


}