Connection classes

Question

hi
i wrote a conenction class some time ago that used oracle's connection cache. this worked great, creating and releasing resources as required be it for jsp or a swing application.
i am now trying to write a more generic connection pool class that is not tied to an oracle database and after many many long nights i'm stumped!!
i have written 3 classes to accomplish this. one implements DataSource, the other is ConnectionPool class itself and the third is DBConnection, a kind of go-between which i also used (obviously modified) with the oracle connection stuff.
so i create the pool for x number of connections and all works fine (pool class is ok as far as i can tell), with calls to retrieve connections made via the DBConnection class. when i used the oracle stuff, my DBConnection class would remain 'static' (though not declared as such) througout the life of my application without explicitly passing the DBConnection object along all my classes. so any call to new DBConnection() from another class would use the existing pool of conns and i would reuse from there.
implementing my own pool now has every call to new DBConnection() actually creating a fresh pool of connections as the boolean value that is set when the pool is created is obviously false for a new instance of that class.
my question is therefore, how do i contruct my DBConnection class such that new calls to it, do not create a new instance entirely and hence a new pool?? i don't know how oracle does it with their cache classes but it works incredibly well without passing the object around all the classes. or even how could i construct my DBConnection class such that it remains as one instance throughout the life of the application - again without passing the object reference around??
any help on this would be most appreciated. thanks
John.

Answer 1

The way I have done it is this:
ConnectionBroker: a singleton class that serves as a repository for java.sql.Connection objects. Clients get access to the single instance of ConnectionBroker through the static getInstance() method. They then call the getConnection( String dbName ) method, passing in the name of the database they wish to connect to (each db that the broker knows about is given a name). The connection is flagged as "busy" by the broker until it is returned by the client. Clients are required to return the connection to the broker when finished by using the returnConnection() method. This is typically done in a finally block to ensure that connections are always returned to the broker.
DBConnection: a wrapper around the Connection class that adds a boolean "busy" flag. Its constructor takes a DBProperties object as an argument, and it handles the creation of its java.sql.Connection object.
DBProperties: encapsulates the information needed to connect to a database - driverName, url, uid, password, and name. Name is a string used by the ConnectionBroker and its clients to identify a database.
properties files: There is one master properties file, which contains one entry for each database the ConnectionBroker will provide connections for. The key of each entry is the database name, and the value is the name of another file that contains driver, url, etc. information for that db. These files are read using Class.getResourceAsStream(), so they can always be read provided that they reside somewhere in the system classpath.
The ConnectionBroker is not dedicated to a single database; it can be used to pool connections to an arbitrary number of databases. Connections are created in response to user requests only when there are no non-busy connections available to the requested database.
usage example for a database named webdb:
masterdb.properties:
webdb=webdb.properties:
webdb.properties file:
driver=sun.jdbc.odbc.JdbcOdbcDriver
url=jdbc:odbc:webdb
uid=
password=
client code:
DBConnection dbConn = null;
Connection conn = null;
try {
    dbConn = ConnectionBroker.getInstance().getConnection( "webdb" );
    conn = dbConn.getConnection();
    // sql stuff here
} catch ( SQLException ) {
    // error handling here
} finally {
    if ( dbConn != null ) ConnectionBroker.getInstance().returnConnection( dbConn );