JTATransactionFactory (Hibernate Core Aggregator 3.6.10.Final API)

java.lang.Object
- org.hibernate.transaction.JTATransactionFactory

All Implemented Interfaces:

TransactionFactory
```
public class JTATransactionFactory
extends Object
implements TransactionFactory
```
Factory for JTATransaction instances.
To be completely accurate to the JTA spec, JTA implementations should publish their contextual UserTransaction reference into JNDI. However, in practice there are quite a few stand-alone implementations intended for use outside of J2EE/JEE containers and which therefore do not publish their UserTransaction references into JNDI but which otherwise follow the aspects of the JTA specification. This TransactionFactory implementation can support both models.
For complete JTA implementations (including dependence on JNDI), the UserTransaction reference is obtained by a call to resolveInitialContext(java.util.Properties). Hibernate will then attempt to locate the UserTransaction within this resolved InitialContext based on the namespace returned by resolveUserTransactionName(java.util.Properties).
For the so-called stand-alone implementations, we do not care at all about the JNDI aspects just described. Here, the implementation would have a specific manner to obtain a reference to its contextual UserTransaction; usually this would be a static code reference, but again it varies. Anyway, for each implementation the integration would need to override the getUserTransaction() method and return the appropriate thing.

Author:

Gavin King, Steve Ebersole, Les Hazlewood

Nested Class Summary
- Nested classes/interfaces inherited from interface org.hibernate.transaction.TransactionFactory
  TransactionFactory.Context

Field Summary

Fields
Modifier and Type Field and Description

static String DEFAULT_USER_TRANSACTION_NAME

protected InitialContext initialContext

protected String userTransactionName

Fields
Modifier and Type	Field and Description
`static String`	`DEFAULT_USER_TRANSACTION_NAME`
`protected InitialContext`	`initialContext`
`protected String`	`userTransactionName`

Constructor Summary

Constructors
Constructor and Description

JTATransactionFactory()

