dbconnectionpool.java

Java程序设计实用案例教程源代码

package database;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.Vector;

public class DBConnectionPool {
	private static final int TIME_BETWEEN_RETRIES = 500; // 0.5 秒

	// 已使用连接
	private int checkedOut = 0;

	// 存放空闲连接
	private Vector<Connection> freeConnections = new Vector<Connection>();

	// 最大连接数
	private int maxConn = 0;

	// 数据库密码
	private String pwd = null;

	// JDBC连接所用URL
	private String URL = null;

	// 数据库用户名
	private String user = null;

	// 构造方法
	public DBConnectionPool(String URL, String user, String pwd, int maxConn) {
		this.URL = URL;
		this.user = user;
		this.pwd = pwd;
		this.maxConn = maxConn;
		System.out.println("创建新的数据库连接池");
	}

	// 释放指定的连接
	synchronized void freeConnection(Connection conn) {
		if (conn != null) {
			if (checkedOut <= 0) {
				try {
					System.out.println("关闭连接！" + checkedOut);
					conn.close();
				} catch (SQLException sqlex) {
					System.out.println("关闭失败!");
					sqlex.printStackTrace();
				}
			} else {
				freeConnections.addElement(conn);
				checkedOut--;
				System.out.println("关闭连接！" + checkedOut);
				// 唤醒所有休息的进程
				notifyAll();
			}
		}
	}

	/*
	 * 检验数据库连接池中的连接 如果没有空闲的连接，则创建一个新的连接。
	 * 除非已经达到最大连接数如果存在一个空闲的关闭了的连接，
	 * 则将这个连接从连接池中移去， 然后再次调用这个方法
	 */
	synchronized Connection getConnection() {
		Connection conn = null;
		while ((freeConnections.size() > 0) && (conn == null)) {
			conn = (Connection) freeConnections.firstElement();
			freeConnections.remove(0);
			try {
				if (conn.isClosed()) {
					System.out.println("移去已关闭的连接");
					// 让while循环继续运行
					conn = null;
				}
			} catch (SQLException sqlex) {
				conn = null;
				System.out.println(sqlex.getMessage());
			}
		}
		// 不能从数据连接池得到任何连接
		if (conn == null) {
			if (maxConn == 0 || checkedOut < maxConn) {
				// 创建新的连接
				conn = newConnection();
			}
		}
		if (conn != null) {
			checkedOut++;
		}
		return conn;
	}

	/*
	 * 返回一个连接 如果没有可以使用的连接，且连接数还没有达到最大，
	 * 就创建一个新的连接；如果连接数达到了最大值，按指定的时间等待，
	 * 如果这个时间内有连接被释放 就返回一个连接
	 * 如果没有连接被释放，就返回null。
	 */
	Connection getConnectin(long timeout) {
		long startTime = System.currentTimeMillis();
		Connection conn;
		while ((conn = getConnection()) == null) {
			long elapsedTime = System.currentTimeMillis() - startTime;
			if (elapsedTime >= timeout) {
				return null;
			}

			long timeToWait = timeout - elapsedTime;
			// 每次等待的时间要能超过TIME_BETWEEN_RETRIES
			if (timeToWait > TIME_BETWEEN_RETRIES)
				timeToWait = TIME_BETWEEN_RETRIES;
			try {
				Thread.sleep(timeToWait);
			} catch (InterruptedException ie) {
				System.out.println(ie.getMessage()
						+ "in getConnection(long timeout)");
			}
		}
		return conn;
	}

	// 关闭所有可利用的连接
	synchronized boolean release() {
		boolean flag = true;
		Enumeration allConns = freeConnections.elements();
		System.out.println(allConns.hasMoreElements());
		while (allConns.hasMoreElements()) {
			Connection conn = (Connection) allConns.nextElement();
			try {
				conn.close();
				checkedOut--;
				System.out.println("a" + checkedOut);
			} catch (SQLException ex) {
				System.out.println("can't close connection in DBConectionPool");
			}
		}
		freeConnections.removeAllElements();
		if (checkedOut != 0) {
			flag = false;
			System.out.println("ConnectionManager: the pool is not balanced."
					+ checkedOut + flag);
		}
		checkedOut = 0;
		return flag;
	}

	// 按指定的用户名和密码创建一个数据库连接
	private synchronized Connection newConnection() {
		Connection conn = null;
		System.out.print("创建新的连接！" + checkedOut);
		try {
			// 没有用户名
			if (user == null) {
				conn = DriverManager.getConnection(URL);
			} else {
				conn = DriverManager.getConnection(URL, user, pwd);
			}
			conn.setAutoCommit(true);
			System.out.println("  " + conn + " int newConnection!");

		} catch (SQLException sqlex) {
			System.out.println();
			sqlex.printStackTrace();
		}
		return conn;
	}
}