The Tomcat JDBC Connection Pool

The JDBC Connection Pool org.apache.tomcat.jdbc.pool
is a replacement or an alternative to the commons-dbcp
connection pool.

So why do we need a new connection pool?

Here are a few of the reasons:

commons-dbcp is single threaded, in order to be thread safe commons-dbcp locks the entire pool, even during query validation.

commons-dbcp is slow - as the number of logical CPUs grow, the performance suffers, the above point shows that there is not support for high concurrency
Even with the enormous optimizations of the synchronized statement in Java 6, commons-dbcp still suffers in speed and concurrency.

commons-dbcp is complex, over 60 classes. tomcat-jdbc-pool, core is 8 classes, hence modifications for future requirement will require
much less changes. This is all you need to run the connection pool itself, the rest is gravy.

commons-dbcp uses static interfaces. This means you can't compile it with JDK 1.6, or if you run on JDK 1.6/1.7 you will get
NoSuchMethodException for all the methods not implemented, even if the driver supports it.

The commons-dbcp has become fairly stagnant. Sparse updates, releases, and new feature support.

It's not worth rewriting over 60 classes, when something as a connection pool can be accomplished with as a much simpler implementation.

Tomcat jdbc pool implements a fairness option not available in commons-dbcp and still performs faster than commons-dbcp

Tomcat jdbc pool is a Tomcat module, it depends on Tomcat JULI, a simplified logging framework used in Tomcat.

Retrieve the underlying connection using the javax.sql.PooledConnection interface.

Starvation proof. If a pool is empty, and threads are waiting for a connection, when a connection is returned,
the pool will awake the correct thread waiting. Most pools will simply starve.

Features added over other connection pool implementations

Support for highly concurrent environments and multi core/cpu systems.

Dynamic implementation of interface, will support java.sql and javax.sql interfaces for
your runtime environment (as long as your JDBC driver does the same), even when compiled with a lower version of the JDK.

Validation intervals - we don't have to validate every single time we use the connection, we can do this
when we borrow or return the connection, just not more frequent than an interval we can configure.

Run-Once query, a configurable query that will be run only once, when the connection to the database is established.
Very useful to setup session settings, that you want to exist during the entire time the connection is established.

Ability to configure custom interceptors.
This allows you to write custom interceptors to enhance the functionality. You can use interceptors to gather query stats,
cache session states, reconnect the connection upon failures, retry queries, cache query results, and so on.
Your options are endless and the interceptors are dynamic, not tied to a JDK version of a
java.sql/javax.sql interface.

High performance - we will show some differences in performance later on

Extremely simple, due to the very simplified implementation, the line count and source file count are very low, compare with c3p0
that has over 200 source files(last time we checked), Tomcat jdbc has a core of 8 files, the connection pool itself is about half
that. As bugs may occur, they will be faster to track down, and easier to fix. Complexity reduction has been a focus from inception.

Asynchronous connection retrieval - you can queue your request for a connection and receive a Future<Connection> back.

Better idle connection handling. Instead of closing connections directly, it can still pool connections and sizes the idle pool with a smarter algorithm.

You can decide at what moment connections are considered abandoned, is it when the pool is full, or directly at a timeout
by specifying a pool usage threshold.

The abandon connection timer will reset upon a statement/query activity. Allowing a connections that is in use for a long time to not timeout.
This is achieved using the ResetAbandonedTimer

Close connections after they have been connected for a certain time. Age based close upon return to the pool.

Get JMX notifications and log entries when connections are suspected for being abandoned. This is similar to
the removeAbandonedTimeout but it doesn't take any action, only reports the information.
This is achieved using the suspectTimeout attribute.

Connections can be retrieved from a java.sql.Driver, javax.sql.DataSource or javax.sql.XADataSource
This is achieved using the dataSource and dataSourceJNDI attributes.

Usage of the Tomcat connection pool has been made to be as simple as possible, for those of you that are familiar with commons-dbcp, the
transition will be very simple. Moving from other connection pools is also fairly straight forward.

