commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Henning Schmiedehausen <>
Subject Re: [DBCP] Managed Connection support
Date Wed, 04 Jul 2007 22:44:09 GMT
Hi Dain,

thanks a lot for this input. Can you please resend your message to the
commons-dev list located at ?

To add some a little bit confusion: The commons have just decided to
become a top-level project in their own right, so the development list
will move to at some point in the near future.

Still, it would be great to follow up on your suggestions;
TransactionSupport would be a real benefit to DBCP. 

	Best regards

On Tue, 2007-07-03 at 18:21 -0700, Dain Sundstrom wrote:
> I just posted a patch JIRA which adds support for container managed  
> connections to DBCP.  In an environment where you have an accessible  
> transaction manger such as Tomcat (when installed), Geronimo or  
> OpenEJB, this patch allows adds support for pooling managed  
> connections to an XA or non-XA data base.
> There are many libraries that use DBCP for non-managed environments,  
> but when additional resources such as a JMS provider are added to the  
> mix, they have to replace DBCP with something else.  If you search  
> google for XA and DBCP, you will loads of painful direction on how to  
> replace DBCP with something else.  I personally want to use DBCP in  
> Tomcat with ActiveMQ.
> Anyways, enough with motivation....
> To use the new code, you need access to a TranactionManager (this  
> code just creates a new Geronimo one).
>          transactionManager = new TransactionManagerImpl();
> Then you either create an XADataSource and  
> DataSourceXAConectionFactory or as this code does, create a normal  
> DBCP ConnectionFactory and wrap it with a LocalXAConectionFactory
>          Properties properties = new Properties();
>          properties.setProperty("user", "username");
>          properties.setProperty("password", "password");
>          ConnectionFactory connectionFactory = new  
> DriverConnectionFactory(
>                  new TesterDriver(),
>                  "jdbc:apache:commons:testdriver", properties);
>          // wrap it with a LocalXAConnectionFactory
>          XAConnectionFactory xaConnectionFactory = new  
> LocalXAConnectionFactory(
>                  transactionManager,
>                  connectionFactory);
> Now you create a pool as normal (full reuse here).
>          pool = new GenericObjectPool();
>          pool.setMaxActive(getMaxActive());
>          pool.setMaxWait(getMaxWait());
>          // create the pool object factory
>          PoolableConnectionFactory factory = new  
> PoolableConnectionFactory(
>                  xaConnectionFactory,
>                  pool,
>                  null,
>                  "SELECT DUMMY FROM DUAL",
>                  true,
>                  true);
>          pool.setFactory(factory);
> Finally, you create a special ManagedDataSource using the pool above  
> and the special TransactionRegistry object obtained from the  
> XAConnectionFactory.
>          ds = new ManagedDataSource(pool,  
> xaConnectionFactory.getTransactionRegistry());
>          ds.setAccessToUnderlyingConnectionAllowed(true);
> That's it.  The data source and connections work as normal until you  
> start a transaction using the TransactionManager.  When you use a  
> connection while the transaction is active, the connection is  
> enlisted in the transaction.  When the transaction is complete, the  
> connection is committed (or rolledback) and the connection returns to  
> normal.
> Most of the new code extends existing classes or uses existing  
> classes without modification.  The key to this reuse is the  
> TransactionRegistry abstraction which maintains a map from the  
> Connection to the XAResource for that connection.  The XAResource is  
> needed to enlist a connection in a transaction.  The  
> TransactionRegistry and associated TransationContext class  
> encapsulate all interactions with the TransactionManager leaving the  
> Connection implementation relatively simple (making reuse easier).
> For now the code is contained in the org.apache.commons.dbcp.managed  
> package, but I would suspect we may want to spread it out amongst the  
> existing packages instead of creating a feature specific package.   
> I'm also not sure what additional interfaces people may want such as  
> equivalents of the BasicDataSource or BasicDataSourceFactory.
> The code has tests and has javadoc, but it needs real world testing  
> and some real docs.  I'm going try hooking it into OpenEJB and  
> running it's massive test suite with a couple of opensource DBs.
> Anyways, I hope you all like it and accept the patch.  I'm around to  
> help with changes or whatever.  I also ran into a few bugs while  
> working on this that are already reported in JIRA (like the close  
> bugs) and am willing to help with those also.
> -dain
> ---------------------------------------------------------------------
> To unsubscribe, e-mail:
> For additional commands, e-mail:

To unsubscribe, e-mail:
For additional commands, e-mail:

View raw message