Constructors
Constructor and Description
`JTATransactionFactory()`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`areCallbacksLocalToHibernateTransactions()` Are all transaction callbacks local to Hibernate Transactions? Or can the callbacks originate from some other source (e.g.
`void`	`configure(Properties props)` Configure this transaction factory.
`Transaction`	`createTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)` Begin a transaction and return the associated `Transaction` instance.
`ConnectionReleaseMode`	`getDefaultReleaseMode()` Get the default connection release mode.
`protected InitialContext`	`getInitialContext()` Getter for property 'initialContext'.
`protected UserTransaction`	`getUserTransaction()` Get the `UserTransaction` reference.
`protected String`	`getUserTransactionName()` Getter for property 'userTransactionName'.
`boolean`	`isTransactionInProgress(JDBCContext jdbcContext, TransactionFactory.Context transactionContext, Transaction transaction)` Determine whether an underlying transaction is in progress.
`boolean`	`isTransactionManagerRequired()` Do we require access to the JTA TransactionManager for this strategy?
`protected InitialContext`	`resolveInitialContext(Properties properties)` Given the lot of Hibernate configuration properties, resolve appropriate reference to JNDI `InitialContext`.
`protected String`	`resolveUserTransactionName(Properties properties)` Given the lot of Hibernate configuration properties, resolve appropriate JNDI namespace to use for `UserTransaction` resolution.

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

- Field Detail
  - DEFAULT_USER_TRANSACTION_NAME
```
public static final String DEFAULT_USER_TRANSACTION_NAME
```
    See Also:
    Constant Field Values
  - initialContext
```
protected InitialContext initialContext
```
  - userTransactionName
```
protected String userTransactionName
```
- Constructor Detail
  - JTATransactionFactory
```
public JTATransactionFactory()
```
- Method Detail
  - configure
```
public void configure(Properties props)
               throws HibernateException
```
    Configure this transaction factory. Specifically here we are attempting to resolve both an InitialContext as well as the JNDI namespace for the UserTransaction.
    
    Specified by:
    
    configure in interface TransactionFactory
    
    Parameters:
    props - The configuration properties
    
    Throws:
    
    HibernateException
  - resolveInitialContext
```
protected final InitialContext resolveInitialContext(Properties properties)
```
    Given the lot of Hibernate configuration properties, resolve appropriate reference to JNDI InitialContext.
    In general, the properties in which we are interested here all begin with hibernate.jndi. Especially important depending on your environment are hibernate.jndi.url and hibernate.jndi.class
    
    Parameters:
    properties - The Hibernate config properties.
    
    Returns:
    The resolved InitialContext.
  - resolveUserTransactionName
```
protected final String resolveUserTransactionName(Properties properties)
```
    Given the lot of Hibernate configuration properties, resolve appropriate JNDI namespace to use for UserTransaction resolution.
    We determine the namespace to use by
    1. Any specified jta.UserTransaction config property
    2. If a TransactionManagerLookup was indicated, use its TransactionManagerLookup.getUserTransactionName()
    3. finally, as a last resort, we use DEFAULT_USER_TRANSACTION_NAME
    Parameters:
    properties - The Hibernate config properties.
    
    Returns:
    The resolved UserTransaction namespace
  - createTransaction
```
public Transaction createTransaction(JDBCContext jdbcContext,
                            TransactionFactory.Context transactionContext)
                              throws HibernateException
```
    Begin a transaction and return the associated Transaction instance.
    
    Specified by:
    
    createTransaction in interface TransactionFactory
    
    Parameters:
    jdbcContext - The jdbc context to which the transaction belongs
    transactionContext - The contract regarding the context in which this transaction will operate.
    
    Returns:
    Transaction
    
    Throws:
    
    HibernateException - Indicates a problem generating a transaction instance
  - getUserTransaction
```
protected UserTransaction getUserTransaction()
```
    Get the UserTransaction reference.
    
    Returns:
    The appropriate UserTransaction reference.
  - getInitialContext
```
protected InitialContext getInitialContext()
```
    Getter for property 'initialContext'.
    
    Returns:
    Value for property 'initialContext'.
  - getUserTransactionName
```
protected String getUserTransactionName()
```
    Getter for property 'userTransactionName'. The algorithm here is
    
    Returns:
    Value for property 'userTransactionName'.
  - getDefaultReleaseMode
```
public ConnectionReleaseMode getDefaultReleaseMode()
```
    Get the default connection release mode.
    
    Specified by:
    
    getDefaultReleaseMode in interface TransactionFactory
    
    Returns:
    The default release mode associated with this strategy
  - isTransactionManagerRequired
```
public boolean isTransactionManagerRequired()
```
    Do we require access to the JTA TransactionManager for this strategy?
    
    Specified by:
    
    isTransactionManagerRequired in interface TransactionFactory
    
    Returns:
    True if this strategy requires access to the JTA TransactionManager; false otherwise.
  - areCallbacksLocalToHibernateTransactions
```
public boolean areCallbacksLocalToHibernateTransactions()
```
    Are all transaction callbacks local to Hibernate Transactions? Or can the callbacks originate from some other source (e.g. a JTA Synchronization).
    
    Specified by:
    
    areCallbacksLocalToHibernateTransactions in interface TransactionFactory
    
    Returns:
    true if callbacks only ever originate from the Hibernate Transaction; false otherwise.
  - isTransactionInProgress
```
public boolean isTransactionInProgress(JDBCContext jdbcContext,
                              TransactionFactory.Context transactionContext,
                              Transaction transaction)
```
    Determine whether an underlying transaction is in progress.
    Mainly this is used in determining whether to register a synchronization as well as whether or not to circumvent auto flushing outside transactions.
    
    Specified by:
    
    isTransactionInProgress in interface TransactionFactory
    
    Parameters:
    jdbcContext - The JDBC context
    transactionContext - The transaction context
    transaction - The Hibernate transaction
    
    Returns:
    true if an underlying transaction is know to be in effect.

Class JTATransactionFactory

Nested Class Summary

Nested classes/interfaces inherited from interface org.hibernate.transaction.TransactionFactory

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_USER_TRANSACTION_NAME

initialContext

userTransactionName

Constructor Detail

JTATransactionFactory

Method Detail

configure

resolveInitialContext

resolveUserTransactionName

createTransaction

getUserTransaction

getInitialContext

getUserTransactionName

getDefaultReleaseMode

isTransactionManagerRequired

areCallbacksLocalToHibernateTransactions

isTransactionInProgress