com.atomikos.icatch.jta.template

Class TransactionTemplate

java.lang.Object

com.atomikos.icatch.jta.template.TransactionTemplate

public class TransactionTemplate
extends Object

Template (builder-style) logic for light-weight transaction demarcation. Example usage:

 
     TransactionTemplate template = new TransactionTemplate();
     template.withTimeout(5).required().execute(() -> {
         //your transactional code as a lambda expression
     });
  
 

Instead of a lambda expression, you can also supply a Callable instance.

Field Summary

Fields

Modifier and Type	Field and Description
protected TransactionManager	utm

Constructor Summary

Constructors

Constructor and Description
TransactionTemplate()

Method Summary

Modifier and Type	Method and Description
protected void	beginTransaction()
protected void	beginTransactionIfNoneExists()
protected void	commitTransactionIfStartedHere()
<T> T	execute(Callable<T> work) Defaults to required() strategy.
protected void	forceRollback(Throwable e)
TransactionTemplate	mandatory()
TransactionTemplate	nested()
TransactionTemplate	never()
TransactionTemplate	notSupported()
TransactionTemplate	required()
TransactionTemplate	requiresNew()
protected void	resumeExistingTransaction()
TransactionTemplate	supports()
protected void	suspendExistingTransaction()
TransactionTemplate	withTimeout(int timeout)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

utm

protected TransactionManager utm

Constructor Detail

TransactionTemplate

public TransactionTemplate()

Method Detail

withTimeout

public TransactionTemplate withTimeout(int timeout)

required

public TransactionTemplate required()

Returns:

An instance that executes work with REQUIRED semantics.

• For new transactions: any exception will lead to rollback, no exception means commit.
• For existing transactions: any exception will mark the transaction as rollbackOnly.

nested

public TransactionTemplate nested()

Returns:

An instance that executes work in a new (nested) transaction and commits if there are no exceptions. Any exception will lead to rollback of the (nested) transaction.

beginTransaction

protected void beginTransaction()
                         throws Exception

Throws:

Exception

commitTransactionIfStartedHere

protected void commitTransactionIfStartedHere()
                                       throws Exception

Throws:

Exception

forceRollback

protected void forceRollback(Throwable e)
                      throws Exception

Throws:

Exception

beginTransactionIfNoneExists

protected void beginTransactionIfNoneExists()
                                     throws Exception

Throws:

Exception

resumeExistingTransaction

protected void resumeExistingTransaction()
                                  throws Exception

Throws:

Exception

suspendExistingTransaction

protected void suspendExistingTransaction()
                                   throws Exception

Throws:

Exception

execute

public <T> T execute(Callable<T> work)
              throws Exception

Defaults to required() strategy.

Parameters:

work -

Returns:

Throws:

Exception

requiresNew

public TransactionTemplate requiresNew()

Returns:

An instance that executes work with REQUIRES_NEW semantics. Any exception will lead to rollback, no exception means commit.

mandatory

public TransactionTemplate mandatory()

Returns:

An instance that executes work with MANDATORY semantics. Any exception will lead to rollbackOnly status of the existing transaction.

never

public TransactionTemplate never()

Returns:

An instance that executes work with NEVER semantics.

supports

public TransactionTemplate supports()

Returns:

An instance that executes work with SUPPORTS semantics.

notSupported

public TransactionTemplate notSupported()

Returns:

An instance that executes work with NOT_SUPPORTED semantics.