Class JtaTransactionManager

java.lang.Object
org.springframework.transaction.support.AbstractPlatformTransactionManager
org.springframework.transaction.jta.JtaTransactionManager
All Implemented Interfaces:
Serializable, InitializingBean, ConfigurableTransactionManager, TransactionFactory, PlatformTransactionManager, TransactionManager
public class JtaTransactionManager extends AbstractPlatformTransactionManager implements TransactionFactory, InitializingBean, Serializable
PlatformTransactionManager implementation for JTA, delegating to a backend JTA provider. This is typically used to delegate to a Jakarta EE server's transaction coordinator, but may also be configured with a local JTA provider which is embedded within the application.

This transaction manager is appropriate for handling distributed transactions, i.e. transactions that span multiple resources, and for controlling transactions on application server resources (for example, JDBC DataSources available in JNDI) in general. For a single JDBC DataSource, DataSourceTransactionManager is perfectly sufficient, and for accessing a single resource with Hibernate (including transactional cache), HibernateTransactionManager is appropriate, for example.

For typical JTA transactions (REQUIRED, SUPPORTS, MANDATORY, NEVER), a plain JtaTransactionManager definition is all you need, portable across all Jakarta EE servers. This corresponds to the functionality of the JTA UserTransaction, for which Jakarta EE specifies a standard JNDI name ("java:comp/UserTransaction"). There is no need to configure a server-specific TransactionManager lookup for this kind of JTA usage.

Transaction suspension (REQUIRES_NEW, NOT_SUPPORTED) is just available with a JTA TransactionManager being registered. Common TransactionManager locations are autodetected by JtaTransactionManager, provided that the "autodetectTransactionManager" flag is set to "true" (which it is by default).

Note: Support for the JTA TransactionManager interface is not required by Jakarta EE. Almost all Jakarta EE servers expose it, but do so as extension to EE. There might be some issues with compatibility, despite the TransactionManager interface being part of JTA.

This pure JtaTransactionManager class supports timeouts but not per-transaction isolation levels. Custom subclasses may override the doJtaBegin(JtaTransactionObject, TransactionDefinition) method for specific JTA extensions in order to provide this functionality. Such adapters for specific Jakarta EE transaction coordinators may also expose transaction names for monitoring; with standard JTA, transaction names will simply be ignored.

JTA 1.1 adds the TransactionSynchronizationRegistry facility, as public Jakarta EE API in addition to the standard JTA UserTransaction handle. As of Spring 2.5, this JtaTransactionManager autodetects the TransactionSynchronizationRegistry and uses it for registering Spring-managed synchronizations when participating in an existing JTA transaction (for example, controlled by EJB CMT). If no TransactionSynchronizationRegistry is available, then such synchronizations will be registered via the (non-EE) JTA TransactionManager handle.

This class is serializable. However, active synchronizations do not survive serialization.

