Connection pool for big web application

Question

hi,
i am developing an application which had more then 20 classes and each class use databases.
i made an connection bean and use it for database connectivity but as my code expand and my application run for longer time i start getting error of connection limit.
then i start using connection pool. in this i start using one connection for whole application.
now i want that my
1-whole application use that connection pool and i dont need to initialize it in different classes.
2- The main problem is that may at a time i have to connect database with different user and these connections should remain active.
my application will be used for enterprise level and remain active for months .
following is my connection pool
public class ConnectionPool implements Runnable
      private Log log=new Log();
      private String driver, url, username, password;
      private int maxConnections;
      private boolean waitIfBusy;
      private Vector availableConnections, busyConnections;
      private boolean connectionPending = false;
      public ConnectionPool(String driver, String url,String username, String password,int initialConnections, int maxConnections, boolean waitIfBusy) 
          this.driver         =     driver;
          this.url            =     url;
          this.username       =     username;
          this.password       =     password;
          this.maxConnections =     maxConnections;
          this.waitIfBusy     =     waitIfBusy;
          if (initialConnections > maxConnections)
            initialConnections = maxConnections;
          availableConnections = new Vector(initialConnections);
          busyConnections = new Vector();
          try
              for(int i=0; i<initialConnections; i++)
                availableConnections.addElement(makeNewConnection());
          catch(Exception e)
            log.write(e.getMessage());
      }//EO constructor
  public synchronized Connection getConnection()
         if (!availableConnections.isEmpty())
              log.write("Total connections="+availableConnections.size());
              Connection existingConnection =  (Connection)availableConnections.lastElement();
              int lastIndex = availableConnections.size() - 1;
              availableConnections.removeElementAt(lastIndex);
              // If connection on available list is closed (e.g.,it timed out), then remove it from available list
              // and repeat the process of obtaining a connection. Also wake up threads that were waiting for a connection because maxConnection limit was reached.
                    try
                        if (existingConnection.isClosed())
                          notifyAll(); // Freed up a spot for anybody waiting
                          return(getConnection());
                        else
                          log.write(  "in available connection"  );
                          busyConnections.addElement(existingConnection);
                          return(existingConnection);
                    catch(SQLException se)
                        log.write(se.getMessage());
          } else {
                    // Three possible cases:
                    // 1) You haven't reached maxConnections limit. So establish one in the background if there isn't
                    //    already one pending, then wait for the next available connection (whether or not it was the newly established one).
                    // 2) You reached maxConnections limit and waitIfBusy flag is false. Throw SQLException in such a case.
                    // 3) You reached maxConnections limit and waitIfBusy flag is true. Then do the same thing as in second
                    //    part of step 1: wait for next available connection.
                    if ((totalConnections() < maxConnections) &&  !connectionPending)
                      makeBackgroundConnection();
                    else if (!waitIfBusy)
                        log.write("Connection limit reached");
                    // Wait for either a new connection to be established (if you called makeBackgroundConnection) or for
                    // an existing connection to be freed up.
                    try {
                      wait();
                    catch(InterruptedException ie)
                      log.write(ie.getMessage());
              // Someone freed up a connection, so try again.
            return(getConnection());
          }//EO main if-else
      return null;
}//EO getconnection method
  // You can't just make a new connection in the foreground
  // when none are available, since this can take several
  // seconds with a slow network connection. Instead,
  // start a thread that establishes a new connection,
  // then wait. You get woken up either when the new connection
  // is established or if someone finishes with an existing
  // connection.
  private void makeBackgroundConnection() {
    connectionPending = true;
    try {
      Thread connectThread = new Thread(this);
      connectThread.start();
    } catch(OutOfMemoryError oome) {
      // Give up on new connection
      log.write(oome.getMessage());
  public void run() {
    try {
      Connection connection = makeNewConnection();
      synchronized(this) {
        availableConnections.addElement(connection);
        connectionPending = false;
        notifyAll();
    } catch(Exception e) { // SQLException or OutOfMemory
      // Give up on new connection and wait for existing one free up.
      log.write(e.getMessage());
  // This explicitly makes a new connection. Called in
  // the foreground when initializing the ConnectionPool,
  // and called in the background when running.
  private Connection makeNewConnection()
    //log.write("make new connection with  "+url+" "+username+" "+password +" and driver= "+driver);
    Connection connection=null;
      try
        // Load database driver if not already loaded
        //Class.forName(driver);
         DriverManager.registerDriver(new OracleDriver());
        // Establish network connection to database
        connection =  DriverManager.getConnection(url, username, password);
                if( connection.isClosed() )
                  log.write("ooooooops no connection");
                else
                  log.write("yahoooo get connection");
      catch(Exception e)
        log.write(e.getMessage());
    return(connection);
  public synchronized void free(Connection connection) {
    busyConnections.removeElement(connection);
    availableConnections.addElement(connection);
    // Wake up threads that are waiting for a connection
    notifyAll();
  public synchronized int totalConnections() {
    return(availableConnections.size() + busyConnections.size());
  /** Close all the connections. Use with caution:
   *  be sure no connections are in use before
   *  calling. Note that you are not <I>required</I> to
   *  call this when done with a ConnectionPool, since
   *  connections are guaranteed to be closed when
   *  garbage collected. But this method gives more control
   *  regarding when the connections are closed.
  public synchronized void closeAllConnections() {
    closeConnections(availableConnections);
    availableConnections = new Vector();
    closeConnections(busyConnections);
    busyConnections = new Vector();
  private void closeConnections(Vector connections) {
    try {
      for(int i=0; i<connections.size(); i++) {
        Connection connection =
          (Connection)connections.elementAt(i);
        if (!connection.isClosed()) {
          connection.close();
    } catch(SQLException sqle) {
      // Ignore errors; garbage collect anyhow
      log.write(sqle.getMessage());
  }i get this code from internet, in which it also mention that use following code
public class BookPool extends ConnectionPool {
private static BookPool pool = null;
private BookPool(...) {
super(...); // Call parent constructor
public static synchronized BookPool getInstance() {
if (pool == null) {
pool = new BookPool(...);
return(pool);
}if some one want to use it for whole application then use connection pool by BookPool,
now main point is i m not getting the BookPool class could some one explain it to me???
and second by using it can i connect to different users of DB at a time, if cant then how i can.
its good if some one explain it by little code.
thxxxxxxxxxxxxxxxxxx

Answer 1

If this is a real, serious application and not just for practice, then why are you trying to write your own connection pool implementation?
You'd better use Jakarta's Commons Pool and Commons DBCP, which are widely used, well tested implementations of connection pools.
If this is a web application running in a J2EE container, you'd normally configure the connection pool in the container. The container will register the pool in JNDI and you'd look it up in JNDI from your application.
Here's some documentation on how to do that in Tomcat 5.5: JNDI Datasource HOW-TO