dbconnectionmanager.java

自己写的一个数据库连接池

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