package cn.com.edu.gui.model;
/**
 * <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(".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(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.driver");
  StringTokenizer st = new StringTokenizer(driverClasses);

  while (st.hasMoreTokens()){
    String driverClassName = st.nextToken().trim();
    try
    {
      Driver driver = (Driver)Class.forName(driverClassName).newInstance();
    DriverManager.registerDriver(driver);
    drivers.addElement(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(new Date() + ":" + msg);
  }
  

  /**
   * 將帶有異常的信息寫進日志文件
   */
  private void log(Throwable e, String msg) {
    log.println(new 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 對象中其他連接之后
      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 (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 = freeConnection.elements();

    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);
     }
    }
      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;
  }
  }
}