## 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.

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