net.sf.mmm.transaction.base

Class AbstractTransactionExecutor.AbstractTransactionAdapter<TRANSACTION>

java.lang.Object

net.sf.mmm.transaction.base.AbstractTransactionExecutor.AbstractTransactionAdapter<TRANSACTION>

Type Parameters:

TRANSACTION - is the generic type of the underlying native transaction.

All Implemented Interfaces:

TransactionAdapter

Direct Known Subclasses:

JpaTransactionExecutor.JpaTransactionAdapter, JtaTransactionExecutor.JtaTransactionAdapter, NoTransactionExecutor.NoTransactionAdapter, SpringTransactionExecutor.SpringTransactionAdapter

Enclosing class:

AbstractTransactionExecutor

protected abstract class AbstractTransactionExecutor.AbstractTransactionAdapter<TRANSACTION>
extends Object
implements TransactionAdapter

This is the abstract base implementation of the TransactionAdapter interface.

Field Summary

Fields

Modifier and Type	Field and Description
private TRANSACTION	activeTransaction
private TransactionContext	context

Constructor Summary

Constructors

Constructor and Description
AbstractTransactionAdapter() The constructor.

Method Summary

Modifier and Type	Method and Description
void	commit() This method commits the current transaction without opening a new transaction.
protected abstract TRANSACTION	createNewTransaction() This method creates a new technical transaction.
protected abstract void	doCommit() This method performs the actual commit() on the active transaction.
protected abstract void	doRollback() This method performs the actual rollback() on the active transaction.
protected TRANSACTION	getActiveTransaction() This method gets the underlying native transaction that is currently active.
TransactionContext	getContext() This method gets the TransactionContext that allows to add individual data to be associated with this TransactionAdapter.
void	interCommit() This method commits the transaction currently active and opens a new one.
boolean	isActive() This method determines if this context holds an active transaction.
void	rollback() This method performs a rollback of the current transaction.
protected void	start() This method has to be called after construction in order to start the transaction.
protected void	stop() This method has to be called at the end of the transactional execution to end transaction.

Methods inherited from class java.lang.Object

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

Field Detail

context

private final TransactionContext context

See Also:

getContext()

activeTransaction

private TRANSACTION activeTransaction

See Also:

getActiveTransaction()

Constructor Detail

AbstractTransactionAdapter

public AbstractTransactionAdapter()

The constructor.

Method Detail

start

protected void start()

This method has to be called after construction in order to start the transaction.

stop

protected void stop()

This method has to be called at the end of the transactional execution to end transaction.

createNewTransaction

protected abstract TRANSACTION createNewTransaction()

This method creates a new technical transaction.

Returns:

the new native transaction.

getActiveTransaction

protected TRANSACTION getActiveTransaction()
                                    throws TransactionNotActiveException

This method gets the underlying native transaction that is currently active.

Returns:

the active transaction.

Throws:

TransactionNotActiveException - if there is no active transaction.

isActive

public boolean isActive()

This method determines if this context holds an active transaction.
This is the case until TransactionAdapter.commit() or TransactionAdapter.rollback() was called explicitly.

Specified by:

isActive in interface TransactionAdapter

Returns:

true if there is an active transaction or false otherwise.

getContext

public TransactionContext getContext()

This method gets the TransactionContext that allows to add individual data to be associated with this TransactionAdapter.

Specified by:

getContext in interface TransactionAdapter

Returns:

the TransactionContext.

commit

public void commit()

This method commits the current transaction without opening a new transaction. It allows to throw an exception in your callable but end with a commit rather than a TransactionAdapter.rollback().
ATTENTION:
Please only use this method as end-user if there is no other way to solve your problem.

Specified by:

commit in interface TransactionAdapter

interCommit

public void interCommit()

This method commits the transaction currently active and opens a new one. You should use this method for (recoverable) batches that process large sets of data and therefore would overload if everything was done in one technical transaction.

Specified by:

interCommit in interface TransactionAdapter

doCommit

protected abstract void doCommit()

This method performs the actual commit() on the active transaction.

rollback

public void rollback()

This method performs a rollback of the current transaction. It allows to return from your callable without committing and or throwing an exception.
ATTENTION:
Please only use this method as end-user if there is no other way to solve your problem.

Specified by:

rollback in interface TransactionAdapter

doRollback

protected abstract void doRollback()

This method performs the actual rollback() on the active transaction.