net.java.trueupdate.manager.spec.tx
Class AtomicMethodsTransaction

java.lang.Object
  net.java.trueupdate.manager.spec.tx.Transaction
      net.java.trueupdate.manager.spec.tx.AtomicMethodsTransaction

public abstract class AtomicMethodsTransaction
extends Transaction

A local transaction which is made of truly atomic methods, that is its methods either completely succeed or completely fail. On this precondition, this class then cooperates with Transactions.execute(net.java.trueupdate.manager.spec.tx.Transaction) to make sure that its rollbackAtomic() method is only called if performAtomic() has succeeded before, e.g. when composed into a CompositeTransaction.

Author:

Christian Schlichtherle

See Also:

Transactions.execute(net.java.trueupdate.manager.spec.tx.Transaction), CompositeTransaction

AtomicMethodsTransaction

public AtomicMethodsTransaction()

commit

public final void commit()

Description copied from class: Transaction

Commits the visible side effects of the body of this transaction. If this method succeeds, any visible side effects of Transaction.perform() must be durable. If this method throws a RuntimeException, then the state of this transaction is undefined and may be inconsistent. If this method throws a RuntimeException and this transaction is part of a composite transaction, then the preceding transactions get neither committed nor rolled back and their state is undefined and may be inconsistent.

Overrides:

commit in class Transaction

commitAtomic

public void commitAtomic()

Semantically identical to commit(), but has to be truly atomic, that is it either completely succeeds or completely fails.

perform

public final void perform()
                   throws Exception

Description copied from class: Transaction

Executes the body of this transaction. If this method throws an Exception, then this transaction gets aborted with calling Transaction.rollback(), so it may leave some visible side effects. If this method throws an Exception and this transaction is part of a composite transaction, then the preceding transactions get properly rolled back.

Specified by:

perform in class Transaction

Throws:

Exception

performAtomic

public abstract void performAtomic()
                            throws Exception

Semantically identical to perform(), but has to be truly atomic, that is it either completely succeeds or completely fails.

Throws:

Exception

prepare

public final void prepare()
                   throws Exception

Description copied from class: Transaction

Sets up this transaction for execution. If this method throws an Exception, then this transaction gets aborted without calling Transaction.rollback(), so it must not leave any visible side effects. If this method throws an Exception and this transaction is part of a composite transaction, then the preceding transactions get properly rolled back.

Overrides:

prepare in class Transaction

Throws:

Exception

prepareAtomic

public void prepareAtomic()
                   throws Exception

Semantically identical to prepare(), but has to be truly atomic, that is it either completely succeeds or completely fails.

Throws:

Exception

rollback

public final void rollback()

Description copied from class: Transaction

Reverts any visible side effects of the body of this transaction. If this method succeeds, it must revert any visible side effects of Transaction.perform(). If this method throws a RuntimeException, then the state of this transaction is undefined and may be inconsistent. If this method throws a RuntimeException and this transaction is part of a composite transaction, then the preceding transactions get neither committed nor rolled back and their state is undefined and may be inconsistent.

Specified by:

rollback in class Transaction

rollbackAtomic

public abstract void rollbackAtomic()

Semantically identical to rollback(), but has to be truly atomic, that is it either completely succeeds or completely fails.