Connection.isClosed implementation

Hi, I posted this in database.general, but this is probably the best forum. We're using the oracle.jdbc.driver.OracleDriver.
thanks
David
Connection.isClosed implementation
Posted: Jul 4, 2008 9:20 AM
Click to reply to this thread Reply
Hi
How does Oracle implement the Conneciton.isClosed call? Does it run any sql against the db, or execute a stored proc. Are there any options to select either, or to disable the call?
Our application uses both Sybase and Oracle, and we're finding that Sybase calls a stored procedure on the db by default to check the connection. This may be leading to a performance problem we're investigating. I was wondering how Oracle implemented the same call.
Many thanks

Well, by spec, the call is defined to be fairly useless. It says it should not
be sending anything to the DBMS. It is supposed to simply return true if
the connection was closed via the close() call. The spec also has the
isValid() call that does more checking, so the Sybase driver is behaving
wrongly, and it is likely your code doesn't need to be calling isClosed()
at all, unless it's disorganized enough that connection users can't be sure
whether their connections may have been closed elsewhere or not...
Joe Weinstein

Similar Messages

Connection Pooling implementation

Hi,
I realize that most J2EE containers support pooling as per the JDBC 3.0 API. But I am looking for a generic connection pooling implementation for JDBC that I can use in my applicaiton without having to write the pooling mechanism myself..
Is there a JDBC connection pool implementation out there (free would be good !), that can be integrated with any app (not neccessarily running inside a J2EE container.
Thanks

You can get one from Jakarta Commons.

Connection pooling implementation in struts

hi I want to implement login process in struts but now i m facing problem , I have written the code for connection pooling but now m in confusion where to call this code bcoz it should be called at once if not called earlier, so that i can use this connection object in search, add, delete, and update actions.
thanks in advance
pranav

thanks a lot, but i didn't get my answer. i want to know where adjectly i need to call this connection pooling class in modal or in controller of struts?

Where is the connection pooling implemented?

Hi!
I�m a bit curious. Does anybody know where the connection pooling is implemented? Is it in the provider or in the Oracle client?
Best regards,
Mattias Alm�n, Consignit AB

It is implemented in the provider.
Thanks
Martha

Generic Connection Framework implementation for J2SE

Hi all,
I need to use HttpConnection and Connector in my J2SE application because it was ported from CLDC/MIDP environment.
I found that there is a JSR (197) but I not found an implementation of this document. The only usefull link I found with Google is this:
http://www.microjava.com/articles/techtalk/connection_framework?content_id=798
but with this method I can't obtain HttpConnection...
Can you help me?
Thanks,
Renato

First of all: thanks :-).
I don't know how to transalte these methods:
getPort
getProtocol
getQuery
getRef
getRequestMethod
getRequestProperty
getResponseCode
getResponseMessage
getURL
setRequestMethod
setRequestProperty
getEncoding
getLength
getType
I made a library to use http over bluetooth from a MIDP device, so I need all HttpConnection method.
Thank you,
Renato

ResultSet problem with a jdbc connection pool implementation

Hi
I'm trying to use jdbc connection pool in my java application (js2e 1.4.0_01)
from the example at http://www.developer.com/tech/article.php/626141
In my main() code, in addition to JDBCConnection, JDBCConnectionImpl and JDBCPool classes, i use
JDBCConnection conn;
conn = new JDBCConnection(dbName);
// make a statement
sqlString = "SELECT........."
ResultSet rs = null;
rs = conn.sendRequest(sqlString, rs);
// print result
while (rs.next()) {
Unfortunately i get an error like "ResultSet is closed" in the line corresponding to rs.next. The error disappears if i remove the line
stmt.close();
in the method sendRequest of the JDBCConnectionImpl class.
1) Does anybody knows the solution?
2) How to close all connections?
Thanks you in advance.

