## org.hibernate.transaction
Class JTATransaction

    java.lang.Object
      org.hibernate.transaction.JTATransaction

All Implemented Interfaces:
  Transaction

    public class JTATransaction

extends Object
implements Transaction

`Transaction` implementation based on transaction management through a JTA `UserTransaction`. Similar to `CMTTransaction`, except here we are actually managing the transactions through the Hibernate transaction mechanism.

Author:
  Gavin King, Steve Ebersole, Les Hazlewood

Constructor Summary
`JTATransaction(UserTransaction userTransaction, JDBCContext jdbcContext, TransactionFactory.Context transactionContext)`

Method Summary
`void` `begin()` Begin a new transaction.
`void` `commit()` Flush the associated `Session` and end the unit of work (unless we are in `FlushMode.MANUAL`.
`protected UserTransaction` `getUserTransaction()` Getter for property 'userTransaction'.
`boolean` `isActive()` Is this transaction still active? Again, this only returns information in relation to the local transaction, not the actual underlying transaction.
`void` `registerSynchronization(Synchronization sync)` Register a user synchronization callback for this transaction.
`void` `rollback()` Force the underlying transaction to roll back.
`void` `setTimeout(int seconds)` Set the transaction timeout for any transaction started by a subsequent call to `begin()` on this instance.
`boolean` `wasCommitted()` Check if this transaction was successfully committed.
`boolean` `wasRolledBack()` Was this transaction rolled back or set to rollback only? This only accounts for actions initiated from this local transaction.

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

Constructor Detail

### JTATransaction

    public JTATransaction(UserTransaction userTransaction,
                          JDBCContext jdbcContext,
                          TransactionFactory.Context transactionContext)

Method Detail

### begin

    public void begin()
               throws HibernateException

  Begin a new transaction.

  Specified by:
    `begin` in interface `Transaction`
  Throws:
    `HibernateException`

### commit

    public void commit()
                throws HibernateException

  Flush the associated `Session` and end the unit of work (unless we are in `FlushMode.MANUAL`. This method will commit the underlying transaction if and only if the underlying transaction was initiated by this object.

  Specified by:
    `commit` in interface `Transaction`
  Throws:
    `HibernateException`

### rollback

    public void rollback()
                  throws HibernateException

  Force the underlying transaction to roll back.

  Specified by:
    `rollback` in interface `Transaction`
  Throws:
    `HibernateException`

### wasRolledBack

    public boolean wasRolledBack()
                          throws TransactionException

  Was this transaction rolled back or set to rollback only?

  This only accounts for actions initiated from this local transaction. If, for example, the underlying transaction is forced to rollback via some other means, this method still reports false because the rollback was not initiated from here.

  Specified by:
    `wasRolledBack` in interface `Transaction`
  Returns:
    boolean True if the transaction was rolled back via this local transaction; false otherwise.
  Throws:
    `TransactionException`

### wasCommitted

    public boolean wasCommitted()
                         throws TransactionException

  Check if this transaction was successfully committed.

  This method could return `false` even after successful invocation of `Transaction.commit()`. As an example, JTA based strategies no-op on `Transaction.commit()` calls if they did not start the transaction; in that case, they also report `Transaction.wasCommitted()` as false.

  Specified by:
    `wasCommitted` in interface `Transaction`
  Returns:
    boolean True if the transaction was (unequivocally) committed via this local transaction; false otherwise.
  Throws:
    `TransactionException`

### isActive

    public boolean isActive()
                     throws TransactionException

  Is this transaction still active?

  Again, this only returns information in relation to the local transaction, not the actual underlying transaction.

  Specified by:
    `isActive` in interface `Transaction`
  Returns:
    boolean Treu if this local transaction is still active.
  Throws:
    `TransactionException`

### registerSynchronization

    public void registerSynchronization(Synchronization sync)
                                 throws HibernateException

  Register a user synchronization callback for this transaction.

  Specified by:
    `registerSynchronization` in interface `Transaction`
  Parameters:
    `sync` - The Synchronization callback to register.
  Throws:
    `HibernateException`

### setTimeout

    public void setTimeout(int seconds)

  Set the transaction timeout for any transaction started by a subsequent call to `begin()` on this instance.

  Specified by:
    `setTimeout` in interface `Transaction`
  Parameters:
    `seconds` - The number of seconds before a timeout.

### getUserTransaction

    protected UserTransaction getUserTransaction()

  Getter for property 'userTransaction'.

  Returns:
    Value for property 'userTransaction'.

Copyright © 2001-2010 Red Hat, Inc. All Rights Reserved.