package cn.edu.jdbc.common;/** * <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 = new 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.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());      }    }  }  /**   * 基于屬性創建DBConnectionPool的實例 DBConnectionPool 可是使用下面的屬性   *    * <poolname>.url 數據庫的url <poolname>.user 數據庫用戶 <poolname>.password 數據庫用戶的口令   * <poolname>.maxconn 連接的最大數目   *    * @param props   *          數據庫連接池的屬性   *    */  public void createPools(Properties props) {    Enumeration propNames = props.propertyNames();    while (propNames.hasMoreElements()) {      //獲得文件中的所有屬性名信息      String name = (String) propNames.nextElement();      if (name.endsWith(".drivers")) {        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);        //將創建的連接池對象保存在hashMap中        pools.put(poolName, pool);        // log("Invalid pool" + poolName);      }    }  }  /**   * 裝載屬性并用其值初始化實例   */  private void init() {    // InputStream is = getClass().getResourceAsStream("/db.properties");    Properties dbProps = new Properties();    try {      FileInputStream is = new FileInputStream(new File("db.properties"));      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(Properties props) {    String driverClasses = props.getProperty("oracle.drivers");    // StringTokenizer st = new StringTokenizer(driverClasses);    //    // while (st.hasMoreTokens()){    // String driverClassName = st.nextToken().trim();    try {      // Driver driver = (Driver)Class.forName(driverClassName).newInstance();      Driver driver = (Driver) Class.forName(driverClasses).newInstance();      DriverManager.registerDriver(driver);      drivers.addElement(driver);      // log("Registerd JDBC Driver " +driverClassName);    }    catch (Exception e) {      // log("Can't register JDBC Driver " + driverClasses + ", Exception:" +      // e);    }    // }  }  /**   * 將消息寫進日志文件   */  // private void log(String msg) {  // log.println(new Date() + ":" + msg);  // }  /**   * 將帶有異常的信息寫進日志文件   */  // private void log(Throwable e, String msg) {  // log.println(new Date() + ":" + msg);  // e.printStackTrace(log);  // }  /**   * 一個內部類，代表一個數據庫連接池   */  private class DBConnectionPool {        //被取走的連接對象個數    private int checkedOut;    //存放連接對象的集合對象    private Vector freeConnection = new Vector();    //定義連接池的最大連接數    private int maxConn;    //定義連接池的名稱    private String name;    //數據庫訪問密碼    private String password;    //數據庫url    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 對象中其他連接之后      freeConnection.addElement(conn);      checkedOut--;            //喚醒其他線程來執行連接池的各種功能操作      notifyAll();    }    /**     * 從連接池得到一個連接， 如果當前沒有空閑的連接， 如果連接數沒有達到最大，則創建一個新的連接     */    public synchronized Connection getConnection() {      Connection con = null;      if (freeConnection.size() > 0) {        // 從Vector對象中得到第一個數據庫連接        con = (Connection) freeConnection.firstElement();        // 將使用了的數據庫連接從數據庫連接池中刪除        freeConnection.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 (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 = freeConnection.elements();      //循環關閉vector中所有連接對象      while (allConnections.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);        }      }      //刪除Vector中關閉的所有連接對象      freeConnection.removeAllElements();    }    /**     * 創建一個新的連接，如果可能，使用指定的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;    }  }}