利用数据库连接池建设网站

 

数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：

1) 最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；

2) 最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。

3) 如果最小连接数与最大连接数相差太大，那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。

在传统的两层结构中，客户端程序在启动时打开数据库连接，在退出程序时关闭数据库连接。这样，在整个程序运行中，每个客户端始终占用一个数据库连接，即使在大量没有数据库操作的空闲时间，如用户输入数据时，从而造成数据库连接的使用效率低下。

在三层结构模式中，数据库连接通过中间层的连接池管理。只有当用户真正需要进行数据库操作时，中间层才从连接池申请一个连接，数据库操作完毕，连接立即释放到连接池中，以供其他用户使用。这样，不仅大大提高了数据库连接的使用效率，使得大量用户可以共享较少的数据库连接，而且省去了建立连接的时间。

以下我将讲述连接池如何在Web工程中的应用，开发工具是Eclipse，采用strut框架

1.新建一个Web工程，工程名任意取（过程略）。

2.配置web.xml。配置文件具体如下：

 xmlns=""
 xmlns:xsi=""
 xsi:schemaLocation=" ">
 
  Set Character Encoding
  
   com.canv.fax.income.SetCharacterEncodingFilter
  
  
   encoding
   GBK
  
 
 
  Set Character Encoding
  /*
 

 
  initServlet
  
   com.canv.fax.context.SystemInitServlet
  
  
   systemName
   sdfax
  
  
   log4j
   WEB-INF/classes/log4j.properties
  
  1
 
 
  action
  
   org.apache.struts.action.ActionServlet
  
  
   config
   /WEB-INF/struts-config.xml
  

   debug
   2
  
  2
 
 
  action
  *.do
 
 
  30
 
 
 faxali
 
  index.html
  index.htm
  index.jsp
  default.html
  default.htm
  default.jsp
 

其中SetCharacterEncodingFilter这是统一编码格式的类，例如统一为GBK。SystemInitServlet这是启动工程时初始化基本信息的类，这里主要是初始化数据库连接池。代码如下：

public class SystemInitServlet extends HttpServlet{
 
 /**
  *
  */
 private static final long serialVersionUID = 1L;

 public SystemInitServlet(){}
 private DbConnectionManager connMgr;
 
 /**
     * 初始化方法
     * @param config ServletConfig
     * @see javax.servlet.Servlet#init(javax.servlet.ServletConfig)
     * @throws ServletException
     */
    public void init(ServletConfig config)
        throws ServletException
    {
        try
        {
            super.init(config);
            System.out.println("Servlet is start!!");
        }

   
   
    public void destroy()
    {
        System.out.println("release system resource...");
    }
}

同时在Web-Inf中增加struts-config.xml文件。

建立连接池的类DbConnectionPool.java.具体代码如下：

package com.canv.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Date;
import java.util.Enumeration;
import java.util.Vector;

