AbstractTransactionImpl (Red Hat JBoss Enterprise Application Platform 6.4.19.GA public API)

java.lang.Object
- org.hibernate.engine.transaction.spi.AbstractTransactionImpl

All Implemented Interfaces:

TransactionImplementor, Transaction

Direct Known Subclasses:

CMTTransaction, JdbcTransaction, JtaTransaction
```
public abstract class AbstractTransactionImpl
extends Object
implements TransactionImplementor
```
Abstract support for creating transaction implementations

Author:

Steve Ebersole

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractTransactionImpl(TransactionCoordinator transactionCoordinator)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractTransactionImpl(TransactionCoordinator transactionCoordinator)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected abstract void`	`afterAfterCompletion()`
`protected abstract void`	`afterTransactionBegin()`
`protected abstract void`	`afterTransactionCompletion(int status)`
`protected boolean`	`allowFailedCommitToPhysicallyRollback()`
`protected abstract void`	`beforeTransactionCommit()`
`protected abstract void`	`beforeTransactionRollBack()`
`void`	`begin()` Begin this transaction.
`void`	`commit()` Commit this transaction.
`protected abstract void`	`doBegin()` Perform the actual steps of beginning a transaction according to the strategy.
`protected abstract void`	`doCommit()` Perform the actual steps of committing a transaction according to the strategy.
`protected boolean`	`doExtendedActiveCheck()` Active has been checked against local state.
`protected abstract void`	`doRollback()` Perform the actual steps of rolling back a transaction according to the strategy.
`LocalStatus`	`getLocalStatus()` Get the current local status of this transaction.
`int`	`getTimeout()` Retrieve the transaction timeout set for this transaction.
`void`	`invalidate()` Called after completion of the underlying transaction to signify the facade is no longer valid.
`boolean`	`isActive()` Is this transaction still active? Answers on a best effort basis.
`boolean`	`isParticipating()` Is Hibernate participating in the underlying transaction? Generally speaking this will be the same as `Transaction.isActive()`.
`void`	`join()` Perform a join to the underlying transaction
`protected JtaPlatform`	`jtaPlatform()` Provide subclasses with convenient access to the configured `JtaPlatform`
`void`	`markForJoin()` Mark a transaction as joinable
`void`	`registerSynchronization(Synchronization synchronization)` Register a user synchronization callback for this transaction.
`void`	`resetJoinStatus()` Reset this transaction's join status.
`void`	`rollback()` Rollback this transaction.
`void`	`setTimeout(int seconds)` Set the transaction timeout for any transaction started by a subsequent call to `Transaction.begin()` on this instance.
`protected TransactionCoordinator`	`transactionCoordinator()` Provide subclasses with access to the transaction coordinator.
`boolean`	`wasCommitted()` Was this transaction committed? Answers on a best effort basis.
`boolean`	`wasRolledBack()` Was this transaction rolled back or set to rollback only? Answers on a best effort basis.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.hibernate.engine.transaction.spi.TransactionImplementor
createIsolationDelegate, getJoinStatus, markRollbackOnly

Methods inherited from interface org.hibernate.Transaction
isInitiator

- Constructor Detail
  - AbstractTransactionImpl
```
protected AbstractTransactionImpl(TransactionCoordinator transactionCoordinator)
```
- Method Detail
  - invalidate
```
public void invalidate()
```
    Description copied from interface: TransactionImplementor
    
    Called after completion of the underlying transaction to signify the facade is no longer valid.
    
    Specified by:
    
    invalidate in interface TransactionImplementor
  - doBegin
```
protected abstract void doBegin()
```
    Perform the actual steps of beginning a transaction according to the strategy.
    
    Throws:
    
    TransactionException - Indicates a problem beginning the transaction
  - doCommit
```
protected abstract void doCommit()
```
    Perform the actual steps of committing a transaction according to the strategy.
    
    Throws:
    
    TransactionException - Indicates a problem committing the transaction
  - doRollback
```
protected abstract void doRollback()
```
    Perform the actual steps of rolling back a transaction according to the strategy.
    
    Throws:
    
    TransactionException - Indicates a problem rolling back the transaction
  - afterTransactionBegin
```
protected abstract void afterTransactionBegin()
```
  - beforeTransactionCommit
```
protected abstract void beforeTransactionCommit()
```
  - beforeTransactionRollBack
```
protected abstract void beforeTransactionRollBack()
```
  - afterTransactionCompletion
```
protected abstract void afterTransactionCompletion(int status)
```
  - afterAfterCompletion
```
protected abstract void afterAfterCompletion()
```
  - transactionCoordinator
```
protected TransactionCoordinator transactionCoordinator()
```
    Provide subclasses with access to the transaction coordinator.
    
    Returns:
    This transaction's context.
  - jtaPlatform
```
protected JtaPlatform jtaPlatform()
```
    Provide subclasses with convenient access to the configured JtaPlatform
    
    Returns:
    The JtaPlatform
  - registerSynchronization
```
public void registerSynchronization(Synchronization synchronization)
```
    Description copied from interface: Transaction
    
    Register a user synchronization callback for this transaction.
    
    Specified by:
    
    registerSynchronization in interface Transaction
    
    Parameters:
    synchronization - The Synchronization callback to register.
  - getLocalStatus
```
public LocalStatus getLocalStatus()
```
    Description copied from interface: Transaction
    
    Get the current local status of this transaction.
    This only accounts for the local view of the transaction status. In other words it does not check the status of the actual underlying transaction.
    
    Specified by:
    
    getLocalStatus in interface Transaction
    
    Returns:
    The current local status.
  - isActive
```
public boolean isActive()
```
    Description copied from interface: Transaction
    
    Is this transaction still active?
    Answers on a best effort basis. For example, in the case of JDBC based transactions we cannot know that a transaction is active when it is initiated directly through the JDBC Connection, only when it is initiated from here.
    
    Specified by:
    
    isActive in interface Transaction
    
    Returns:
    true if the transaction is still active; false otherwise.
  - isParticipating
```
public boolean isParticipating()
```
    Description copied from interface: Transaction
    
    Is Hibernate participating in the underlying transaction?
    Generally speaking this will be the same as Transaction.isActive().
    
    Specified by:
    
    isParticipating in interface Transaction
    
    Returns:
    true if Hibernate is known to be participating in the underlying transaction; false otherwise.
  - wasCommitted
```
public boolean wasCommitted()
```
    Description copied from interface: Transaction
    
    Was this transaction committed?
    Answers on a best effort basis. For example, in the case of JDBC based transactions we cannot know that a transaction was committed when the commit was performed directly through the JDBC Connection, only when the commit was done from this.
    
    Specified by:
    
    wasCommitted in interface Transaction
    
    Returns:
    true if the transaction is rolled back; false otherwise.
  - wasRolledBack
```
public boolean wasRolledBack()
                      throws HibernateException
