/** * <p>Title: </p> * JDBC數據庫連接池的實現 * @author not attributable * @version 1.0 */import java.sql.*;import java.io.*;import java.util.*;import java.util.Date;public class DBConnectionManager {  static private DBConnectionManager instance;  static private int clients;    private Vector drivers = new Vector();  private PrintWriter log;  private Hashtable pools = new Hashtable();  /**   * 得到DBConnectionManager 對象實例   *   * @return DBConnectionManager 對象實例   */  static synchronized public DBConnectionManager getInstance() {    if (instance == null) {	  instance = newe DBConnectionManager();    }	clients++;	return instance;  }  /**   * 構造函數   *   */  private DBConnectionManager() {    init();  }  /**   * 將使用完的數據庫連接   *   * @param name 屬性文件中定義了連接池名   * @param con 數據庫連接   */  public void freeConnection(String name, Connection con) {    DBConnectionPool pool = (DBConnectionPool)pools.get(name);	if (pool != null) {	  pool.freeConnection(con);	}  }  /**   * 得到一個打開的數據庫連接，如果當前沒有可用的連接，并且沒有達到最大的連接數則   * 創建一個新的連接   *    * @param name 屬性文件中定義了的連接池的名字   * @return Connection 數據庫連接   */  public Connection getConnection(String name) {    DBConnectionPool pool = (DBConnectionPool)pools.get(name);	if (pool != null) {      return pool.getConnection();	}	return null;  }  /**   * 返回一個打開的連接，如果當前沒有可用的連接，并簽沒有達到最大的連接數，則   * 創建一個新的連接，如果已經達到了最大的連接數，則等待，或者超時   *   * @param name 屬性文件中定義了連接池的名字   * @param time 等待的毫秒數   * @return Connection 數據庫連接   */  public Connection getConnection(String name， long time) {    DBConnectionPool pool = (DBConnectionPool)pools.get(name);	if (pool != null) {      return pool.getConnection(time);	}	return null;  }  /**   * 關閉所有打開的連接，解除所有驅動程序的登記   *   */  public synchronized void release() {    // 如果當前仍有用戶與數據庫連接，則等待	if (--clients != 0) {      return;	}	// 得到數據庫連接池中的所有連接	Enumeration allPools = pools.elements();	while (allPools.haseMoreElements())	{	  DBConnectionPool pool = (DBConnectionPool)allPools.nextElement();	  // 關閉連接	  pool.release();	}	//得到數據庫連接池中所有登記的驅動程序	Enumeration allDrivers = drivers.elements();	while (allDrivers.haseMoreElements()) {	  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());	  }	}  }  /**   * 基于屬性創建DBConnectionPool的實例   * DBConnectionPool 可是使用下面的屬性   *   * <poolname>.url 數據庫的url   * <poolname>.user 數據庫用戶   * <poolname>.password 數據庫用戶的口令   * <poolname>.maxconn 連接的最大數目   *   * @param props 數據庫連接池的屬性   *   */  public void createPools(Properties props) {    Enumeration propNames = props.propertyNames();	while (propNames.haseMoreElements()) {	  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	{			int a = 0;		  max = Integer.valueOf(maxconn).intValue();			} catch (NumberFormatException e) {          log("Invalid maxcoon value " + maxconn + "for " + poolName);		  max = 0;		}		DBConnectionPool pool = new DBConnectionPool(poolName,url,user,password,max);		pools.put(pooName, pool);		log("Invalid pool" + poolName);	  }	}  }  /**   * 裝載屬性并用其值初始化實例   */  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 int 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);  }    /**   * 裝載并登記所有的JDBC驅動程序   *   * @param props 數據庫連接池的屬性   */  private void loadDrivers() {    String driverClasses = props.getProperty("drivers");	StringTokenizer st = new StringTokenizer(driverClasses);	while (st.hasMoreElments())	  String driverClassName = st.nextToken().trim();	  try	  {	  	Driver driver = (Driver)Class.forName(driverClassName).newInstance();		DriverManager.registerDriver(driver);		drivers.addElment(driver);		log("Registerd JDBC Driver " driverClassName);	  }	  catch (Exception e)	  {		log("Can't register JDBC Driver " + driverClassName + ", Exception:" +e);	  }	}  }  /**   * 將消息寫進日志文件   */  private void log(String msg) {    log.println(mew Date() + ":" + msg);  }    /**   * 將帶有異常的信息寫進日志文件   */  private void log(Throwable e, String msg) {    log.println(mew Date() + ":" + msg);    e.printStackTrace(log);  }    /**   * 一個內部類，代表一個數據庫連接池   */  class DBConnectionPool {    private int checkedOut;	private Vector freeConnection = new Vector();	private int maxConn;	private String name;	private String password;	private String URL;	private String user;	/**	 * 創建一個新的連接池	 *	 * @param name 連接池的名字	 * @param URL 數據庫的JDBC URL	 * @param user 數據庫連接的用戶名	 * @param password 數據庫的用戶口令	 * @param maxConn 最大的連接數，如果為0則每限制	 * 	 */	public DBConnectionPool(String name, String URL, String user		String password, int maxConn) {	  this.name = name;	  this.URL = URL;	  this.user = user;	  this.password = password;	  this.maxConn = maxConn;	}	/**	 * 將連接插入連接池，并通知所有等待連接的其他線程	 *	 * @param con 插入連接	 */	public synchronized void freeConnection(Connection conn) {	  // 將連接放到Vector 對象中其他連接之后	  freeConnections.removeElement(con);	  checkedOut--;	  notifyAll();	}	/**	 * 從連接池得到一個連接， 如果當前沒有空閑的連接，	 * 如果連接數沒有達到最大，則創建一個新的連接	 */	public synchronized Connection getConnection() {	  Connection con = null;	  if (freeConnections.size() >０) {　　		//從Vector對象中得到第一個數據庫連接	    con = (Connection)freeConncetions.firstElement();		//將使用了的數據庫連接從數據庫連接池中刪除		freeConnections.removeElementAt(0);		try		{	      if (con.isClosed())	      {			log("Remove bad conection from " + name);			con = getConnection();	      } 		} catch (SQLException e){	      log("Remove bad connection form " + name);		  con = getConnection();		}	  } else if (maxConn == 0 || checkedOut < maxConn)	  {		con = newConnection();	  }	  if (con != null)	  {		checkedOut++;	  }      return con;	}	/**	 * 從連接池中得到一個連接，如果當前沒有空閑的連接，如果數據庫的連接沒有達到最大	 * 則創建一個新的	 *	 * @param timeout 毫秒為單位的超時的值	 */	public synchronized Connection getConnection(long timeout) {	  //得到當前的時間，作為開始時間	  long startTime = new Date().getTime();	  Connection con;	  while ((con = getConnection()) == null){        try {        	wait(timeout);        } catch (InterruptedException e){		  if ((new Date().getTime() - startTime) >= timeout){			//超時            return null;		  }        }		return con;	  }	}	/**	 *關閉所有的數據庫連接	 */	public synchronized void release() {	  //得到數據庫連接池中的所有連接	  Enumeration allConnections = freeConnections.elements();	  while (allConnctions.hasMoreElements())	  {		 Connection con = (Connection)allConnections.nextElement();		 try		 {		 	//關閉數據庫連接			con.close();			log("Closed connetion for pool" + name);		 }		 catch (SQLException e)		 {		  log(e, "Can't close connection for pool" + name);		 }	  }	  freeConnections.removeAllElments();	}	/**	 *創建一個新的連接，如果可能，使用指定的user和passwoed	 */     private Connection newConnection() {	  Connection con = null;	  try	  {	  	if (user == null)	  	{		  //得到一個新的數據庫連接		  con = DriverManager.getConnection(URL);	  	} else {		  //得到一個新的數據庫連接，使用用戶和koling、		  con = DriverManager.getConnection(URL,user,password);		}		log("Created a new connection in pool " + name);	  }	  catch (SQLException e)	  {		log(e,"Can't create a new connection for " + URL);		return null;	  }	  return con;	}  }}