一个 JDBC 连接池例子

　　import Java.io.*;
　　import java.sql.*;
　　import java.util.*;
　　import java.util.Date;
　　
　　/**
　　* This class is a Singleton that provides Access to one or many
　　* connection pools defined in a Property file. A client gets
　　* access to the single instance through the static getInstance()
　　* method and can then check-out and check-in connections from a pool.
　　* When the client shuts down it should call the release() method
　　* to close all open connections and do other clean up.
　　*/
　　public class DBConnectionManager {
　　 static private DBConnectionManager instance; // The single instance
　　 static private int clients;
　　
　　 private Vector drivers = new Vector();
　　 private PrintWriter log;
　　 private Hashtable pools = new Hashtable();
　　
　　 /**
　　 * Returns the single instance, creating one if it's the
　　 * first time this method is called.
　　 *
　　 * @return DBConnectionManager The single instance.
　　 */
　　 static synchronized public DBConnectionManager getInstance() {
　　 if (instance == null) {
　　 instance = new DBConnectionManager();
　　 }
　　 clients++;
　　 return instance;
　　 }
　　
　　 /**
　　 * A private constrUCtor since this is a Singleton
　　 */
　　 private DBConnectionManager() {
　　 init();
　　 }
　　
　　 /**
　　 * Returns a connection to the named pool.
　　 *
　　 * @param name The pool name as defined in the properties file
　　 * @param con The Connection
　　 */
　　 public void freeConnection(String name, Connection con) {
　　 DBConnectionPool pool = (DBConnectionPool) pools.get(name);
　　 if (pool != null) {
　　 pool.freeConnection(con);
　　 }
　　 }
　　
　　 /**
　　 * Returns an open connection. If no one is available, and the max
　　 * number of connections has not been reached, a new connection is
　　 * created.
　　 *
　　 * @param name The pool name as defined in the properties file
　　 * @return Connection The connection or null
　　 */
　　 public java.sql.Connection getConnection(String name) {
　　 DBConnectionPool pool = (DBConnectionPool) pools.get(name);
　　 if (pool != null) {
　　 return pool.getConnection();
　　 }
　　 return null;
　　 }
　　
　　 /**
　　 * Returns an open connection. If no one is available, and the max
　　 * number of connections has not been reached, a new connection is
　　 * created. If the max number has been reached, waits until one
　　 * is available or the specified time has elapsed.
　　 *
　　 * @param name The pool name as defined in the properties file
　　 * @param time The number of milliseconds to wait
　　 * @return Connection The connection or null
　　 */
　　 public java.sql.Connection getConnection(String name, long time) {
　　 DBConnectionPool pool = (DBConnectionPool) pools.get(name);
　　 if (pool != null) {
　　 return pool.getConnection(time);
　　 }
　　 return null;
　　 }
　　
　　 /**
　　 * Closes all open connections and deregisters all drivers.
　　 */
　　 public synchronized void release() {
　　 // Wait until called by the last client
　　 if (--clients != 0) {
　　 return;
　　 }
　　
　　 Enumeration allPools = pools.elements();
　　 while (allPools.hasMoreElements()) {
　　 DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();
　　 pool.release();
　　 }
　　 Enumeration allDrivers = drivers.elements();
　　 while (allDrivers.hasMoreElements()) {
　　 Driver driver = (Driver) allDrivers.nextElement();
　　 try {
　　 DriverManager.deregisterDriver(driver);
　　 log("Deregistered JDBC driver " + driver.getClass().getName());
　　 }
　　 catch (SQLException e) {
　　 log(e, "Can't deregister JDBC driver: " + driver.getClass().getName());
　　 }
　　 }
　　 }
　　
　　 /**
　　 * Creates instances of DBConnectionPool based on the properties.
　　 * A DBConnectionPool can be defined with the following properties:
　　 *


　　    * <poolname>.url         The JDBC URL for the database
　　    * <poolname>.user        A database user (optional)
　　    * <poolname>.passWord    A database user password (if user specified)
　　    * <poolname>.maxconn     The maximal number of connections (optional)
　　    *

　　 *
　　 * @param props The connection pool properties
　　 */
　　 private void createPools(Properties props) {
　　 Enumeration propNames = props.propertyNames();
　　 while (propNames.hasMoreElements()) {
　　 String name = (String) propNames.nextElement();
　　 if (name.endsWith(".url")) {
　　 String poolName = name.substring(0, name.lastIndexOf("."));
　　 String url = props.getProperty(poolName + ".url");
　　 if (url == null) {
　　 log("No URL specified for " + poolName);
　　 continue;
　　 }
　　 String user = props.getProperty(poolName + ".user");
　　 String password = props.getProperty(poolName + ".password");
　　 String maxconn = props.getProperty(poolName + ".maxconn", "0");
　　 int max;
　　 try {
　　 max = Integer.valueOf(maxconn).intvalue();
　　 }
　　 catch (NumberformatException e) {
　　 log("Invalid maxconn value " + maxconn + " for " + poolName);
　　 max = 0;
　　 }
　　 DBConnectionPool pool =
　　 new DBConnectionPool(poolName, url, user, password, max);
　　 pools.put(poolName, pool);
　　 log("Initialized pool " + poolName);
　　 }
　　 }
　　 }
　　
　　 /**
　　 * Loads properties and initializes the instance with its values.
　　 */
　　 private void init() {
　　 InputStream is = getClass().getResourceAsStream("/db.properties");
　　 Properties dbProps = new Properties();
　　 try {
　　 dbProps.load(is);
　　 }
　　 catch (Exception e) {
　　 System.err.println("Can't read the properties file. " +
　　 "Make sure db.properties is in the CLASSPATH");
　　 return;
　　 }
　　 String logFile = dbProps.getProperty("logfile", "DBConnectionManager.log");
　　 try {
　　 log = new PrintWriter(new FileWriter(logFile, true), true);
　　 }
　　 catch (IOException e) {
　　 System.err.println("Can't open the log file: " + logFile);
　　 log = new PrintWriter(System.err);
　　 }
　　 loadDrivers(dbProps);
　　 createPools(dbProps);
　　 }
　　
　　 /**
　　 * Loads and registers all JDBC drivers. This is done by the
　　 * DBConnectionManager, as opposed to the DBConnectionPool,
　　 * since many pools may share the same driver.
　　 *
　　 * @param props The connection pool properties