```
    Description copied from interface: Transaction
    
    Was this transaction rolled back or set to rollback only?
    Answers on a best effort basis. For example, in the case of JDBC based transactions we cannot know that a transaction was rolled back when rollback was performed directly through the JDBC Connection, only when it was rolled back from here.
    
    Specified by:
    
    wasRolledBack in interface Transaction
    
    Returns:
    true if the transaction is rolled back; false otherwise.
    
    Throws:
    
    HibernateException - Indicates a problem checking the transaction status.
  - doExtendedActiveCheck
```
protected boolean doExtendedActiveCheck()
```
    Active has been checked against local state. Perform any needed checks against resource transactions.
    
    Returns:
    true if the extended active check checks out as well; false otherwise.
  - begin
```
public void begin()
           throws HibernateException
```
    Description copied from interface: Transaction
    
    Begin this transaction. No-op if the transaction has already been begun. Note that this is not necessarily symmetrical since usually multiple calls to Transaction.commit() or Transaction.rollback() will error.
    
    Specified by:
    
    begin in interface Transaction
    
    Throws:
    
    HibernateException - Indicates a problem beginning the transaction.
  - commit
```
public void commit()
            throws HibernateException
```
    Description copied from interface: Transaction
    Commit this transaction. This might entail a number of things depending on the context:
    - If this transaction is the initiator, Session.flush() the Session with which it is associated (unless Session is in FlushMode.MANUAL).
    - If this transaction is the initiator, commit the underlying transaction.
    - Coordinate various callbacks
    Specified by:
    
    commit in interface Transaction
    
    Throws:
    
    HibernateException - Indicates a problem committing the transaction.
  - allowFailedCommitToPhysicallyRollback
```
protected boolean allowFailedCommitToPhysicallyRollback()
```
  - rollback
```
public void rollback()
              throws HibernateException
```
    Description copied from interface: Transaction
    
    Rollback this transaction. Either rolls back the underlying transaction or ensures it cannot later commit (depending on the actual underlying strategy).
    
    Specified by:
    
    rollback in interface Transaction
    
    Throws:
    
    HibernateException - Indicates a problem rolling back the transaction.
  - setTimeout
```
public void setTimeout(int seconds)
```
    Description copied from interface: Transaction
    
    Set the transaction timeout for any transaction started by a subsequent call to Transaction.begin() on this instance.
    
    Specified by:
    
    setTimeout in interface Transaction
    
    Parameters:
    seconds - The number of seconds before a timeout.
  - getTimeout
```
public int getTimeout()
```
    Description copied from interface: Transaction
    
    Retrieve the transaction timeout set for this transaction. A negative indicates no timeout has been set.
    
    Specified by:
    
    getTimeout in interface Transaction
    
    Returns:
    The timeout, in seconds.
  - markForJoin
```
public void markForJoin()
```
    Description copied from interface: TransactionImplementor
    
    Mark a transaction as joinable
    
    Specified by:
    
    markForJoin in interface TransactionImplementor
  - join
```
public void join()
```
    Description copied from interface: TransactionImplementor
    
    Perform a join to the underlying transaction
    
    Specified by:
    
    join in interface TransactionImplementor
  - resetJoinStatus
```
public void resetJoinStatus()
```
    Description copied from interface: TransactionImplementor
    
    Reset this transaction's join status.
    
    Specified by:
    
    resetJoinStatus in interface TransactionImplementor

Class AbstractTransactionImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.hibernate.engine.transaction.spi.TransactionImplementor

Methods inherited from interface org.hibernate.Transaction

Constructor Detail

AbstractTransactionImpl

Method Detail

invalidate

doBegin

doCommit

doRollback

afterTransactionBegin

beforeTransactionCommit

beforeTransactionRollBack

afterTransactionCompletion

afterAfterCompletion

transactionCoordinator

jtaPlatform

registerSynchronization

getLocalStatus

isActive

isParticipating

wasCommitted

wasRolledBack

doExtendedActiveCheck

begin

commit

allowFailedCommitToPhysicallyRollback

rollback

setTimeout

getTimeout

markForJoin

join

resetJoinStatus