public class DbConnectionPool {
 // private int checkedOut;
 private Vector freeConnections = 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
  *            数据库帐号,或 null
  * @param password
  *            密码,或 null
  * @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 con) {
  // 将指定连接加入到向量末尾
  try {
   if (con.isClosed()) {
    System.out.println("before freeConnection con is closed");
   }
   freeConnections.addElement(con);
   Connection contest = (Connection) freeConnections.lastElement();
   if (contest.isClosed()) {
    System.out.println("after freeConnection contest is closed");
   }
   notifyAll();
  } catch (SQLException e) {
   System.out.println(e);
  }
 }

 /**
  * 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接 数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之,
  * 然后递归调用自己以尝试新的可用连接.
  */
 public synchronized Connection getConnection() {
  Connection con = null;
  if (freeConnections.size() > 0) {
   // 获取向量中第一个可用连接
   
   con = (Connection) freeConnections.firstElement();
   System.out.println(" [a 连接池可用连接数 ] : " + "[ "
     + freeConnections.size() + " ]");
   freeConnections.removeElementAt(0);
   System.out.println(" [b 连接池可用连接数 ] : " + "[ "
     + freeConnections.size() + " ]");
   try {
    if (con.isClosed()) {
     System.out.println("从连接池" + name + "删除一个无效连接");
     // 递归调用自己,尝试再次获取可用连接
     con = getConnection();
    }
   } catch (SQLException e) {
    System.out.println("从连接池" + name + "删除一个无效连接出错");
    // 递归调用自己,尝试再次获取可用连接
    con = getConnection();
   }
   if (freeConnections.size() > maxConn) {
    System.out.println(" 删除一个溢出连接 ");
    releaseOne();
   }
  }

  else if ((maxConn == 0) || (freeConnections.size() < maxConn)) {
   con = newConnection();
  }

  return con;
 }
 /**
  * 从连接池获得一个可用连接.如当前连接数小于最大连接数限制,则创建新连接.如果当前可用连接数大于最大连接，则返回一个可用的旧连接，
  * 如原来登记为可用的连接不再有效,则从向量删除之,然后递归调用自己以尝试新的可用连接.此方法经测试保证闲置连接数可能会超过最大连接数，不是很好。
  */
 public synchronized Connection returnConnection() {
  Connection con = null;
  // 如果闲置小于最大连接,返回一个新连接
  if (freeConnections.size() < maxConn) {
   con = newConnection();
  }
  // 如果闲置大于最大连接，返回一个可用的旧连接
  else if (freeConnections.size() >= maxConn) {
   con = (Connection) freeConnections.firstElement();
   System.out.println(" [a 连接池可用连接数 ] : " + "[ "
     + freeConnections.size() + " ]");
   freeConnections.removeElementAt(0);
   System.out.println(" [b 连接池可用连接数 ] : " + "[ "
     + freeConnections.size() + " ]");
   try {
    if (con.isClosed()) {
     System.out.println("从连接池" + name + "删除一个无效连接");
     returnConnection();
    }
   } catch (SQLException e) {
    System.out.println("从连接池" + name + "删除一个无效连接出错");
    returnConnection();
   }
  }
  return con;
 }

 /**
  * 从连接池获取可用连接.可以指定客户程序能够等待的最长时间 参见前一个getConnection()方法.
  *
  * @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) {
    // wait()返回的原因是超时
    return null;
   }
  }
  return con;
 }

 /**
  * 关闭所有连接
  */
 public synchronized void release() {
  Enumeration allConnections = freeConnections.elements();
  while (allConnections.hasMoreElements()) {
   Connection con = (Connection) allConnections.nextElement();
   try {
    con.close();
   } catch (SQLException e) {
   }
  }
  freeConnections.removeAllElements();
 }

 /**
  * 关闭一个连接
  */
 public synchronized void releaseOne() {
  if (freeConnections.firstElement() != null) {
   Connection con = (Connection) freeConnections.firstElement();
   try {
    con.close();
   } catch (SQLException e) {

    System.out.println("无法关闭连接池" + name + "中的一个连接");
   }
  } else {
   System.out
     .println("releaseOne() bug.......................................................");

  }
 }

 /**
  * 创建新的连接
  */
 private Connection newConnection() {
  Connection con = null;
  try {
   if (user == null) {
    con = DriverManager.getConnection(URL);
   } else {
    con = DriverManager.getConnection(URL, user, password);
   }

  } catch (SQLException e) {
   System.out.println("无法创建下列URL的连接: " + URL);
   return null;
  }
  return con;
 }
}

连接池类建好后，再新建DbConnectionManager.java，用来管理连接池，代码如下：

package com.canv.jdbc;

import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;

import com.canv.fax.income.MyPropContext;

public class DbConnectionManager {
 static public DbConnectionManager instance; // 唯一实例

 static public int clients;

 public Vector drivers = new Vector(); // 驱动

 public PrintWriter log; // 日志

 public static Hashtable pools = new Hashtable(); // 连接

 /**
  * 返回唯一实例.如果是第一次调用此方法,则创建实例
  *
  * @return DBConnectionManager 唯一实例
  */
 static synchronized public DbConnectionManager getInstance() {
  
  if (instance == null) {
   instance = new DbConnectionManager();
  }

  return instance;
 }

 /**
  * 建构函数私有以防止其它对象创建本类实例
  */
 public DbConnectionManager() {
  init();
 }