The Tomcat Connection pool is configured as a resource described in The Tomcat JDBC documentation
With the only difference being that you have to specify the factory attribute and set the value to
org.apache.tomcat.jdbc.pool.DataSourceFactory

The connection pool only has another dependency, and that is on tomcat-juli.jar.
To configure the pool in a stand alone project using bean instantiation, the bean to instantiate is
org.apache.tomcat.jdbc.pool.DataSource. The same attributes (documented below) as you use to configure a connection
pool as a JNDI resource, are used to configure a data source as a bean.

The connection pool object exposes an MBean that can be registered.
In order for the connection pool object to create the MBean, the flag jmxEnabled has to be set to true.
This doesn't imply that the pool will be registered with an MBean server, merely that the MBean is created.
In a container like Tomcat, Tomcat itself registers the DataSource with the MBean server, the
org.apache.tomcat.jdbc.pool.DataSource object will then register the actual
connection pool MBean.
If you're running outside of a container, you can register the DataSource yourself under any object name you specify,
and it propagates the registration to the underlying pool. To do this you would call mBeanServer.registerMBean(dataSource.getPool().getJmxPool(),objectname).
Prior to this call, ensure that the pool has been created by calling dataSource.createPool().

These attributes are shared between commons-dbcp and tomcat-jdbc-pool, in some cases default values are different.

Attribute

Description

defaultAutoCommit

(boolean) The default auto-commit state of connections created by this pool. If not set, default is JDBC driver default (If not set then the setAutoCommit method will not be called.)

defaultReadOnly

