I need to use Atomikos transaction Manager with Tomcat 8.0.36 to support JTA. Every documentation for Atomikos, recommend using com.atomikos.jdbc.AtomikosDataSourceBean as the type and com.atomikos.tomcat.EnhancedTomcatAtomikosBeanFactory as the object factory for the datasource resource (specified as resource in tomcat's context.xml)
However, if we use com.atomikos.jdbc.AtomikosDataSourceBean, Atomikos will use its own JDBC connection Pool instead of Tomcat's connection Pool.
Tomcat's connection pool provides more configurable settings than atomikos.
Is it possible to use Datasource resource, with type as javax.sql.XADatasource and factory as org.apace.tomcat.jdbc.pool.DatasourceFactory (which will use Tomcat's XA connection Pool) with Atomikos?
I tried to use atomikos with tomcat JDBC pool i.e. I didn't use AtomikosDatasourceBean (which is the only recommended way in Atomikos documentation). So far I have tested this with 3-4 applications and it seems to work fine.
Atomikos documentation doesn't provide much detail about it, however, there is one sentence on its website which says that we can use other JDBC pool with tomcat.
Related
is it possible to intercept the connection pooling mechanism of a DataSource in a JEE container?
For (un)setting some information on the connection's context I'm searching for a way to intercept the pooling mechanism so that I know when and which connection is put back into the pool.
So does anyone know a (common) way to do this?
Some additional info:
The application runs on Wildfly
Using Hibernate for ORM
The option connection-listener in datasource configuration can be the solution.
connection-listener:
An org.jboss.jca.adapters.jdbc.spi.listener.ConnectionListener that
provides a possible to listen for connection activation and
passivation in order to perform actions before the connection is
returned to the application or returned to the pool
You can create a custom implementation of org.jboss.jca.adapters.jdbc.spi.listener.ConnectionListener and deploy it as a module to do that you want.
I'm reading Java Persistence with Hibernate, and I found the following text.
Today, high-quality standalone JTA providers such as Bitronix (used for the example code of this book) and Atomikos are available and easy to install in any Java environment. Think of these solutions as JTA-enabled database connection pools.
As I understand, JTA providers have their own connection pools.
So, do they integrate (how, if they do) with connection pools like HikariCP and C3P0? Thank you.
The answer is NO, you cannot combine JTA provider with these JDBC Connection Pools.
The short reason is:
The JTA provider need XADataSource and the JDBC Connection Pools named by you just have standard DataSource.
The longer reason is:
With a JTA provider you want to handle global transactions - global means over different DataSources. (e.g. your operation wants to do something in database/DataSource 1 and something in database/DataSource 2 - if one of these parts fail, you want both parts to get rolled back as if nothing has happened to both databases/DataSources) This is done by Two-Phase-Commit and this needs a XADataSource.
Your JDBC connection pools are lightweight for applications using only one DataSource - for this applications you do not need JTA (even if you can use them either, of course).
Part of my project is to enhance the thread-safety part of my application. I want to be able to store and retrieve data from a mysql database through JDBC Connector/J and I know that I need to use connection pooling for this but my application is not a servlet ... Should I still install Tomcat and change the config.xml file for the connection pooling datasource, connection numbers etc...?
You don't need a servlet or webapp to use db connection pooling. I'm sure there are a plenty of pools to use, my default is apache dbcp http://commons.apache.org/dbcp/
To use dbcp you need to have the commons-dbcp-1.4.jar (for version 1.4) and the commons-pool (http://commons.apache.org/pool/) in your classpath.
A simple way to use pooling, is to use the org.apache.commons.dbcp.BasicDataSource
BasicDataSource ds = new BasicDataSource();
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUsername(username);
ds.setPassword(password);
ds.setUrl(jdbcUrl);
ds.setInitialSize(4);
Then, you can get connections out of the pool by calling ds.getConnection() .
Furthermore, you need to configure the maximum count of active connections, have a look at the BasicDataSource API.
You can use c3p0 instead.
You can find the entire documentation here :
c3p0 - JDBC3 Connection
When creating JNDI JDBC connection pools in an application server, I always specified the type as javax.sql.ConnectionPoolDataSource. I never really gave it too much thought as it always seemed natural to prefer pooled connections over non-pooled.
However, in looking at some examples (specifically for Tomcat) I noticed that they specify javax.sql.DataSource. Further, it seems there are settings for maxIdle and maxWait giving the impression that these connections are pooled as well. Glassfish also allows these parameters regardless of the type of data source selected.
Are javax.sql.DataSource pooled in an application server (or servlet container)?
What (if any) advantages are there for choosing javax.sql.ConnectionPoolDataSource over javax.sql.DataSource (or vice versa)?
Yes, Tomcat does use Apache DBCP pooling by default for DataSources defined as JNDI Context resources.
From documentation at
http://tomcat.apache.org/tomcat-7.0-doc/jndi-resources-howto.html#JDBC_Data_Sources
NOTE - The default data source support
in Tomcat is based on the DBCP
connection pool from the Commons
project. However, it is possible to
use any other connection pool that
implements javax.sql.DataSource, by
writing your own custom resource
factory, as described below.
Digging Tomcat 6 sources revealed that they obtain connection factory this way (in case when you don't specify your own using Context's "factory" attribute):
ObjectFactory factory = (ObjectFactory)Class.forName(System.getProperty("javax.sql.DataSource.Factory", "org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory")).newInstance();
And org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory that implements javax.naming.spi.ObjectFactory takes care of creating DataSource instances:
http://www.jarvana.com/jarvana/view/org/apache/tomcat/tomcat-dbcp/7.0.2/tomcat-dbcp-7.0.2-sources.jar!/org/apache/tomcat/dbcp/dbcp/BasicDataSourceFactory.java?format=ok
I see they create instances of org.apache.tomcat.dbcp.dbcp.BasicDataSource:
http://www.jarvana.com/jarvana/view/org/apache/tomcat/tomcat-dbcp/7.0.2/tomcat-dbcp-7.0.2-sources.jar!/org/apache/tomcat/dbcp/dbcp/BasicDataSource.java?format=ok
Oddly enough, this class doesn't implement ConnectionPoolDataSource itself, neither does org.apache.tomcat.dbcp.dbcp.PoolingDataSource, that's returned internally by BasicDataSource
http://www.jarvana.com/jarvana/view/org/apache/tomcat/tomcat-dbcp/7.0.2/tomcat-dbcp-7.0.2-sources.jar!/org/apache/tomcat/dbcp/dbcp/PoolingDataSource.java?format=ok
So I presume when you configured your DataSources as javax.sql.ConnectionPoolDataSource you also used some custom-defined factory (it's just a guess, but I suppose otherwise you'd have class cast exceptions in Tomcat, since their pooling doesn't really provide instances of javax.sql.ConnectionPoolDataSource, only javax.sql.DataSource).
Thus, to answer questions about advantages or disadvantages of particular case you should compare Apache DBCP against pooling mechanism in your DataSource factory, whichever one you used.
My understanding is that only purpose of ConnectionPoolDataSource is to give access to PooledConnection which implements native pooling by JDBC driver. In this case application server can implement connections pooling using this native interface.
When using simple DataSource, appserver uses its own pooling instead of native.
Can't say which approach is best.
As for the Java docs it contains this:
DataSource Java 7 API
The DataSource interface is implemented by a driver vendor. There are three types of implementations:
Basic implementation -- produces a standard Connection object
Connection pooling implementation -- produces a Connection object that will automatically participate in connection pooling. This implementation works with a middle-tier connection pooling manager.
Distributed transaction implementation -- produces a Connection object that may be used for distributed transactions and almost always participates in connection pooling. This implementation works with a middle-tier transaction manager and almost always with a connection pooling manager.
PooledConnection Java 7 API
An application programmer does not use the PooledConnection interface directly; rather, it is used by a middle tier infrastructure that manages the pooling of connections.
When an application calls the method DataSource.getConnection, it gets back a Connection object. If connection pooling is being done, that Connection object is actually a handle to a PooledConnection object, which is a physical connection.
The connection pool manager, typically the application server, maintains a pool of PooledConnection objects ....
So in the end you just use DataSource and Connection classes and never PooledConnection / ConnectionPoolDataSource, if you are a happy and normal programmer.
If are implementing an Application Server that's another story...
Is it possible to use bitronix.tm.resource.jdbc.PoolingDataSource without using bitronix transaction manager and using standalone JBossTS instead?
For database access I use Hibernate, with transaction demarcation done with Spring's #Transactional annotation (or Spring's TransactionTemplate which has similar implementation). PoolingDataSource and standalone JBossTS is used in tests, however I'd like not to abandon db connection pooling.
If it's not possible, what other pooling data source will fit here? Some other question suggests c3p0 is not an option. Is it true?
No, that's not possible and it's also not possible to switch XA pools between transaction managers simply because there is no standard defining the communication between the transaction manager and the JDBC connection pool. At least that's the short story, the long one is here: http://blog.bitronix.be/2011/02/why-we-need-jta-2-0/
AFAIK in the JBossTS case your only options are to use the JBossAS connection pool but that would not be a minor achievement as it requires at least a JCA runtime, but certainly more.
I'm afraid the only realistic options are to use all of BTM or JBossTS without connection pooling or JBossTS with pooling but inside JBossAS.