org.hibernate.transaction
Class JTATransactionFactory

java.lang.Object
  extended by 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
static String DEFAULT_USER_TRANSACTION_NAME
           
protected  InitialContext initialContext
           
protected  String userTransactionName
           
 
Constructor Summary
JTATransactionFactory()
           
 
Method Summary
 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.


Copyright © 2009 Hibernate.org. All Rights Reserved.