(boolean) The default read-only state of connections created by this pool. If not set then the setReadOnly method will not be called. (Some drivers don't support read only mode, ex: Informix)

defaultTransactionIsolation

(String) The default TransactionIsolation state of connections created by this pool. One of the following: (see javadoc )

NONE

READ_COMMITTED

READ_UNCOMMITTED

REPEATABLE_READ

SERIALIZABLE

If not set, the method will not be called and it defaults to the JDBC driver.

defaultCatalog

(String) The default catalog of connections created by this pool.

driverClassName

(String) The fully qualified Java class name of the JDBC driver to be used. The driver has to be accessible
from the same classloader as tomcat-jdbc.jar

username

(String) The connection username to be passed to our JDBC driver to establish a connection.
Note, at this point, DataSource.getConnection(username,password) is not using the credentials passed into the method.

password

(String) The connection password to be passed to our JDBC driver to establish a connection.
Note, at this point, DataSource.getConnection(username,password) is not using the credentials passed into the method.

maxActive

(int) The maximum number of active connections that can be allocated from this pool at the same time.
The default value is 100

maxIdle

(int) The maximum number of connections that should be kept in the pool at all times.
Default value is maxActive:100
Idle connections are checked periodically (if enabled) and
connections that been idle for longer than minEvictableIdleTimeMillis
will be released. (also see testWhileIdle)

minIdle

(int) The minimum number of established connections that should be kept in the pool at all times.
The connection pool can shrink below this number if validation queries fail.
Default value is derived from initialSize:10 (also see testWhileIdle)

initialSize

(int)The initial number of connections that are created when the pool is started.
Default value is 10

maxWait

(int) The maximum number of milliseconds that the pool will wait (when there are no available connections)
for a connection to be returned before throwing an exception.
Default value is 30000 (30 seconds)

testOnBorrow

(boolean) The indication of whether objects will be validated before being borrowed from the pool.
If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another.
NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string.
In order to have a more efficient validation, see validationInterval.
Default value is false

testOnReturn

(boolean) The indication of whether objects will be validated before being returned to the pool.
NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string.
The default value is false.

testWhileIdle

(boolean) The indication of whether objects will be validated by the idle object evictor (if any).
If an object fails to validate, it will be dropped from the pool.
NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string.
The default value is false and this property has to be set in order for the
pool cleaner/test thread is to run (also see timeBetweenEvictionRunsMillis)

validationQuery

(String) The SQL query that will be used to validate connections from this pool before returning them to the caller.
If specified, this query does not have to return any data, it just can't throw a SQLException.
The default value is null.
Example values are SELECT 1(mysql), select 1 from dual(oracle), SELECT 1(MS Sql Server)

validatorClassName

(String) The name of a class which implements the
org.apache.tomcat.jdbc.pool.Validator interface and
provides a no-arg constructor (may be implicit). If specified, the
class will be used to create a Validator instance which is then used
instead of any validation query to validate connections. The default
value is null. An example value is
com.mycompany.project.SimpleValidator.

timeBetweenEvictionRunsMillis

(int) The number of milliseconds to sleep between runs of the idle connection validation/cleaner thread.
This value should not be set under 1 second. It dictates how often we check for idle, abandoned connections, and how often
we validate idle connections.
The default value is 5000 (5 seconds).

numTestsPerEvictionRun

(int) Property not used in tomcat-jdbc-pool.

minEvictableIdleTimeMillis

(int) The minimum amount of time an object may sit idle in the pool before it is eligible for eviction.
The default value is 60000 (60 seconds).

accessToUnderlyingConnectionAllowed

(boolean) Property not used. Access can be achieved by calling unwrap on the pooled connection.
see javax.sql.DataSource interface, or call getConnection through reflection or
or cast the object as javax.sql.PooledConnection

removeAbandoned

(boolean) Flag to remove abandoned connections if they exceed the removeAbandonedTimout.
If set to true a connection is considered abandoned and eligible for removal if it has been in use
longer than the removeAbandonedTimeout Setting this to true can recover db connections from
applications that fail to close a connection. See also logAbandoned
The default value is false.

removeAbandonedTimeout

(int) Timeout in seconds before an abandoned(in use) connection can be removed.
The default value is 60 (60 seconds). The value should be set to the longest running query your applications
might have.

logAbandoned

(boolean) Flag to log stack traces for application code which abandoned a Connection.
Logging of abandoned Connections adds overhead for every Connection borrow because a stack trace has to be generated.
The default value is false.

connectionProperties

(String) The connection properties that will be sent to our JDBC driver when establishing new connections.
Format of the string must be [propertyName=property;]*
NOTE - The "user" and "password" properties will be passed explicitly, so they do not need to be included here.
The default value is null.

(String) A custom query to be run when a connection is first created.
The default value is null.

jdbcInterceptors

(String) A semicolon separated list of classnames extending org.apache.tomcat.jdbc.pool.JdbcInterceptor class.
These interceptors will be inserted as an interceptor into the chain of operations on a java.sql.Connection object.
The default value is null.
Predefined interceptors:org.apache.tomcat.jdbc.pool.interceptor.ConnectionState - keeps track of auto commit, read only, catalog and transaction isolation level.org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer - keeps track of opened statements, and closes them when the connection is returned to the pool.
More predefined interceptors are described in detail in the JDBC Interceptors section.

validationInterval

(long) avoid excess validation, only run validation at most at this frequency - time in milliseconds.
If a connection is due for validation, but has been validated previously within this interval, it will not be validated again.
The default value is 30000 (30 seconds).

jmxEnabled

(boolean) Register the pool with JMX or not.
The default value is true.

fairQueue

(boolean) Set to true if you wish that calls to getConnection should be treated
fairly in a true FIFO fashion. This uses the org.apache.tomcat.jdbc.pool.FairBlockingQueue
implementation for the list of the idle connections. The default value is true.
This flag is required when you want to use asynchronous connection retrieval.
Setting this flag ensures that threads receive connections in the order they arrive.
During performance tests, there is a very large difference in how locks
and lock waiting is implemented. When fairQueue=true
there is a decision making process based on what operating system the system is running.
If the system is running on Linux (property os.name=Linux.
To disable this Linux specific behavior and still use the fair queue, simply add the property
org.apache.tomcat.jdbc.pool.FairBlockingQueue.ignoreOS=true to your system properties
before the connection pool classes are loaded.

abandonWhenPercentageFull

(int) Connections that have been abandoned (timed out) wont get closed and reported up unless
the number of connections in use are above the percentage defined by abandonWhenPercentageFull.
The value should be between 0-100.
The default value is 0, which implies that connections are eligible for closure as soon
as removeAbandonedTimeout has been reached.

maxAge

(long) Time in milliseconds to keep this connection. When a connection is returned to the pool,
the pool will check to see if the now - time-when-connected > maxAge has been reached,
and if so, it closes the connection rather than returning it to the pool.
The default value is 0, which implies that connections will be left open and no age check
will be done upon returning the connection to the pool.

useEquals

(boolean) Set to true if you wish the ProxyConnection class to use String.equals and set to false
when you wish to use == when comparing method names. This property does not apply to added interceptors as those are configured individually.
The default value is true.

suspectTimeout

(int) Timeout value in seconds. Default value is 0.
Similar to to the removeAbandonedTimeout value but instead of treating the connection
as abandoned, and potentially closing the connection, this simply logs the warning if
logAbandoned is set to true. If this value is equal or less than 0, no suspect
checking will be performed. Suspect checking only takes place if the timeout value is larger than 0 and
the connection was not abandoned or if abandon check is disabled. If a connection is suspect a WARN message gets
logged and a JMX notification gets sent once.

rollbackOnReturn

(boolean) If autoCommit==false then the pool can terminate the transaction by calling rollback on the connection as it is returned to the pool
Default value is false.

commitOnReturn

(boolean) If autoCommit==false then the pool can complete the transaction by calling commit on the connection as it is returned to the pool
If rollbackOnReturn==true then this attribute is ignored.
Default value is false.

alternateUsernameAllowed

(boolean) By default, the jdbc-pool will ignore the
DataSource.getConnection(username,password)
call, and simply return a previously pooled connection under the globally configured properties username and password, for performance reasons.
The pool can however be used with different credentials each time a connection is used. Should you request a connection with the credentials user1/password1 and the connection
was previously connected using user2/password2, the connection will be closed, and reopened with the requested credentials. This way, the pool size is still managed
on a global level, and not on a per schema level. To enable the functionality described in the
DataSource.getConnection(username,password)
call, simply set the property alternateUsernameAllowed to true.
The default value is false.
This property was added as an enhancement to bug 50025.

dataSource

(javax.sql.DataSource) Inject a data source to the connection pool, and the pool will use the data source to retrieve connections instead of establishing them using the java.sql.Driver interface.
This is useful when you wish to pool XA connections or connections established using a data source instead of a connection string. Default value is null

dataSourceJNDI

(String) The JNDI name for a data source to be looked up in JNDI and then used to establish connections to the database. See the dataSource attribute. Default value is null

useDisposableConnectionFacade

(boolean) Set this to true if you wish to put a facade on your connection so that it cannot be reused after it has been closed. This prevents a thread holding on to a
reference of a connection it has already called closed on, to execute queries on it. Default value is true.

logValidationErrors

(boolean) Set this to true to log errors during the validation phase to the log file. If set to true, errors will be logged as SEVERE. Default value is false for backwards compatibility.

propagateInterruptState

(boolean) Set this to true to propagate the interrupt state for a thread that has been interrupted (not clearing the interrupt state). Default value is false for backwards compatibility.

To see an example of how to use an interceptor, take a look at
org.apache.tomcat.jdbc.pool.interceptor.ConnectionState.
This simple interceptor is a cache of three attributes, transaction isolation level, auto commit and read only state,
in order for the system to avoid not needed roundtrips to the database.

Further interceptors will be added to the core of the pool as the need arises. Contributions are always welcome!

Interceptors are of course not limited to just java.sql.Connection but can be used to wrap any
of the results from a method invokation as well. You could build query performance analyzer that provides JMX notifications when a
query is running longer than the expected time.

Configuring JDBC interceptors is done using the jdbcInterceptors property.
The property contains a list of semi colon separated class names. If the classname is not fully qualified it will be prefixed with the
org.apache.tomcat.jdbc.pool.interceptor. prefix.
Example:
jdbcInterceptors="org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer"
is the same as
jdbcInterceptors="ConnectionState;StatementFinalizer"
Interceptors can have properties as well. These would be configured within the paranthesis of the class names.
Example:
jdbcInterceptors="ConnectionState;StatementFinalizer(useEquals=true)"

Caches the connection for the following attributes autoCommit, readOnly,
transactionIsolation and catalog.
It is a performance enhancement to avoid roundtrip to the database when getters are called or setters are called with an already set value.

Extends the SlowQueryReport and in addition to log entries it issues JMX notification
for monitoring tools to react to. Inherits all the attributes from its parent class.
This class uses Tomcat's JMX engine so it wont work outside of the Tomcat container.
By default, JMX notifications are sent through the ConnectionPool mbean if it is enabled.
The SlowQueryReportJmx can also register an MBean if notifyPool=false

Attribute

Description

notifyPool

(boolean as String) Set to false if you want JMX notifications to go to the SlowQueryReportJmx MBean
The default value is true.

The abandoned timer starts when a connection is checked out from the pool.
This means if you have a 30second timeout and run 10x10second queries using the connection
it will be marked abandoned and potentially reclaimed depending on the abandonWhenPercentageFull
attribute.
Using this interceptor it will reset the checkout timer every time you perform an operation on the connection or execute a
query successfully.

The Tomcat JDBC connection pool supports asynchronous connection retrieval without adding additional threads to the
pool library. It does this by adding a method to the data source called Future<Connection> getConnectionAsync().
In order to use the async retrieval, two conditions must be met:

You must configure the fairQueue property to be true.

You will have to cast the data source to org.apache.tomcat.jdbc.pool.DataSource

Interceptors are a powerful way to enable, disable or modify functionality on a specific connection or its sub components.
There are many different use cases for when interceptors are useful. By default, and for performance reasons, the connection pool is stateless.
The only state the pool itself inserts are defaultAutoCommit, defaultReadOnly, defaultTransactionIsolation, defaultCatalog if
these are set. These 4 properties are only set upon connection creation. Should these properties be modified during the usage of the connection,
the pool itself will not reset them.

An interceptor has to extend the org.apache.tomcat.jdbc.pool.JdbcInterceptor class. This class is fairly simple,
You will need to have a no arg constructor

public JdbcInterceptor() {
}

When a connection is borrowed from the pool, the interceptor can initialize or in some other way react to the event by implementing the

method to get invoked. The Method method is the actual method invoked, and Object[] args are the arguments.
To look at a very simple example, where we demonstrate how to make the invokation to java.sql.Connection.close() a noop
if the connection has been closed

There is an observation being made. It is the comparison of the method name. One way to do this would be to do
"close".equals(method.getName()).
Above we see a direct reference comparison between the method name and static final String reference.
According to the JVM spec, method names and static final String end up in a shared constant pool, so the reference comparison should work.
One could of course do this as well:

The compare(String,Method) will use the useEquals flag on an interceptor and do either reference comparison or
a string value comparison when the useEquals=true flag is set.

Pool start/stop
When the connection pool is started or closed, you can be notifed. You will only be notified once per interceptor class
even though it is an instance method. and you will be notified using an interceptor currently not attached to a pool.

Interceptor properties
Since interceptors can have properties, you need to be able to read the values of these properties within your
interceptor. Taking an example like the one above, you can override the setProperties method.

Connection pools create wrappers around the actual connection in order to properly pool them.
We also create interceptors in these wrappers to be able to perform certain functions.
If there is a need to retrieve the actual connection, one can do so using the javax.sql.PooledConnection
interface.