Hi ,
You are closing the statement and then trying to use resultset , which is not going to work .So close then statment after using resultset .Ideally the code should be like this
try {
conn = // get the connection
pstmt = conn.prepareStatement(sql);
rs = pstmt.executeQuery();
while ( rs.next()){
// do something
catch (Exception ex) {
finally {
try {
if (rs != null)
rs.close();
if (pstmt != null)
pstmt.close();
if(conn!=null )
conn.close();

Connect Failover implementation

I have an application which connects to a RAC 9i through DataDirect JDBC, which doesn't use OCI to my knowledge (or is it?), so it doesn't use a TNS defintion with failover enabled.
Is there an automatic connect failover between the nodes in case on a crash of one of the instances?
If instance 1 fails would listener 1 redirect new connections to listener 2 on node 2 ?

<p>Hi -</p>
<p>I don't know much specifically about the DataDirect JDBC driver, but if it is not the JDBC Thin driver you are using the OCI-based JDBC driver. Assuming that you are using the OCI-based driver then yes it does use the TNS definition with failover enabled as well as a TAF policy setup according to your needs.</p>
<p>The only way you can have an automatic connect failover is if you have your tnsnames.ora enteries correctly configured to take advantage of this feature and have the proper coding in your application to utilize the OracleOCIFailover interface.</p>
<p>See the following docs for more informaiton on JDBC, OCI, and TAF.</p>
<ul>
<li>TAF Callbacks</li>
<li>OCI Driver Transparent Application Failover</li>
<li>Java TAF Callback Interface</li>
<li>Table of Contents for Oracle9i JDBC Developer's Guide and Reference</li>
<li>Table of Contents for Oracle Call Interface Programmer's Guide</li>
</ul>
<p>-shawn</p>

Shared Connection Pool via Singleton

I have just started to learn Java (more jsp & servlets) and have been going through "Core Servlets and Java Server Pages" and in there is stuff on connection pooling. The author provides a good a connection pool servlet that can be shared, but as I'm new and don't fully understand how everything works (got a basic idea).
How do i go about making the following code accessiable via a singleton class?
ConnectionPool Class
package sco;
import java.sql.*;
import java.util.*;
/** A class for preallocating, recycling, and managing
* JDBC connections.
* <P>
* Taken from Core Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.coreservlets.com/.
* © 2000 Marty Hall; may be freely used or adapted.
public class ConnectionPool implements Runnable {
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)
      throws SQLException {
    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();
    for(int i=0; i<initialConnections; i++) {
      availableConnections.addElement(makeNewConnection());
public synchronized Connection getConnection()
      throws SQLException {
    if (!availableConnections.isEmpty()) {
      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.
      if (existingConnection.isClosed()) {
        notifyAll(); // Freed up a spot for anybody waiting
        return(getConnection());
      } else {
        busyConnections.addElement(existingConnection);
        return(existingConnection);
    } 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) {
        throw new SQLException("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) {}
      // Someone freed up a connection, so try again.
      return(getConnection());
// 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
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
      // to free up.
// This explicitly makes a new connection. Called in
// the foreground when initializing the ConnectionPool,
// and called in the background when running.
private Connection makeNewConnection()
      throws SQLException {
    try {
      // Load database driver if not already loaded
      Class.forName(driver);
      // Establish network connection to database
      Connection connection =
        DriverManager.getConnection(url, username, password);
      return(connection);
    } catch(ClassNotFoundException cnfe) {
      // Simplify try/catch blocks of people using this by
      // throwing only one exception type.
      throw new SQLException("Can't find class for driver: " +
                             driver);
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
public synchronized String toString() {
    String info =
      "ConnectionPool(" + url + "," + username + ")\n" +
      ", available=" + availableConnections.size() + "\n" +
      ", busy=" + busyConnections.size() + "\n" +
      ", max=" + maxConnections;
    return(info);
ScoPool Class (singleton to access the connection pool)
package sco;
public class ScoPool extends ConnectionPool {
private ScoPool pool = null;
private ScoPool() {
    super(); // Call parent constructor
public static synchronized ScoPool getInstance() {
    if(pool == null) {
      pool = new ScoPool();
    return(pool);
}Please help a newbie.

Figured it out.
package sco;
import java.sql.SQLException;
public class ScoPool extends ConnectionPool {
private static ScoPool pool;
private ScoPool(String driver, String url, String username, String password,
                  int initialConnections, int maxConnections, boolean waitIfBusy) throws SQLException {
    super(driver, url, username, password, initialConnections, maxConnections, waitIfBusy); // Call parent constructor
public static synchronized ScoPool getInstance() {
    if(pool == null) {
      String driver = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
      String url = "jdbc:microsoft:sqlserver://MIM-W0432:1433;DatabaseName=sco";
      String username = "sco_user";
      String password = "123";
      int initCon = 5;
      int maxCon = 10;
      boolean waitIfBusy = true;
      try {
        pool = new ScoPool(driver, url, username, password, initCon, maxCon, waitIfBusy);
      catch(SQLException sqle) {
    return pool;
}

Connection pool for big web application

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

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

Setting up a connection pool to ms sql database

Hi
I am trying to create a connection pool to talk to an MSSQL database, and could not manage to ping the DB (Operation 'pingConnectionPool' failed in 'resources' Config Mbean.) .
What set of properties need to be included for connection pool to an MS SQL DB?
your help is very much appreciated,
Yhank you
orms2004

package coreservlets;
import java.sql.*;
import java.util.*;
/** A class for preallocating, recycling, and managing
* JDBC connections.
* <P>
* Taken from Core Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.coreservlets.com/.
* © 2000 Marty Hall; may be freely used or adapted.
public class ConnectionPool implements Runnable {
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)
      throws SQLException {
    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();
    for(int i=0; i<initialConnections; i++) {
      availableConnections.addElement(makeNewConnection());
public synchronized Connection getConnection()
      throws SQLException {
    if (!availableConnections.isEmpty()) {
      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.
      if (existingConnection.isClosed()) {
        notifyAll(); // Freed up a spot for anybody waiting
        return(getConnection());
      } else {
        busyConnections.addElement(existingConnection);
        return(existingConnection);
    } 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) {
        throw new SQLException("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) {}
      // Someone freed up a connection, so try again.
      return(getConnection());
// 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
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
      // to free up.
// This explicitly makes a new connection. Called in
// the foreground when initializing the ConnectionPool,
// and called in the background when running.
private Connection makeNewConnection()
      throws SQLException {
    try {
      // Load database driver if not already loaded
      Class.forName(driver);
      // Establish network connection to database
      Connection connection =
        DriverManager.getConnection(url, username, password);
      return(connection);
    } catch(ClassNotFoundException cnfe) {
      // Simplify try/catch blocks of people using this by
      // throwing only one exception type.
      throw new SQLException("Can't find class for driver: " +
                             driver);
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
public synchronized String toString() {
    String info =
      "ConnectionPool(" + url + "," + username + ")" +
      ", available=" + availableConnections.size() +
      ", busy=" + busyConnections.size() +
      ", max=" + maxConnections;
    return(info);
}taken from:
http://archive.coreservlets.com/Chapter18.html

How to make connection Pool for standalone Application

hi
I have got an application to craete a stadalone appliaction for connection pool.But it is taking m more time to create the Connection and fetch the data.
import java.sql.*;
import java.util.*;
/** A class for preallocating, recycling, and managing
* JDBC connections.
* <P>
* Taken from Core Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.coreservlets.com/.
* © 2000 Marty Hall; may be freely used or adapted.
public class ConnectionPool implements Runnable {
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)
      throws SQLException {
    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();
    for(int i=0; i<initialConnections; i++) {
      availableConnections.addElement(makeNewConnection());
public synchronized Connection getConnection()
      throws SQLException {
    if (!availableConnections.isEmpty()) {
      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.
      if (existingConnection.isClosed()) {
        notifyAll(); // Freed up a spot for anybody waiting
        return(getConnection());
      } else {
        busyConnections.addElement(existingConnection);
        return(existingConnection);
    } 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) {
        throw new SQLException("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) {}
      // Someone freed up a connection, so try again.
      return(getConnection());
// 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.
public void makeBackgroundConnection() {
    connectionPending = true;
    try {
      Thread connectThread = new Thread(this);
      connectThread.start();
    } catch(OutOfMemoryError oome) {
      // Give up on new connection
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
      // to free up.
// This explicitly makes a new connection. Called in
// the foreground when initializing the ConnectionPool,
// and called in the background when running.
public Connection makeNewConnection()
      throws SQLException {
    try {
      // Load database driver if not already loaded
      Class.forName(driver);
      // Establish network connection to database
      Connection connection =
        DriverManager.getConnection(url, username, password);
      return(connection);
    } catch(ClassNotFoundException cnfe) {
      // Simplify try/catch blocks of people using this by
      // throwing only one exception type.
      throw new SQLException("Can't find class for driver: " +driver);
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();
public 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
public synchronized String toString() {
    String info =
      "ConnectionPool(" + url + "," + username + ")" +
      ", available=" + availableConnections.size() +
      ", busy=" + busyConnections.size() +
      ", max=" + maxConnections;
    return(info);
}///// The Calling Class is below---------/////////////////
import java.util.*;
import java.sql.*;
public class dbConnection
     public static void main(String[] args)
          String driver="oracle.jdbc.driver.OracleDriver";
          String username="ETS";
          String password="ETS";
          String url="jdbc:oracle:thin:@192.168.47.10:1521:ETS";
          int initialConnections=10;
        int maxConnections=50;
          boolean waitIfBusy=false;
          Connection con=null;
          Statement stmt = null;
          ResultSet rs = null;
          try
          System.out.println("Before constructory "+new java.util.Date());
          ConnectionPool pool=new ConnectionPool(driver,url,username,password,initialConnections,maxConnections,waitIfBusy);
          System.out.println("After constructory "+new java.util.Date());
                    con=pool.makeNewConnection();
     System.out.println("After Connection pool "+new java.util.Date());
                    String sql="select * from emp_master";
                    stmt = con.createStatement();
                    rs = stmt.executeQuery(sql);
                    while(rs.next()) {
               int login1=rs.getInt("emp_code");
                    System.out.println("Employee Code is "+login1);
                    System.out.println("check 2");
               String pass=rs.getString("PASSWORD");
                    System.out.println("Pass Word is "+pass);
          }catch(Exception e)
               System.out.println("Exception is "+e);
          finally {
}

I once created a connection pool programatically with Apache DBCP API. It didnt took more than 10 lines. Unforchunetly I dont have to code with me now.
But If I remember right there is a sample code for that in the Apache Commans DBCP documentation.

How to test if db connection is available

I have got the following code to conenct to database.
package com.db;
import java.util.*;
import java.io.*;
import java.sql.*;
import javax.servlet.http.*;
public class ConnectionManager implements HttpSessionBindingListener
private Connection connection;
private Statement statement;
private String driver = "";
private String dbURL = "";
private String login = "";
private String password = "";
static public void main(String[] args)
      ConnectionManager cm = new ConnectionManager();
} // main
public ConnectionManager()
       Properties Prop = new Properties();
       try {
          InputStream configStream = getClass().getResourceAsStream("/config/database.properties");
               Prop.load(configStream);
          configStream.close();
           } catch(IOException e) {
                  System.out.println("Error: Cannot laod configuration file ");
       driver =Prop.getProperty("driver");
       dbURL = Prop.getProperty("dbURL");
        login = Prop.getProperty("login");
        password = Prop.getProperty("password");
public void setDriver (String sDriver)
   if (sDriver != null)
       driver = sDriver;
public String getDriver ()
   return driver;
public void setDbURL (String sDbURL)
    if (sDbURL != null)
     dbURL = sDbURL;
public String getDbURL()
   return dbURL;
public void setLogin (String sLogin)
   if (sLogin != null)
      login = sLogin;
public String getLogin()
   return login;
public void setPassword (String sPassword)
   if (sPassword != null)
      password = sPassword;
private String getPassword()
   return password;
private void getConn ()
   try
      Class.forName(driver);
      connection = DriverManager.getConnection(dbURL,login,password);
      statement=connection.createStatement();
   catch (ClassNotFoundException e)
      System.out.println("ConnectionManager: driver unavailable");
      connection = null;
   catch (SQLException e)
      System.out.println("ConnectionManager: driver not loaded");
      connection = null;
public Connection getConnection()
   if (connection == null)
      getConn();
   return connection;
public void commit() throws SQLException
    connection.commit();
public void rollback() throws SQLException
    connection.rollback();
public void setAutoCommit(boolean autoCommit)
    throws SQLException
    connection.setAutoCommit(autoCommit );
public ResultSet executeQuery(String sql) throws SQLException
    if (connection == null || connection.isClosed())
        getConn();
    return statement.executeQuery(sql);
public int executeUpdate(String sql) throws SQLException
    if (connection == null || connection.isClosed())
        getConn();
    return statement.executeUpdate(sql);
public void valueBound(HttpSessionBindingEvent event)
    System.err.println("ConnectionBean: in the valueBound method");
    try
      if (connection == null || connection.isClosed())
        connection = DriverManager.getConnection(dbURL,login,password);
        statement = connection.createStatement();
    catch (SQLException e)
      e.printStackTrace();
      connection = null;
public void valueUnbound(HttpSessionBindingEvent event)
    close();
public void close()
   try
       if ( connection != null
            || !connection.isClosed())
        connection.close();
   catch (SQLException e)
      e.printStackTrace();
My aim is to find out if a connection is available. so that when multiple user hit the first page, it will serve the user only when a connection is available and will display an error message if there is non.
I have tried the following with database shutdown. This still return a string regardless if any connection is available.
<%
com.db.ConnectionManager CM = new com.db.ConnectionManager();
out.println(CM);
%>Please could you suggest a way I could know if a conenction is availble.
Thank you.

I would propose you create a Stack of Connections POP out the Connection whenever a user requests and Push a Connection back when the User is through and releases the connection this way if you try to POP a connection which is not present you can notify the user that the Connection is not available .
Ideally the Architecture of the class should be like this :-
A Class SQLProvider
some methods within it like
getConnection [Should be a Static Method ]
return Connection
destroy etc etc
The Instance will be a Vector which will be used as a stack You can Use a Stack either . and the Connection will be a part of the Vector / Stack .
The getConnection will Pop out elements and if not present should return a Message / Exception this is to your requirements .
A Static Code snippet which will populate the Stack once with the connection etc .
Does that Gives you Idea how to write the code ?
S

Problem Connecting To MS SQL Server Via JSP

Please advise !
My envoironment is Windows 2000, j2sdk1.4.1_02, Java Web Services Developer Pack 1.1.
I have set my system variables as below :
JAVA_HOME : C:\j2sdk1.4.1_02
CATALINA_HOME : C:\jwsdp-1.1
CLASSPATH : %JAVA_HOME%\lib;%CATALINA_HOME%\lib;.
PATH : %JAVA_HOME%\bin;
I have copied all the *.jar files from "C:\jwsdp-1.1\jaxp-1.2.2\lib\endorsed" to "C:\j2sdk1.4.1_02\jre\lib".
I have download and install the Microsoft SQL Server 2000 Driver for JDBC. I copied msbase.jar, msutil.jar, mssqlserver.jar to "C:\j2sdk1.4.1_02\lib".
I have created database call "test" in my local SQL server.
I have created table call "Conferences"
I have created those file :
ConnectionBean.java
import java.sql.*;
import javax.sql.*;
import javax.naming.*;
import javax.servlet.http.*;
public class ConnectionBean implements HttpSessionBindingListener {
     private Connection connection;
     private Statement statement;
     private static final String driver="com.microsoft.jdbc.sqlserver.SQLServerDriver";
     private static final String dbURL="jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=test;"; // database address/database name
     private static final String login="sa";
     private static final String password="";
     public ConnectionBean()
     try {
          Class.forName(driver);
          connection=DriverManager.getConnection(dbURL,login,password);
          statement=connection.createStatement();
     catch (ClassNotFoundException e) {
          System.err.println("ConnectionBean : driver unavailable");
          connection = null;
     catch (SQLException e) {
          System.err.println("ConnectionBean : driver not loaded");
          connection = null;
public static void main(String args[]){
     ConnectionBean nb = new ConnectionBean();
     public Connection getConnection()
     return connection;
     public void commit() throws SQLException
     connection.commit();
     public void rollback() throws SQLException
     connection.rollback();
     public void setAutoCommit (boolean autoCommit) throws SQLException
     connection.setAutoCommit(autoCommit);
     public ResultSet executeQuery (String sql) throws SQLException
     return statement.executeQuery(sql);
     public int executeUpdate(String sql) throws SQLException
     return statement.executeUpdate(sql);
     public void valueBound(HttpSessionBindingEvent event)
     System.err.print("Connection: in the valueBound method");
try
          if (connection == null || connection.isClosed())
          connection=DriverManager.getConnection(dbURL,login,password);
          statement=connection.createStatement();
     catch (SQLException e) { connection = null; }
     public void valueUnbound(HttpSessionBindingEvent event)
     try
connection.close();
catch (SQLException e) { }
finally
connection = null;
     protected void finalize()
     try
     connection.close();
catch (SQLException e) { }
conference.jsp
<%@ page import="java.sql.*" %>
<jsp:useBean id="connection" class"ConnectionBean" scope="session" />
<html>
<body>
<center>
<font size="+2" face="arial"><b>Conference Registration</b></font>
<form action="shuttle.jsp" method="post">
<table border=1 bgcolor="tan" width="50%" align="center">
<tr><td>
<table border="0" bgcolor="white" cellspacing=0 width="100%"
<tr bgcolor="tan">
<th>?</th><th>City</th><th>Tickets Remaining</th><tr>
<%
Strign sql = "SELECT * FROM Conferences";
ResultSet results = connection.executeQuery(sql);
while (results.next()){
if (results.getInt("seats") > 0) {
%>
<td>
<input type="radio" name="show"
value="<%= results.getString("id") %>">
</td>
<% } else { %>
<td>?</td>
<% } %>
<td><%= results.getString("city") %></td>
<td align="center"><%= results.getString("seats") %></td>
</tr>
<% } %>
</table>
</td></tr></table>
<p>
<input type="submit" value="Next Choose Shuttle)">
</form>
</center>
</body>
</html>
I created 2 folder call "WEB-INF" and "classes" in my web server directory.
I have compiled the ConnectionBean.java and copied the ConnectionBean.class to my "classes" folder.
But i get an error like this :
type Exception report
message
description The server encountered an internal error () that prevented it from fulfilling this request.
exception
org.apache.jasper.compiler.ParseException: /conference.jsp(1,34) Attribute class has no value
     at org.apache.jasper.compiler.JspReader.parseAttributeValue(JspReader.java:563)
     at org.apache.jasper.compiler.JspReader.parseTagAttributesBean(JspReader.java:616)
     at org.apache.jasper.compiler.Parser$Bean.accept(Parser.java:654)
     at org.apache.jasper.compiler.Parser.parse(Parser.java:1145)
     at org.apache.jasper.compiler.Parser.parse(Parser.java:1103)
     at org.apache.jasper.compiler.Parser.parse(Parser.java:1099)
     at org.apache.jasper.compiler.ParserController.parse(ParserController.java:213)
     at org.apache.jasper.compiler.Compiler.compile(Compiler.java:210)
     at org.apache.jasper.servlet.JspServlet.loadJSP(JspServlet.java:548)
     at org.apache.jasper.servlet.JspServlet$JspServletWrapper.loadIfNecessary(JspServlet.java:176)
     at org.apache.jasper.servlet.JspServlet$JspServletWrapper.service(JspServlet.java:188)
     at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:381)
     at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:473)
     at javax.servlet.http.HttpServlet.service(HttpServlet.java:853)
     at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:247)
     at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:193)
     at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:260)
     at org.apache.catalina.core.StandardPipeline$StandardPipelineValveContext.invokeNext(StandardPipeline.java:646)
     at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:483)
     at org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:995)
     at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:191)
     at org.apache.catalina.core.StandardPipeline$StandardPipelineValveContext.invokeNext(StandardPipeline.java:646)
     at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:483)
     at org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:995)
     at org.apache.catalina.core.StandardContext.invoke(StandardContext.java:2349)
     at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:180)
     at org.apache.catalina.core.StandardPipeline$StandardPipelineValveContext.invokeNext(StandardPipeline.java:646)
     at org.apache.catalina.valves.ErrorDispatcherValve.invoke(ErrorDispatcherValve.java:170)
     at org.apache.catalina.core.StandardPipeline$StandardPipelineValveContext.invokeNext(StandardPipeline.java:644)
     at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:171)
     at org.apache.catalina.core.StandardPipeline$StandardPipelineValveContext.invokeNext(StandardPipeline.java:644)
     at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:483)
     at org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:995)
     at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:174)
     at org.apache.catalina.core.StandardPipeline$StandardPipelineValveContext.invokeNext(StandardPipeline.java:646)
     at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:469)
     at org.apache.catalina.core.StandardPipeline$StandardPipelineValveContext.invokeNext(StandardPipeline.java:644)
     at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:483)
     at org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:995)
     at org.apache.coyote.tomcat4.CoyoteAdapter.service(CoyoteAdapter.java:223)
     at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:405)
     at org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.processConnection(Http11Protocol.java:376)
     at org.apache.tomcat.util.net.TcpWorkerThread.runIt(PoolTcpEndpoint.java:508)
     at org.apache.tomcat.util.threads.ThreadPool$ControlRunnable.run(ThreadPool.java:518)
     at java.lang.Thread.run(Thread.java:536)
It look like cant find the class, I have try copied ConnectionBean.class to "C:\jwsdp-1.1\common\classes", but still came out a some error message.
I'm very sad and demotivate because i have try so many time and i still cant make it.
Please help ! thank you.
regards.

What's creating the connection and putting it into the session scope?
I'd start looking at the docs to figure out how to set up a data source for your app.
I know how to do it for Tomcat 4.1.24. Does Tomcat come bundled with the Java Web Services Developer Pack 1.1? If so, check this out:
http://jakarta.apache.org/tomcat/tomcat-4.1-doc/jndi-datasource-examples-howto.html

How to handle a Connection Timeout

Hi Everybody,
My situation is as follows: I have a web application, some sort of content management system. I'm using MySQL to store information. The application is obtaining Connection objects via a Connection Pool. I'm runngin Sun Java Application Server 8 Update 1 and MySQL 4.1.9 on a Windows 2003 Server machine.
After 8 hours of inactivity, the system it's raising an exception. Searching the log, I've found the cause, an SQL Exception with a "recv failed" error. Google said that MySQL shuts the idle connections after 8 hours, and also found a code to correctly handling that disconnection. The thing is that the Application Server is handling the connection pool to physically connect with the database, I'm not dealing with connection setup. I've tried setting autoReconnect and autoReconnectForPools properties (in the management console) without success.
Anyone has any idea to correct this?
Thanks in advance for your time.
Best regards
Antonio Varela.

You could execute a query from time to time, but you can't control which connection is being used. For example, you could be accessing the same connection all the time, and in the end only one functioning connection would remain in the pool.
As said in another thread,
The problem (in detail) is how the MySQL JDBC driver operates. The physical connection to the database can fail, but the Connection.isClosed() method will still return false.
So, there seems to be some problem with the MySQL driver.
But even in this case, the "connection validation" options should work on the application server, which they just don't. I am inclined to blame this problem on the connection pool implementation.
The only "solution" I found so far was to set larger connection timeouts on the MySQL server:
interactive_timeout = 2764800
wait_timeout = 2764800

Connection ==null and Connection is closed, difference

Hi experts,
I wonder what are the differences between "Connection==null" and "Connection is closed"?
I closed a connection on one JSP page after a bean has retrieved data. Then, on the same page I call another bean to connect to the database. Because the Connection object has been created earlier, therefore Connection is not NULL, but it is closed. So, the second bean has to initiate another connection(if I knew how to test the "closed" status)
Is it true that if the Connection is closed, then it should become null?
I think I must have make quite a few mistakes in above statement:). Please help. Thanks a lot.

connection.isClosed() will tell you if the connection object is closed or not. If it is closed, then the connection object can be dropped because you will not be able to create any new statements from that connection object. Just recreate another connection to use when this occurs.

Connection.isClosed implementation

Similar Messages

Maybe you are looking for