Database Connection Pool API.
Database Connection Pool API.
Overview in Dialog Form
Q: How do I use the DBCP package?
A: There are two primary ways to access the DBCP pool, as a
Driver
, or as a
DataSource
.
You'll want to create an instance of
PoolingDriver
or
PoolingDataSource
. When using one of these
interfaces, you can just use your JDBC objects the way you normally would.
Closing a
java.sql.Connection
will simply return it to its pool.
Q: But
PoolingDriver
and
PoolingDataSource
both expect an
ObjectPool
as an input. Where do I
get one of those?
A: The
ObjectPool
interface is defined
in the
org.apache.commons.pool
package (Commons-Pool).
The
org.apache.commons.pool.impl
package has a couple of implementations,
and you can always create your own.
Q: Ok, I've found an
ObjectPool
implementation that I think suits my connection pooling needs. But it wants
a
PoolableObjectFactory
.
What should I use for that?
A: The DBCP package provides a class for this purpose. It's called
PoolableConnectionFactory
.
It implements the factory and lifecycle methods of
org.apache.commons.pool.PoolableObjectFactory
for
java.sql.Connection
s. But it doesn't create the actual database
java.sql.Connection
s itself, if uses a
ConnectionFactory
for that.
The
PoolableConnectionFactory
will take
java.sql.Connection
s created by the
ConnectionFactory
and wrap them with classes that implement the pooling behaviour.
Several implementations of
ConnectionFactory
are
provided--one that uses
java.sql.DriverManager
to create connections
(
DriverManagerConnectionFactory
),
one that uses a
java.sql.Driver
to create connections
(
DriverConnectionFactory
),
one that uses a
javax.sql.DataSource
to create connections
(
DataSourceConnectionFactory
).
Q: I think I'm starting to get it, but can you walk me though it again?
A: Sure. Let's assume you want to create a
javax.sql.DataSource
that pools
java.sql.Connection
s. Let's also assume that that
those pooled
java.sql.Connection
s should be obtained from
the
java.sql.DriverManager
.
You'll want to create a
PoolingDataSource
.
The
PoolingDataSource
uses an underlying
org.apache.commons.pool.ObjectPool
to create and store its
java.sql.Connection
.
To create a
org.apache.commons.pool.ObjectPool
, you'll need
a
org.apache.commons.pool.PoolableObjectFactory
that creates
the actual
java.sql.Connection
s. That's what
PoolableConnectionFactory
is for.
To create the
PoolableConnectionFactory
,
you'll need at least two things:
-
A
ConnectionFactory
from which
the actual database java.sql.Connection
s will be obtained.
-
An empty and factory-less
org.apache.commons.pool.ObjectPool
in which the java.sql.Connection
s will be stored.
When you pass an org.apache.commons.pool.ObjectPool
into the
PoolableConnectionFactory
, it will
automatically register itself as the org.apache.commons.pool.PoolableObjectFactory
for that pool.
You can optionally provide a
org.apache.commons.pool.KeyedObjectPoolFactory
that will be used to create
org.apache.commons.pool.KeyedObjectPool
s for
pooling
java.sql.PreparedStatement
s for each
java.sql.Connection
.
In code, that might look like this:
GenericObjectPool connectionPool = new GenericObjectPool(null);
DriverManagerConnectionFactory connectionFactory = new DriverConnectionFactory("jdbc:some:connect:string",null);
PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,connectionPool,null,null,false,true);
PoolingDataSource dataSource = new PoolingDataSource(connectionPool);
To create a
PoolingDriver
, we do the same thing,
except that instead of creating a
javax.sql.DataSource
on the last line,
we create a
PoolingDriver
, and register the
connectionPool with it. E.g.,:
GenericObjectPool connectionPool = new GenericObjectPool(null);
DriverManagerConnectionFactory connectionFactory = new DriverConnectionFactory("jdbc:some:connect:string",null);
PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,connectionPool,null,null,false,true);
PoolingDriver driver = new PoolingDriver();
driver.registerPool("example",connectionPool);
Since the
PoolingDriver
registers itself
with the
java.sql.DriverManager
when it is created, now you can just
go to the
java.sql.DriverManager
to create your
java.sql.Connection
s,
like you normally would:
Connection conn = DriverManager.getConnection("jdbc:apache:commons:dbcp:example");
Q: Sounds complicated, is there an easier way?
A: If you're using the
PoolingDriver
, you
don't need to do this configuration in code. Instead, you can provide
a JOCL document that describes the connection pool,
and let the
PoolingDriver
discover it at
runtime.
Specifically, if the
PoolingDriver
is asked for
a
java.sql.Connection
from a pool that has not yet been registered,
it will look for a named resource from which to read the pool's configuration,
and create that pool.
For example, suppose you create a pool named "
/eg" from a JOCL
document. The "connect string" for this pool will be
"
jdbc:apache:commons:dbcp:/eg". To do this, you'll need a create
a
resource (just a file in your classpath) containing a JOCL description
of the pool. Specifically, this JOCL document should define a
PoolableConnectionFactory
from which the
pool will be obtained. For example:
<object class="org.apache.commons.dbcp.PoolableConnectionFactory" xmlns="http://apache.org/xml/xmlns/jakarta/commons/jocl">
<!-- the first argument is the ConnectionFactory -->
<object class="org.apache.commons.dbcp.DriverManagerConnectionFactory">
<string value="jdbc:some:connect:string"/>
<object class="java.util.Properties" null="true"/>
</object>
<!-- the next argument is the ObjectPool -->
<object class="org.apache.commons.pool.impl.GenericObjectPool">
<object class="org.apache.commons.pool.PoolableObjectFactory" null="true"/>
<int value="10"/> <!-- max active -->
<byte value="1"/> <!-- when exhausted action, 0 = fail, 1 = block, 2 = grow -->
<long value="2000"/> <!-- max wait -->
<int value="10"/> <!-- max idle -->
<boolean value="false"/> <!-- test on borrow -->
<boolean value="false"/> <!-- test on return -->
<long value="10000"/> <!-- time between eviction runs -->
<int value="5"/> <!-- number of connections to test per eviction run -->
<long value="5000"/> <!-- min evictable idle time -->
<boolean value="true"/> <!-- test while idle -->
</object>
<!-- the next argument is the KeyedObjectPoolFactory -->
<object class="org.apache.commons.pool.StackKeyedObjectPoolFactory">
<int value="5"/> <!-- max idle -->
</object>
<string value="SELECT COUNT(*) FROM DUAL"/> <;!-- validation query -->
<boolean value="false"/> <!-- default read only -->
<boolean value="true"/> <!-- default auto commit -->
</object>
Simply save that file somewhere in your classpath as
eg.jocl,
and the
PoolingDriver
will find it
automatically. You need only register the
PoolingDriver
(for example, using the
jdbc.drivers property), and use the
the
java.sql.DriverManager
to create your
java.sql.Connection
s,
like you normally would:
Connection conn = DriverManager.getConnection("jdbc:apache:commons:dbcp:/eg");
(Note that without the leading slash, the pool must be located at
org/apache/commons/dbcp/PoolingDriver/eg.jocl within your classpath.
See
java.lang.Class.getResource
for details.)