com.atlassian.jira.transaction

Interface Transaction

public interface Transaction

This represents the state of a running transaction that can be comitted or rolled back

Since:

v4.4.1

Method Summary

Modifier and Type	Method and Description
void	commit() This will commit the transaction.
void	finallyRollbackIfNotCommitted() This is designed to be called in a top level finally block and it will attempt to rollback the transaction IF it has not already been committed.
NestedConnection	getNestedConnection() This will return the connection used by this transaction, in a transaction-safe wrapper using NestedConnection
boolean	isNewTransaction() Returns if this is a new transaction.
void	rollback() This will rollback the transaction.
void	runAfterSuccessfulCommit(Runnable runnable) This will enqueue a runnable that will be run if the transaction successfully commits.

Method Detail

commit

void commit()
     throws TransactionRuntimeException

This will commit the transaction.

Throws:

TransactionRuntimeException - if the transaction cannot be commited

rollback

void rollback()
       throws TransactionRuntimeException

This will rollback the transaction.

Throws:

TransactionRuntimeException - if the transaction cannot be rollbacked

finallyRollbackIfNotCommitted

void finallyRollbackIfNotCommitted()

This is designed to be called in a top level finally block and it will attempt to rollback the transaction IF it has not already been committed. This allows you to simplify your try/catch/finally blocks in and around transaction code.

Note it DOES NOT throw a {@link TransactionRuntimeException) if the roll back cannot be performed. Since this is intended to be inside a finally block it most likely to late to know about this you probably dont want to do anything since rollback hasnt worked either. So it logs this condition is an ignores it to make calling code more simple.

isNewTransaction

boolean isNewTransaction()

Returns if this is a new transaction. A nested transaction is not new and its behaviour for commit and rollback calls is not performed immediately.

Calls to commit for a nested transaction effectively do nothing relying on the outer transaction to perform the commit.

Calls to rollback for a nested transaction mark the outer transaction as requiring to be rolled back. The outer transaction will eventually rollback, whether commit or rollback is eventually called.

Returns:

if this represents a new transaction. and hence whether calling commit() or rollback() will actually do anything

runAfterSuccessfulCommit

void runAfterSuccessfulCommit(@Nonnull
                              Runnable runnable)

This will enqueue a runnable that will be run if the transaction successfully commits. All enqueued runnable code will be run in enqueued order. If the transaction rolls back then no code is run. NO exceptions will bubble out of them into the upper Transaction code.

Parameters:

runnable - the code to run if the transaction commits successfully

getNestedConnection

NestedConnection getNestedConnection()

This will return the connection used by this transaction, in a transaction-safe wrapper using NestedConnection

Used as a safety measure against devs calling commit() close() etc

Returns:

The connection used by this transaction

Since:

7.5.0