Nested Transaction and J2EE

Question

Hi,
I have a question about how J2EE Application server (WAS4.x/5.x) follows the spec for Nested transaction. In a J2EE tutorial at one place it says
http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/Transaction4.html
following :
A JTA transaction is controlled by the J2EE transaction manager. You may want to use a JTA transaction because it can span updates to multiple databases from different vendors. A particular DBMS's transaction manager may not work with heterogeneous databases. However, the J2EE transaction manager does have one limitation--it does not support nested transactions. In other words, it cannot start a transaction for an instance until the previous transaction has ended.
It means I cannot start another transaction while the first one is not completed.
CASE 1:
My statefull session bean has method a() and method b().
Method a() calls Method b().
I have started userTransaction in Method a() and before commiting
it I have started another transaction in method b(). like
Method a() {
Statrs TX
calls b()
Commits TX
Method b() {
Starts TX
Commits TX
CASE 2:
What if I use Declarative TX
and specify method a() requires new
and method b() also requires new.
Where, method b() is invoked by method a() in a statefull session
bean.
Thanks in advance.

Answer 1

I had i similar problem and solved it in th following way.
My first attempt was to call an atomic method which has the transaction attribute "RequiresNew" from a complex method with the transaction attribute "Required". Both methods where located in the same Session EJB class. If the code inside the atomic method fails by an exception, the exception will be catched and ctx.setRollbackOnly( ) be called in the catch block. This does NOT work! So I start reading a lot in the net and in books. I foud that J2EE does not support nested transactions. So that was a shoot in my foot! :-(
Frustated I went home from work and in the evening I remember some words from Adam Bien, the author of J2EE Patterns. He said that you can build something like nested transactions if you use an additional EJB layer. He said that in the context of a SessionFacade and a set of EntityBeans. But he also said that this will also work with layers of SessionBeans.
At the next day, I build the addional Session EJB and moved all atomic methods in that Session EJB. So the situation is now like this. My ComplexEJB holds method which define a more complex business process. Each of this processes call a lot of atomic methods from the Atomic EJB. In my case it�s not neccesary that all of this atomic methods have to succeed. OK, the methods with transaction attribute "Required" will proceed as much atomic methods with transaction attribute "RequiresNew" as possible! But if a "hard" Exception occurs the whole transaction is rolled back.
This works very good for our needs!
public class ComplexEJB implements SessionBean
    public Collection complexMethod1( Parameter param ) throws BusinessException
     try
            service = this.getAtomicServiceLocal( );
            service.atomicMethod1( param.getSubparam1( ) );
                    service.atomicMethod3( param.getSubparam3( ) );
                    service.atomicMethod1( param.getSubparamN( ) );
                    service.atomicMethod1( param.getSubparam1( ) );
                      catch( "hard" exception like Nullpointer i.e. )
                   //if an "hard" Exception occur rollback the whole transaction
                   ctx.setRollbackOnly( );
    public Collection complexMethodN( Parameter param ) throws BusinessException
     try
        service = this.getAtomicServiceLocal( );
        service.atomicMethod1( param.getSubparam1( ) );
                service.atomicMethod3( param.getSubparam3( ) );
                service.atomicMethod1( param.getSubparamN( ) );
                service.atomicMethod1( param.getSubparam1( ) );
                     catch( "" hard exception like Nullpointer i.e. )
                 //if an "hard" Exception occur rollback the whole transaction
                 ctx.setRollbackOnly( );
public class AtomicEJB implements SessionBean
    public Collection atomicMethod1( Parameter param ) throws BusinessAtomicException
            try
          //The call to a service i.e. access to database
     catch ( DatabseException cbex )
          ctx.setRollbackOnly(  );
     finally
          //release database connection i.e.
    public Collection atomicMethodN( Parameter param ) throws BusinessAtomicException
            try
          //The call to a service i.e. access to database
     catch ( DatabseException cbex )
          ctx.setRollbackOnly(  );
     finally
          //release database connection i.e.