Basic implementation of javax.sql.DataSource that is
* configured via JavaBeans properties. This is not the only way to
* combine the commons-dbcp and commons-pool packages,
* but provides a "one stop shopping" solution for basic requirements.
createDataSource() method.
*/
protected DataSource dataSource = null;
/**
* The PrintWriter to which log messages should be directed.
*/
protected PrintWriter logWriter = new PrintWriter(System.out);
// ----------------------------------------------------- DataSource Methods
/**
* Create (if necessary) and return a connection to the database.
*
* @exception SQLException if a database access error occurs
*/
public Connection getConnection() throws SQLException {
return (createDataSource().getConnection());
}
/**
* Create (if necessary) and return a connection to the database.
*
* @param username Database user on whose behalf the Connection
* is being made
* @param password The database user's password
*
* @exception SQLException if a database access error occurs
*/
public Connection getConnection(String username, String password)
throws SQLException {
return (createDataSource().getConnection(username, password));
}
/**
* Return the login timeout (in seconds) for connecting to the database.
*
* @exception SQLException if a database access error occurs
*/
public int getLoginTimeout() throws SQLException {
return (createDataSource().getLoginTimeout());
}
/**
* Return the log writer being used by this data source.
*
* @exception SQLException if a database access error occurs
*/
public PrintWriter getLogWriter() throws SQLException {
return (createDataSource().getLogWriter());
}
/**
* Set the login timeout (in seconds) for connecting to the database.
*
* @param loginTimeout The new login timeout, or zero for no timeout
*
* @exception SQLException if a database access error occurs
*/
public void setLoginTimeout(int loginTimeout) throws SQLException {
createDataSource().setLoginTimeout(loginTimeout);
}
/**
* Set the log writer being used by this data source.
*
* @param logWriter The new log writer
*
* @exception SQLException if a database access error occurs
*/
public void setLogWriter(PrintWriter logWriter) throws SQLException {
createDataSource().setLogWriter(logWriter);
this.logWriter = logWriter;
}
private AbandonedConfig abandonedConfig;
/**
* Flag to remove abandoned connections if they exceed the
* removeAbandonedTimout.
*
* Set to true or false, default false.
* If set to true a connection is considered abandoned and eligible
* for removal if it has been idle longer than the removeAbandonedTimeout.
* Setting this to true can recover db connections from poorly written
* applications which fail to close a connection.
*/
public boolean getRemoveAbandoned() {
if (abandonedConfig != null) {
return abandonedConfig.getRemoveAbandoned();
}
return false;
}
public void setRemoveAbandoned(boolean removeAbandoned) {
if (abandonedConfig == null) {
abandonedConfig = new AbandonedConfig();
}
abandonedConfig.setRemoveAbandoned(removeAbandoned);
}
/**
* Timeout in seconds before an abandoned connection can be removed.
*
* Defaults to 300 seconds.
*/
public int getRemoveAbandonedTimeout() {
if (abandonedConfig != null) {
return abandonedConfig.getRemoveAbandonedTimeout();
}
return 300;
}
public void setRemoveAbandonedTimeout(int removeAbandonedTimeout) {
if (abandonedConfig == null) {
abandonedConfig = new AbandonedConfig();
}
abandonedConfig.setRemoveAbandonedTimeout(removeAbandonedTimeout);
}
/**
* Flag to log stack traces for application code which abandoned
* a Statement or Connection.
*
* Defaults to false.
*
* Logging of abandoned Statements and Connections adds overhead
* for every Connection open or new Statement because a stack
* trace has to be generated.
*/
public boolean getLogAbandoned() {
if (abandonedConfig != null) {
return abandonedConfig.getLogAbandoned();
}
return false;
}
public void setLogAbandoned(boolean logAbandoned) {
if (abandonedConfig == null) {
abandonedConfig = new AbandonedConfig();
}
abandonedConfig.setLogAbandoned(logAbandoned);
}
// --------------------------------------------------------- Public Methods
/**
* Add a custom connection property to the set that will be passed to our
* JDBC driver. This MUST be called before the first
* connection is retrieved (along with all the other configuration
* property setters).
*
* @param name Name of the custom connection property
* @param value Value of the custom connection property
*/
public void addConnectionProperty(String name, String value) {
connectionProperties.put(name, value);
}
/**
* Close and release all connections that are currently stored in the
* connection pool associated with our data source.
*
* @exception SQLException if a database error occurs
*/
public void close() throws SQLException {
GenericObjectPool oldpool = connectionPool;
connectionPool = null;
dataSource = null;
try {
oldpool.close();
} catch(SQLException e) {
throw e;
} catch(RuntimeException e) {
throw e;
} catch(Exception e) {
throw new SQLException(e.toString());
}
}
// ------------------------------------------------------ Protected Methods
/**
* Create (if necessary) and return the internal data source we are * using to manage our connections.
* *IMPLEMENTATION NOTE - It is tempting to use the * "double checked locking" idiom in an attempt to avoid synchronizing * on every single call to this method. However, this idiom fails to * work correctly in the face of some optimizations that are legal for * a JVM to perform.
* * @exception SQLException if the object pool cannot be created. */ protected synchronized DataSource createDataSource() throws SQLException { // Return the pool if we have already created it if (dataSource != null) { return (dataSource); } // Load the JDBC driver class Class driverClass = null; try { driverClass = Class.forName(driverClassName); } catch (Throwable t) { String message = "Cannot load JDBC driver class '" + driverClassName + "'"; logWriter.println(message); t.printStackTrace(logWriter); throw new SQLException(message); } // Create a JDBC driver instance Driver driver = null; try { driver = DriverManager.getDriver(url); } catch (Throwable t) { String message = "Cannot create JDBC driver of class '" + driverClassName + "' for connect URL '" + url + "'"; logWriter.println(message); t.printStackTrace(logWriter); throw new SQLException(message); } // Create an object pool to contain our active connections connectionPool = new AbandonedObjectPool(null,abandonedConfig); connectionPool.setMaxActive(maxActive); connectionPool.setMaxIdle(maxIdle); connectionPool.setMaxWait(maxWait); if (validationQuery != null) { connectionPool.setTestOnBorrow(true); } // Set up the driver connection factory we will use if (username != null) { connectionProperties.put("user", username); } else { System.out.println( "DBCP DataSource configured without a 'username'"); } if (password != null) { connectionProperties.put("password", password); } else { System.out.println( "DBCP DataSource configured without a 'password'"); } DriverConnectionFactory driverConnectionFactory = new DriverConnectionFactory(driver, url, connectionProperties); // Set up the poolable connection factory we will use PoolableConnectionFactory connectionFactory = null; try { connectionFactory = new PoolableConnectionFactory(driverConnectionFactory, connectionPool, null, // FIXME - stmtPoolFactory? validationQuery, defaultReadOnly, defaultAutoCommit, abandonedConfig); } catch(RuntimeException e) { throw e; } catch(Exception e) { throw new SQLException(e.toString()); } // Create and return the pooling data source to manage the connections dataSource = new PoolingDataSource(connectionPool); dataSource.setLogWriter(logWriter); return (dataSource); } }