 /**
  * 将连接对象返回给由名字指定的连接池
  *
  * @param name
  *            在属性文件中定义的连接池名字
  * @param con
  *            连接对象
  */
 public static void freeConnection(String name, Connection con) {
  DbConnectionPool pool = (DbConnectionPool) pools.get(name);
  if (pool != null) {
   pool.freeConnection(con);
  } else {
   System.out.println("pool ==null");
  }
  clients--;
 }

 /**
  * 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数 限制,则创建并返回新连接
  *
  * @param name
  *            在属性文件中定义的连接池名字
  * @return Connection 可用连接或null
  */
 public static Connection getConnection(String name) {
  DbConnectionPool pool = (DbConnectionPool) pools.get(name);
  if (pool != null) {
    return pool.getConnection();

}
  return null;
 }

 /**
  * 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制, 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.
  *
  * @param name
  *            连接池名字
  * @param time
  *            以毫秒计的等待时间
  * @return Connection 可用连接或null
  */
 public Connection getConnection(String name, long time) {
  DbConnectionPool pool = (DbConnectionPool) pools.get(name);
  if (pool != null) {
   return pool.getConnection(time);
  }

client++;
  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);

    System.out.println("撤销JDBC驱动程序 " + driver.getClass().getName()
      + "的注册");
   } catch (SQLException e) {
    System.out.println("无法撤销下列JDBC驱动程序的注册: "
      + driver.getClass().getName());
   }
  }
 }

 /**
  * 根据指定属性创建连接池实例.
  *
  * @param props
  *            连接池属性
  */
 private void createPools(Properties props) {
  String url = props.getProperty("sDBConnUrl");
  String user = props.getProperty("sDBUser");
  String password = props.getProperty("sDBPwd");
  int max = Integer.parseInt(props.getProperty("maxConnections"));
  String poolName = props.getProperty("poolName");
  DbConnectionPool pool = new DbConnectionPool(poolName, url,
    user, password, max);
  pools.put(poolName, pool);
  System.out.println("成功创建连接池" + poolName);
 }

 /**
  * 读取属性完成初始化
  */
 private void init() {
  try {   
   loadDrivers(MyPropContext.prop);
   createPools(MyPropContext.prop);
  } catch (Exception e) {
  }
 }

 /**
  * 171 * 装载和注册所有JDBC驱动程序 172 * 173 *
  *
  * @param props
  *            属性 174
  */
 private void loadDrivers(Properties props) {
  
  String driverClasses = props.getProperty("DB_DRIVER");
  StringTokenizer st = new StringTokenizer(driverClasses);
  while (st.hasMoreElements()) {
   String driverClassName = st.nextToken().trim();
   try {
    Driver driver = (Driver) Class.forName(driverClassName)
      .newInstance();
    DriverManager.registerDriver(driver);
    drivers.addElement(driver);
   } catch (Exception e) {
    System.out.println("无法注册JDBC驱动程序: " + driverClassName
      + ", 错误: " + e);
   }
  }
 }
}

连接池类和管理连接池的类建立后，接下来最关键的一步，初始化连接池。在SystemInitServlet类中声明一个私有变量private DbConnectionManager connMgr，在init方法中增加connMgr.getInstance()初始化连接池，在destroy方法中添加connMgr.release();释放所有的链接。

工程基本完成，就差测试了。新建index.jsp页面，在页面中添加一个超链接获取数据。然后在struts-config.xml中添加

   type="com.canv.action.GetDateAction">
   

GetDate.java代码如下：

public class GetDataAction extends Action{
 public ActionForward execute(
         ActionMapping mapping,
         ActionForm actionForm,
         HttpServletRequest request,
         HttpServletResponse response) throws Exception {
  ResultSet rs = null;
  Statement stmt = null;
  Connection conn = null;
  try {
   
   //从连接池中获取连接
    conn = DbConnectionManager.getConnection("mypool");
   String sql = "select * from fax_user where uid='20582'";
   if( null != conn){
    stmt = conn.createStatement();
    rs = stmt.executeQuery(sql);
    if( rs.next() ){
     System.out.println("username=" + rs.getString("username"));
    }
    stmt.close();
    rs.close();
   }
   //把链接返回给连接池
   DbConnectionManager.freeConnection("mypool", conn);
  }catch(Exception e){
   e.printStackTrace();
  }finally{
   
  }
  return null;
 }
}

OK!