connectionpool.java

采用Struts框架做的网上啤酒买卖系统

package com.cavaness.beer4all.database;

import java.sql.*;
import java.util.*;
import java.io.*;
/**
 *本类为数据库连接池管理类，实现空闲数据库连接对象的管理工作
 */
public class ConnectionPool extends Thread{

  //保存与数据库驱动相关的信息
  private String driver = new String("");
  private String url = new String("");
  private int size = 0;
  private int maxsize=5;
  private String username = new String("");
  private String password = new String("");

  //保存缓存的数据库连接对象
  private ArrayList pool = new ArrayList();

  //初始化数据库连接池
  public synchronized void initConnectionPool()
  {
     try
     {
       //从配置文件中加载数据库驱动程序信息
       InputStream fin=this.getClass().getResourceAsStream("/db.properties");
       Properties prop=new Properties();
       prop.load(fin);

       driver=prop.getProperty("driver","sun.jdbc.odbc.JdbcOdbcDriver");
       url=prop.getProperty("url","jdbc:odbc:catalog");
       username=prop.getProperty("username","");
       password=prop.getProperty("password","");
       size=Integer.parseInt(prop.getProperty("size","2"));
       maxsize=Integer.parseInt(prop.getProperty("maxsize","5"));

       Class.forName(driver);
       for(int i=0;i<size;i++)
       {
         Connection con = createConnection();
         if ( con != null )
         {
           con.setAutoCommit(false);
           PooledConnection pcon = new PooledConnection(con);
           pool.add(pcon);
         }

       }
     }
     catch (SQLException sqle) {
        sqle.printStackTrace();
     }
     catch (ClassNotFoundException cnfe) {
        cnfe.printStackTrace();
     }
     catch (Exception e) {
        e.printStackTrace();
     }
  }
  // 创建并返回一个数据库连接对象
  private Connection createConnection() throws SQLException {
    Connection con = null;
    con = DriverManager.getConnection(url,username, password);
    return con;
  }

  //归还一个数据库连接对象到缓存池中
  public synchronized void releaseConnection(Connection con) {
    Iterator it = pool.iterator();
    while (it.hasNext())
    {
      PooledConnection pcon = (PooledConnection) it.next();
      if (pcon.getConnection() == con)
      {
        pcon.setInUse(false);
        break;
      }
    }
  }
  //从缓存池中得到一个空闲的数据库连接对象
  public synchronized Connection getConnection() throws SQLException {
    PooledConnection pcon = null;

    //首先从缓存池中查找，看是否有空闲的数据库连接对象
    Iterator it = pool.iterator();
    while (it.hasNext())
    {
      pcon = (PooledConnection) it.next();
      if (pcon.inUse() == false)
      {
        pcon.setInUse(true);
        return pcon.getConnection();
      }
    }

    //当缓存池中没有空闲的数据库连接对象时，则新建一个并返回
    try {
      Connection con = createConnection();
      pcon = new PooledConnection(con);
      pcon.setInUse(true);
      pool.add(pcon);
    }
    catch (Exception e) {
      System.err.println(e.getMessage());
    }
    return pcon.getConnection();
  }

  // 当完后，应该清空数据库连接池
  public synchronized void emptyPool() {

    Iterator it=pool.iterator();
    while(it.hasNext())
    {
      PooledConnection pcon =(PooledConnection)it.next();
      pcon.close();
    }
  }

  //利用子线程，在适当的时刻释放多余的数据库连接对象
  public void run()
  {
    try
    {
      Thread.sleep(1000*60*2);//每鬲2分钟，清除一次

      synchronized(this)
      {
        while(pool.size()>maxsize)
        {
          PooledConnection pcon =(PooledConnection)pool.remove(pool.size()-1);
           pcon.close();
        }
      }
    }
    catch(InterruptedException ie)
    {
      ie.printStackTrace();
    }
  }

  //利用单件模式，确保数据库池对象的唯一性
  private static ConnectionPool conPool=new ConnectionPool();
  //私有的构造函数
  private ConnectionPool() {
    //初始化数据库连接池
    initConnectionPool();
    //启动线程
    this.start();
  }
  //公有的静态成员函数，返回唯一的数据库连接池对象
  public static ConnectionPool getInstance()
  {
    return conPool;
  }
}