Since:
24.03.2003
Author:
Juergen Hoeller
See Also:

  • Field Details

  • Constructor Details

    • JtaTransactionManager

      public JtaTransactionManager()
      Create a new JtaTransactionManager instance, to be configured as bean. Invoke afterPropertiesSet to activate the configuration.
      See Also:

    • JtaTransactionManager

      public JtaTransactionManager(jakarta.transaction.UserTransaction userTransaction)
      Create a new JtaTransactionManager instance.
      Parameters:
      userTransaction - the JTA UserTransaction to use as direct reference

    • JtaTransactionManager

      public JtaTransactionManager(jakarta.transaction.UserTransaction userTransaction, jakarta.transaction.TransactionManager transactionManager)
      Create a new JtaTransactionManager instance.
      Parameters:
      userTransaction - the JTA UserTransaction to use as direct reference
      transactionManager - the JTA TransactionManager to use as direct reference

    • JtaTransactionManager

      public JtaTransactionManager(jakarta.transaction.TransactionManager transactionManager)
      Create a new JtaTransactionManager instance.
      Parameters:
      transactionManager - the JTA TransactionManager to use as direct reference

  • Method Details

    • setJndiTemplate

      public void setJndiTemplate(JndiTemplate jndiTemplate)
      Set the JndiTemplate to use for JNDI lookups. A default one is used if not set.

    • getJndiTemplate

      public JndiTemplate getJndiTemplate()
      Return the JndiTemplate used for JNDI lookups.

    • setJndiEnvironment

      public void setJndiEnvironment(@Nullable Properties jndiEnvironment)
      Set the JNDI environment to use for JNDI lookups. Creates a JndiTemplate with the given environment settings.
      See Also:

    • getJndiEnvironment

      public @Nullable Properties getJndiEnvironment()
      Return the JNDI environment to use for JNDI lookups.

    • setUserTransaction

      public void setUserTransaction(@Nullable jakarta.transaction.UserTransaction userTransaction)
      Set the JTA UserTransaction to use as direct reference.

      Typically just used for local JTA setups; in a Jakarta EE environment, the UserTransaction will always be fetched from JNDI.

      See Also:

    • getUserTransaction

      public @Nullable jakarta.transaction.UserTransaction getUserTransaction()
      Return the JTA UserTransaction that this transaction manager uses.

    • setUserTransactionName

      public void setUserTransactionName(String userTransactionName)
      Set the JNDI name of the JTA UserTransaction.

      Note that the UserTransaction will be autodetected at the Jakarta EE default location "java:comp/UserTransaction" if not specified explicitly.

      See Also:

    • setAutodetectUserTransaction

      public void setAutodetectUserTransaction(boolean autodetectUserTransaction)
      Set whether to autodetect the JTA UserTransaction at its default JNDI location "java:comp/UserTransaction", as specified by Jakarta EE. Will proceed without UserTransaction if none found.

      Default is "true", autodetecting the UserTransaction unless it has been specified explicitly. Turn this flag off to allow for JtaTransactionManager operating against the TransactionManager only, despite a default UserTransaction being available.

      See Also:

    • setCacheUserTransaction

      public void setCacheUserTransaction(boolean cacheUserTransaction)
      Set whether to cache the JTA UserTransaction object fetched from JNDI.

      Default is "true": UserTransaction lookup will only happen at startup, reusing the same UserTransaction handle for all transactions of all threads. This is the most efficient choice for all application servers that provide a shared UserTransaction object (the typical case).

      Turn this flag off to enforce a fresh lookup of the UserTransaction for every transaction. This is only necessary for application servers that return a new UserTransaction for every transaction, keeping state tied to the UserTransaction object itself rather than the current thread.

      See Also:

    • setTransactionManager

      public void setTransactionManager(@Nullable jakarta.transaction.TransactionManager transactionManager)
      Set the JTA TransactionManager to use as direct reference.

      A TransactionManager is necessary for suspending and resuming transactions, as this not supported by the UserTransaction interface.

      Note that the TransactionManager will be autodetected if the JTA UserTransaction object implements the JTA TransactionManager interface too, as well as autodetected at various well-known fallback JNDI locations.

      See Also:

    • getTransactionManager

      public @Nullable jakarta.transaction.TransactionManager getTransactionManager()
      Return the JTA TransactionManager that this transaction manager uses, if any.

    • setTransactionManagerName

      public void setTransactionManagerName(String transactionManagerName)
      Set the JNDI name of the JTA TransactionManager.

      A TransactionManager is necessary for suspending and resuming transactions, as this not supported by the UserTransaction interface.

      Note that the TransactionManager will be autodetected if the JTA UserTransaction object implements the JTA TransactionManager interface too, as well as autodetected at various well-known fallback JNDI locations.

      See Also:

    • setAutodetectTransactionManager

      public void setAutodetectTransactionManager(boolean autodetectTransactionManager)
      Set whether to autodetect a JTA UserTransaction object that implements the JTA TransactionManager interface too (i.e. the JNDI location for the TransactionManager is "java:comp/UserTransaction", same as for the UserTransaction). Also checks the fallback JNDI locations "java:comp/TransactionManager" and "java:/TransactionManager". Will proceed without TransactionManager if none found.

      Default is "true", autodetecting the TransactionManager unless it has been specified explicitly. Can be turned off to deliberately ignore an available TransactionManager, for example when there are known issues with suspend/resume and any attempt to use REQUIRES_NEW or NOT_SUPPORTED should fail fast.

      See Also:

    • setTransactionSynchronizationRegistry

      public void setTransactionSynchronizationRegistry(@Nullable jakarta.transaction.TransactionSynchronizationRegistry transactionSynchronizationRegistry)
      Set the JTA 1.1 TransactionSynchronizationRegistry to use as direct reference.

      A TransactionSynchronizationRegistry allows for interposed registration of transaction synchronizations, as an alternative to the regular registration methods on the JTA TransactionManager API. Also, it is an official part of the Jakarta EE platform, in contrast to the JTA TransactionManager itself.

      Note that the TransactionSynchronizationRegistry will be autodetected in JNDI and also from the UserTransaction/TransactionManager object if implemented there as well.

      See Also:

    • getTransactionSynchronizationRegistry

      public @Nullable jakarta.transaction.TransactionSynchronizationRegistry getTransactionSynchronizationRegistry()
      Return the JTA 1.1 TransactionSynchronizationRegistry that this transaction manager uses, if any.

    • setTransactionSynchronizationRegistryName

      public void setTransactionSynchronizationRegistryName(String transactionSynchronizationRegistryName)
      Set the JNDI name of the JTA 1.1 TransactionSynchronizationRegistry.

      Note that the TransactionSynchronizationRegistry will be autodetected at the Jakarta EE default location "java:comp/TransactionSynchronizationRegistry" if not specified explicitly.

      See Also:

    • setAutodetectTransactionSynchronizationRegistry

      public void setAutodetectTransactionSynchronizationRegistry(boolean autodetectTransactionSynchronizationRegistry)
      Set whether to autodetect a JTA 1.1 TransactionSynchronizationRegistry object at its default JDNI location ("java:comp/TransactionSynchronizationRegistry") if the UserTransaction has also been obtained from JNDI, and also whether to fall back to checking whether the JTA UserTransaction/TransactionManager object implements the JTA TransactionSynchronizationRegistry interface too.

      Default is "true", autodetecting the TransactionSynchronizationRegistry unless it has been specified explicitly. Can be turned off to delegate synchronization registration to the regular JTA TransactionManager API.

    • setAllowCustomIsolationLevels

      public void setAllowCustomIsolationLevels(boolean allowCustomIsolationLevels)
      Set whether to allow custom isolation levels to be specified.

      Default is "false", throwing an exception if a non-default isolation level is specified for a transaction. Turn this flag on if affected resource adapters check the thread-bound transaction context and apply the specified isolation levels individually (for example, through an IsolationLevelDataSourceAdapter).

      See Also:

    • afterPropertiesSet

      public void afterPropertiesSet() throws TransactionSystemException
      Initialize the UserTransaction as well as the TransactionManager handle.
      Specified by:
      afterPropertiesSet in interface InitializingBean
      Throws:
      TransactionSystemException
      See Also:

    • initUserTransactionAndTransactionManager

      protected void initUserTransactionAndTransactionManager() throws TransactionSystemException
      Initialize the UserTransaction as well as the TransactionManager handle.
      Throws:
      TransactionSystemException - if initialization failed

    • checkUserTransactionAndTransactionManager

      protected void checkUserTransactionAndTransactionManager() throws IllegalStateException
      Check the UserTransaction as well as the TransactionManager handle, assuming standard JTA requirements.
      Throws:
      IllegalStateException - if no sufficient handles are available

    • initTransactionSynchronizationRegistry

      protected void initTransactionSynchronizationRegistry()
      Initialize the JTA 1.1 TransactionSynchronizationRegistry, if available.

      To be called after initUserTransactionAndTransactionManager(), since it may check the UserTransaction and TransactionManager handles.

      Throws:
      TransactionSystemException - if initialization failed

    • buildUserTransaction

      protected jakarta.transaction.UserTransaction buildUserTransaction(jakarta.transaction.TransactionManager transactionManager)
      Build a UserTransaction handle based on the given TransactionManager.
      Parameters:
      transactionManager - the TransactionManager
      Returns:
      a corresponding UserTransaction handle

    • lookupUserTransaction

      protected jakarta.transaction.UserTransaction lookupUserTransaction(String userTransactionName) throws TransactionSystemException
      Look up the JTA UserTransaction in JNDI via the configured name.

      Called by afterPropertiesSet if no direct UserTransaction reference was set. Can be overridden in subclasses to provide a different UserTransaction object.

      Parameters:
      userTransactionName - the JNDI name of the UserTransaction
      Returns:
      the UserTransaction object
      Throws:
      TransactionSystemException - if the JNDI lookup failed
      See Also:

    • lookupTransactionManager

      protected jakarta.transaction.TransactionManager lookupTransactionManager(String transactionManagerName) throws TransactionSystemException
      Look up the JTA TransactionManager in JNDI via the configured name.

      Called by afterPropertiesSet if no direct TransactionManager reference was set. Can be overridden in subclasses to provide a different TransactionManager object.

      Parameters:
      transactionManagerName - the JNDI name of the TransactionManager
      Returns:
      the UserTransaction object
      Throws:
      TransactionSystemException - if the JNDI lookup failed
      See Also:

    • lookupTransactionSynchronizationRegistry

      protected jakarta.transaction.TransactionSynchronizationRegistry lookupTransactionSynchronizationRegistry(String registryName) throws TransactionSystemException
      Look up the JTA 1.1 TransactionSynchronizationRegistry in JNDI via the configured name.

      Can be overridden in subclasses to provide a different TransactionManager object.

      Parameters:
      registryName - the JNDI name of the TransactionSynchronizationRegistry
      Returns:
      the TransactionSynchronizationRegistry object
      Throws:
      TransactionSystemException - if the JNDI lookup failed
      See Also:

    • retrieveUserTransaction

      protected @Nullable jakarta.transaction.UserTransaction retrieveUserTransaction() throws TransactionSystemException
      Allows subclasses to retrieve the JTA UserTransaction in a vendor-specific manner. Only called if no "userTransaction" or "userTransactionName" specified.

      The default implementation simply returns null.

      Returns:
      the JTA UserTransaction handle to use, or null if none found
      Throws:
      TransactionSystemException - in case of errors
      See Also:

    • retrieveTransactionManager

      protected @Nullable jakarta.transaction.TransactionManager retrieveTransactionManager() throws TransactionSystemException
      Allows subclasses to retrieve the JTA TransactionManager in a vendor-specific manner. Only called if no "transactionManager" or "transactionManagerName" specified.

      The default implementation simply returns null.

      Returns:
      the JTA TransactionManager handle to use, or null if none found
      Throws:
      TransactionSystemException - in case of errors
      See Also:

    • retrieveTransactionSynchronizationRegistry

      protected @Nullable jakarta.transaction.TransactionSynchronizationRegistry retrieveTransactionSynchronizationRegistry() throws TransactionSystemException
      Allows subclasses to retrieve the JTA 1.1 TransactionSynchronizationRegistry in a vendor-specific manner.

      The default implementation simply returns null.

      Returns:
      the JTA TransactionSynchronizationRegistry handle to use, or null if none found
      Throws:
      TransactionSystemException - in case of errors

    • findUserTransaction

      protected @Nullable jakarta.transaction.UserTransaction findUserTransaction()
      Find the JTA UserTransaction through a default JNDI lookup: "java:comp/UserTransaction".
      Returns:
      the JTA UserTransaction reference, or null if not found
      See Also:

    • findTransactionManager

      protected @Nullable jakarta.transaction.TransactionManager findTransactionManager(@Nullable jakarta.transaction.UserTransaction ut)
      Find the JTA TransactionManager through autodetection: checking whether the UserTransaction object implements the TransactionManager, and checking the fallback JNDI locations.
      Parameters:
      ut - the JTA UserTransaction object
      Returns:
      the JTA TransactionManager reference, or null if not found
      See Also:

    • findTransactionSynchronizationRegistry

      protected @Nullable jakarta.transaction.TransactionSynchronizationRegistry findTransactionSynchronizationRegistry(@Nullable jakarta.transaction.UserTransaction ut, @Nullable jakarta.transaction.TransactionManager tm) throws TransactionSystemException
      Find the JTA 1.1 TransactionSynchronizationRegistry through autodetection: checking whether the UserTransaction object or TransactionManager object implements it, and checking Jakarta EE's standard JNDI location.

      The default implementation simply returns null.

      Parameters:
      ut - the JTA UserTransaction object
      tm - the JTA TransactionManager object
      Returns:
      the JTA TransactionSynchronizationRegistry handle to use, or null if none found
      Throws:
      TransactionSystemException - in case of errors

    • doGetTransaction

      protected Object doGetTransaction()
      This implementation returns a JtaTransactionObject instance for the JTA UserTransaction.

      The UserTransaction object will either be looked up freshly for the current transaction, or the cached one looked up at startup will be used. The latter is the default: Most application servers use a shared singleton UserTransaction that can be cached. Turn off the "cacheUserTransaction" flag to enforce a fresh lookup for every transaction.

      Specified by:
      doGetTransaction in class AbstractPlatformTransactionManager
      Returns:
      the current transaction object
      See Also:

    • doGetJtaTransaction

      protected JtaTransactionObject doGetJtaTransaction(jakarta.transaction.UserTransaction ut)
      Get a JTA transaction object for the given current UserTransaction.

      Subclasses can override this to provide a JtaTransactionObject subclass, for example holding some additional JTA handle needed.

      Parameters:
      ut - the UserTransaction handle to use for the current transaction
      Returns:
      the JtaTransactionObject holding the UserTransaction

    • isExistingTransaction

      protected boolean isExistingTransaction(Object transaction)
      Description copied from class: AbstractPlatformTransactionManager
      Check if the given transaction object indicates an existing transaction (that is, a transaction which has already started).

      The result will be evaluated according to the specified propagation behavior for the new transaction. An existing transaction might get suspended (in case of PROPAGATION_REQUIRES_NEW), or the new transaction might participate in the existing one (in case of PROPAGATION_REQUIRED).

      The default implementation returns false, assuming that participating in existing transactions is generally not supported. Subclasses are of course encouraged to provide such support.

      Overrides:
      isExistingTransaction in class AbstractPlatformTransactionManager
      Parameters:
      transaction - the transaction object returned by doGetTransaction
      Returns:
      if there is an existing transaction
      See Also:

    • useSavepointForNestedTransaction

      protected boolean useSavepointForNestedTransaction()
      This implementation returns false to cause a further invocation of doBegin despite an already existing transaction.

      JTA implementations might support nested transactions via further UserTransaction.begin() invocations, but never support savepoints.

      Overrides:
      useSavepointForNestedTransaction in class AbstractPlatformTransactionManager
      See Also:

    • doBegin

      protected void doBegin(Object transaction, TransactionDefinition definition)
      Description copied from class: AbstractPlatformTransactionManager
      Begin a new transaction with semantics according to the given transaction definition. Does not have to care about applying the propagation behavior, as this has already been handled by this abstract manager.

      This method gets called when the transaction manager has decided to actually start a new transaction. Either there wasn't any transaction before, or the previous transaction has been suspended.

      A special scenario is a nested transaction without savepoint: If useSavepointForNestedTransaction() returns "false", this method will be called to start a nested transaction when necessary. In such a context, there will be an active transaction: The implementation of this method has to detect this and start an appropriate nested transaction.

      Specified by:
      doBegin in class AbstractPlatformTransactionManager
      Parameters:
      transaction - the transaction object returned by doGetTransaction
      definition - a TransactionDefinition instance, describing propagation behavior, isolation level, read-only flag, timeout, and transaction name

    • doJtaBegin

      protected void doJtaBegin(JtaTransactionObject txObject, TransactionDefinition definition) throws jakarta.transaction.NotSupportedException, jakarta.transaction.SystemException
      Perform a JTA begin on the JTA UserTransaction or TransactionManager.

      This implementation only supports standard JTA functionality: that is, no per-transaction isolation levels and no transaction names. Can be overridden in subclasses, for specific JTA implementations.

      Calls applyIsolationLevel and applyTimeout before invoking the UserTransaction's begin method.

      Parameters:
      txObject - the JtaTransactionObject containing the UserTransaction
      definition - the TransactionDefinition instance, describing propagation behavior, isolation level, read-only flag, timeout, and transaction name
      Throws:
      jakarta.transaction.NotSupportedException - if thrown by JTA methods
      jakarta.transaction.SystemException - if thrown by JTA methods
      See Also:

    • applyIsolationLevel

      protected void applyIsolationLevel(JtaTransactionObject txObject, int isolationLevel) throws InvalidIsolationLevelException, jakarta.transaction.SystemException
      Apply the given transaction isolation level. The default implementation will throw an exception for any level other than ISOLATION_DEFAULT.

      To be overridden in subclasses for specific JTA implementations, as alternative to overriding the full doJtaBegin(JtaTransactionObject, TransactionDefinition) method.

      Parameters:
      txObject - the JtaTransactionObject containing the UserTransaction
      isolationLevel - isolation level taken from transaction definition
      Throws:
      InvalidIsolationLevelException - if the given isolation level cannot be applied
      jakarta.transaction.SystemException - if thrown by the JTA implementation
      See Also:

    • applyTimeout

      protected void applyTimeout(JtaTransactionObject txObject, int timeout) throws jakarta.transaction.SystemException
      Apply the given transaction timeout. The default implementation will call UserTransaction.setTransactionTimeout for a non-default timeout value.
      Parameters:
      txObject - the JtaTransactionObject containing the UserTransaction
      timeout - the timeout value taken from transaction definition
      Throws:
      jakarta.transaction.SystemException - if thrown by the JTA implementation
      See Also:

    • doSuspend

      protected Object doSuspend(Object transaction)
      Description copied from class: AbstractPlatformTransactionManager
      Suspend the resources of the current transaction. Transaction synchronization will already have been suspended.

      The default implementation throws a TransactionSuspensionNotSupportedException, assuming that transaction suspension is generally not supported.

      Overrides:
      doSuspend in class AbstractPlatformTransactionManager
      Parameters:
      transaction - the transaction object returned by doGetTransaction
      Returns:
      an object that holds suspended resources (will be kept unexamined for passing it into doResume)
      See Also:

    • doJtaSuspend

      protected Object doJtaSuspend(JtaTransactionObject txObject) throws jakarta.transaction.SystemException
      Perform a JTA suspend on the JTA TransactionManager.

      Can be overridden in subclasses, for specific JTA implementations.

      Parameters:
      txObject - the JtaTransactionObject containing the UserTransaction
      Returns:
      the suspended JTA Transaction object
      Throws:
      jakarta.transaction.SystemException - if thrown by JTA methods
      See Also:

    • doResume

      protected void doResume(@Nullable Object transaction, Object suspendedResources)
      Description copied from class: AbstractPlatformTransactionManager
      Resume the resources of the current transaction. Transaction synchronization will be resumed afterwards.

      The default implementation throws a TransactionSuspensionNotSupportedException, assuming that transaction suspension is generally not supported.

      Overrides:
      doResume in class AbstractPlatformTransactionManager
      Parameters:
      transaction - the transaction object returned by doGetTransaction
      suspendedResources - the object that holds suspended resources, as returned by doSuspend
      See Also:

    • doJtaResume

      protected void doJtaResume(@Nullable JtaTransactionObject txObject, Object suspendedTransaction) throws jakarta.transaction.InvalidTransactionException, jakarta.transaction.SystemException
      Perform a JTA resume on the JTA TransactionManager.

      Can be overridden in subclasses, for specific JTA implementations.

      Parameters:
      txObject - the JtaTransactionObject containing the UserTransaction
      suspendedTransaction - the suspended JTA Transaction object
      Throws:
      jakarta.transaction.InvalidTransactionException - if thrown by JTA methods
      jakarta.transaction.SystemException - if thrown by JTA methods
      See Also:

    • shouldCommitOnGlobalRollbackOnly

      protected boolean shouldCommitOnGlobalRollbackOnly()
      This implementation returns "true": a JTA commit will properly handle transactions that have been marked rollback-only at a global level.
      Overrides:
      shouldCommitOnGlobalRollbackOnly in class AbstractPlatformTransactionManager
      See Also:

    • doCommit

      protected void doCommit(DefaultTransactionStatus status)
      Description copied from class: AbstractPlatformTransactionManager
      Perform an actual commit of the given transaction.

      An implementation does not need to check the "new transaction" flag or the rollback-only flag; this will already have been handled before. Usually, a straight commit will be performed on the transaction object contained in the passed-in status.

      Specified by:
      doCommit in class AbstractPlatformTransactionManager
      Parameters:
      status - the status representation of the transaction
      See Also:

    • doRollback

      protected void doRollback(DefaultTransactionStatus status)
      Description copied from class: AbstractPlatformTransactionManager
      Perform an actual rollback of the given transaction.

      An implementation does not need to check the "new transaction" flag; this will already have been handled before. Usually, a straight rollback will be performed on the transaction object contained in the passed-in status.

      Specified by:
      doRollback in class AbstractPlatformTransactionManager
      Parameters:
      status - the status representation of the transaction
      See Also:

    • doSetRollbackOnly

      protected void doSetRollbackOnly(DefaultTransactionStatus status)
      Description copied from class: AbstractPlatformTransactionManager
      Set the given transaction rollback-only. Only called on rollback if the current transaction participates in an existing one.

      The default implementation throws an IllegalTransactionStateException, assuming that participating in existing transactions is generally not supported. Subclasses are of course encouraged to provide such support.

      Overrides:
      doSetRollbackOnly in class AbstractPlatformTransactionManager
      Parameters:
      status - the status representation of the transaction

    • registerAfterCompletionWithExistingTransaction

      protected void registerAfterCompletionWithExistingTransaction(Object transaction, List<TransactionSynchronization> synchronizations)
      Description copied from class: AbstractPlatformTransactionManager
      Register the given list of transaction synchronizations with the existing transaction.

      Invoked when the control of the Spring transaction manager and thus all Spring transaction synchronizations end, without the transaction being completed yet. This is for example the case when participating in an existing JTA or EJB CMT transaction.

      The default implementation simply invokes the afterCompletion methods immediately, passing in "STATUS_UNKNOWN". This is the best we can do if there's no chance to determine the actual outcome of the outer transaction.

      Overrides:
      registerAfterCompletionWithExistingTransaction in class AbstractPlatformTransactionManager
      Parameters:
      transaction - the transaction object returned by doGetTransaction
      synchronizations - a List of TransactionSynchronization objects
      See Also:

    • doRegisterAfterCompletionWithJtaTransaction

      protected void doRegisterAfterCompletionWithJtaTransaction(JtaTransactionObject txObject, List<TransactionSynchronization> synchronizations) throws jakarta.transaction.RollbackException, jakarta.transaction.SystemException
      Register a JTA synchronization on the JTA TransactionManager, for calling afterCompletion on the given Spring TransactionSynchronizations.

      The default implementation registers the synchronizations on the JTA 1.1 TransactionSynchronizationRegistry, if available, or on the JTA TransactionManager's current Transaction - again, if available. If none of the two is available, a warning will be logged.

      Can be overridden in subclasses, for specific JTA implementations.

      Parameters:
      txObject - the current transaction object
      synchronizations - a List of TransactionSynchronization objects
      Throws:
      jakarta.transaction.RollbackException - if thrown by JTA methods
      jakarta.transaction.SystemException - if thrown by JTA methods
      See Also:
      • getTransactionManager()
      • Transaction.registerSynchronization(Synchronization)
      • TransactionSynchronizationRegistry.registerInterposedSynchronization(Synchronization)

    • doCleanupAfterCompletion

      protected void doCleanupAfterCompletion(Object transaction)
      Description copied from class: AbstractPlatformTransactionManager
      Cleanup resources after transaction completion.

      Called after doCommit and doRollback execution, on any outcome. The default implementation does nothing.

      Should not throw any exceptions but just issue warnings on errors.

      Overrides:
      doCleanupAfterCompletion in class AbstractPlatformTransactionManager
      Parameters:
      transaction - the transaction object returned by doGetTransaction

    • createTransaction

      public jakarta.transaction.Transaction createTransaction(@Nullable String name, int timeout) throws jakarta.transaction.NotSupportedException, jakarta.transaction.SystemException
      Description copied from interface: TransactionFactory
      Create an active Transaction object based on the given name and timeout.
      Specified by:
      createTransaction in interface TransactionFactory
      Parameters:
      name - the transaction name (may be null)
      timeout - the transaction timeout (may be -1 for the default timeout)
      Returns:
      the active Transaction object (never null)
      Throws:
      jakarta.transaction.NotSupportedException - if the transaction manager does not support a transaction of the specified type
      jakarta.transaction.SystemException - if the transaction manager failed to create the transaction

    • supportsResourceAdapterManagedTransactions

      public boolean supportsResourceAdapterManagedTransactions()
      Description copied from interface: TransactionFactory
      Determine whether the underlying transaction manager supports XA transactions managed by a resource adapter (i.e. without explicit XA resource enlistment).

      Typically false. Checked by AbstractMessageEndpointFactory in order to differentiate between invalid configuration and valid ResourceAdapter-managed transactions.

      Specified by:
      supportsResourceAdapterManagedTransactions in interface TransactionFactory
      See Also:
      • ResourceAdapter.endpointActivation(MessageEndpointFactory, ActivationSpec)
      • MessageEndpointFactory.isDeliveryTransacted(Method)