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

  • Field Details

    • DEFAULT_USER_TRANSACTION_NAME

      public static final String DEFAULT_USER_TRANSACTION_NAME
      See Also:

    • initialContext

      protected InitialContext initialContext

    • userTransactionName

      protected String userTransactionName

  • Constructor Details

    • JTATransactionFactory

      public JTATransactionFactory()

  • Method Details

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