The Java Transaction API and WebLogic

JTA specifies local, high-level Java interfaces between a transaction manager and the other parties involved in a distributed transactional system. The JTA package, javax.transaction, contains three core interfaces:

• UserTransaction

• TransactionManager

• Transaction

The UserTransaction Interface

The UserTransaction interface is implemented for bean-managed transaction boundaries. It defines six methods that allow an application to explicitly manage transaction boundaries:

• begin— Creates a new transaction associated with the current thread

• commit— Commits a transaction

• getStatus— Returns the status of a transaction as an integer

• rollback— Immediately rolls back the transaction associated with the current thread

• setRollbackOnly— Does not immediately roll back the transaction, but sets a flag that calls the rollback method after the current operation has completed

• setTransactionTimeout— Sets the time in seconds in which a transaction associated with the current thread will time out if not completed

  The following code is a high-level example of how to use the UserTransaction API:

  // create a JNDI Initial context
  Context ctx = new InitialContext();
  // obtain the UserTransaction
  UserTransaction utx = (UserTransaction) ctx.lookup
                                        ("java:comp/UserTransaction");
  // begin the transaction
  utx.begin();
  //  . work.......
  utx.commit();
  

With regular Java applications, such as servlets, RMI applications, JavaBeans, MDBs, and session EJBs, the UserTransaction interface is implemented explicitly in the source code of the application.

However, enterprise components (session beans and MDBs) may use the TX_BEAN_MANAGED transaction attribute, which is set in the bean's deployment descriptor, to implement the UserTransaction interface. In this manner, the application does not directly interface with the transaction manager, but relies on the EJB server to provide support for all of its transaction work. JTA transactions are automatically transferred from the client side to the server side when using RMI (and EJB). So, a server component can participate in a transaction and force it to roll back. However, it cannot commit or roll back; only the participant who started the transaction can finish it.

The TransactionManager Interface

The TransactionManager interface is the interface intended for the application server to manage transaction boundaries on behalf of the application being managed (that is, container-managed transactions). An example of using the TransactionManager interface follows:

Transaction tx = TransactionManager.suspend ();
. . .
TransactionManager.resume (tx);

WebLogic's weblogic.transaction.TransactionManager interface extends the javax.transaction.TransactionManager interface, allowing components using bean-managed transactions to suspend and resume their own transactions.

The Transaction Interface

The Transaction interface is intended for use by a resource manager to participate in and perform operations on the transaction itself. The following code snippet shows how the Transaction interface can be used:

Transaction tx = null;
      TransactionManager tm = getTransactionManager ();
  try
  {
      tx = tm.getTransaction();
  }
  catch(SystemException e)
  {
  }
  if (tx == null)
  {
      try
      {
          tm.begin();
      }
      catch(NotSupportedException e)
      {  }
      catch(SystemException e)
      {  }
  }

A resource manager could use this interface to enlist or delist resources, register for synchronization callbacks, commit or roll back a transaction, and obtain the status of a transaction.