org.hibernate.transaction
Class JTATransactionFactory

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

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.