Class SpringAwareUserTransaction

  • All Implemented Interfaces:
    javax.transaction.UserTransaction, org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanFactoryAware, org.springframework.beans.factory.InitializingBean, org.springframework.transaction.interceptor.TransactionAttribute, org.springframework.transaction.interceptor.TransactionAttributeSource, org.springframework.transaction.TransactionDefinition

    public class SpringAwareUserTransaction
    extends org.springframework.transaction.interceptor.TransactionAspectSupport
    implements javax.transaction.UserTransaction, org.springframework.transaction.interceptor.TransactionAttributeSource, org.springframework.transaction.interceptor.TransactionAttribute
    A UserTransaction that will allow the thread using it to participate in transactions that are normally only begun and committed by the SpringFramework transaction aware components.

    Client code can use this class directly, but should be very careful to handle the exception conditions with the appropriate finally blocks and rollback code. It is recommended that clients use this class indirectly via an instance of the org.alfresco.repo.transaction.RetryingTransactionHelper.

    This class is thread-safe in that it will detect multithreaded access and throw exceptions. Therefore do not use on multiple threads. Instances should be used only for the duration of the required user transaction and then discarded. Any attempt to reuse an instance will result in failure.

    Nested user transaction are allowed.

    Logging:
    To dump exceptions during commits, turn debugging on for this class.
    To log leaked transactions i.e. a begin() is not matched by a commit() or rollback(), add .trace to the usual classname-based debug category and set to WARN log level. This will log the first detection of a leaked transaction and automatically enable transaction call stack logging for subsequent leaked transactions. To enforce call stack logging from the start set the .trace log level to DEBUG. Call stack logging will hamper performance but is useful when it appears that something is eating connections or holding onto resources - usually a sign that client code hasn't handled all possible exception conditions.

    Author:
    Derek Hulley
    See Also:
    PlatformTransactionManager, DefaultTransactionDefinition
    • Nested Class Summary

      • Nested classes/interfaces inherited from class org.springframework.transaction.interceptor.TransactionAspectSupport

        org.springframework.transaction.interceptor.TransactionAspectSupport.InvocationCallback, org.springframework.transaction.interceptor.TransactionAspectSupport.TransactionInfo
    • Field Summary

      • Fields inherited from interface org.springframework.transaction.TransactionDefinition

        ISOLATION_DEFAULT, ISOLATION_READ_COMMITTED, ISOLATION_READ_UNCOMMITTED, ISOLATION_REPEATABLE_READ, ISOLATION_SERIALIZABLE, PROPAGATION_MANDATORY, PROPAGATION_NESTED, PROPAGATION_NEVER, PROPAGATION_NOT_SUPPORTED, PROPAGATION_REQUIRED, PROPAGATION_REQUIRES_NEW, PROPAGATION_SUPPORTS, TIMEOUT_DEFAULT
    • Constructor Summary

      Constructors 
      Constructor Description
      SpringAwareUserTransaction​(org.springframework.transaction.PlatformTransactionManager transactionManager, boolean readOnly, int isolationLevel, int propagationBehaviour, int timeout)
      Creates a user transaction that defaults to TransactionDefinition.PROPAGATION_REQUIRED.
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void begin()  
      void commit()  
      protected void completeTransactionAfterThrowing​(org.springframework.transaction.interceptor.TransactionAspectSupport.TransactionInfo txInfo, java.lang.Throwable ex)  
      protected void finalize()  
      int getIsolationLevel()  
      java.lang.String getName()  
      int getPropagationBehavior()  
      java.lang.String getQualifier()
      Return a qualifier value associated with this transaction attribute.
      int getStatus()
      This status is a combination of the internal status, as recorded during explicit operations, and the status provided by the Spring support.
      int getTimeout()  
      org.springframework.transaction.interceptor.TransactionAttribute getTransactionAttribute​(java.lang.reflect.Method method, java.lang.Class<?> targetClass)
      This class carries all the information required to fullfil requests about the transaction attributes.
      boolean isReadOnly()  
      void rollback()  
      boolean rollbackOn​(java.lang.Throwable ex)
      The UserTransaction must rollback regardless of the error.
      void setRollbackOnly()  
      void setTransactionTimeout​(int timeout)
      Implementation required for UserTransaction.
      java.lang.String toString()  
      • Methods inherited from class org.springframework.transaction.interceptor.TransactionAspectSupport

        afterPropertiesSet, cleanupTransactionInfo, clearTransactionManagerCache, commitTransactionAfterReturning, createTransactionIfNecessary, currentTransactionInfo, currentTransactionStatus, determineTransactionManager, getBeanFactory, getTransactionAttributeSource, getTransactionManager, getTransactionManagerBeanName, invokeWithinTransaction, methodIdentification, prepareTransactionInfo, setBeanFactory, setTransactionAttributes, setTransactionAttributeSource, setTransactionAttributeSources, setTransactionManager, setTransactionManagerBeanName
      • Methods inherited from class java.lang.Object

        clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
    • Constructor Detail

      • SpringAwareUserTransaction

        public SpringAwareUserTransaction​(org.springframework.transaction.PlatformTransactionManager transactionManager,
                                          boolean readOnly,
                                          int isolationLevel,
                                          int propagationBehaviour,
                                          int timeout)
        Creates a user transaction that defaults to TransactionDefinition.PROPAGATION_REQUIRED.
        Parameters:
        transactionManager - the transaction manager to use
        readOnly - true to force a read-only transaction
        isolationLevel - one of the TransactionDefinition.ISOLATION_XXX constants
        propagationBehaviour - one of the TransactionDefinition.PROPAGATION__XXX constants
        timeout - the transaction timeout in seconds.
        See Also:
        TransactionDefinition.getTimeout()
    • Method Detail

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object
      • getTransactionAttribute

        public org.springframework.transaction.interceptor.TransactionAttribute getTransactionAttribute​(java.lang.reflect.Method method,
                                                                                                        java.lang.Class<?> targetClass)
        This class carries all the information required to fullfil requests about the transaction attributes. It acts as a source of the transaction attributes.
        Specified by:
        getTransactionAttribute in interface org.springframework.transaction.interceptor.TransactionAttributeSource
        Returns:
        Return this instance
      • getQualifier

        public java.lang.String getQualifier()
        Return a qualifier value associated with this transaction attribute. This is not used as the transaction manager has been selected for us.
        Specified by:
        getQualifier in interface org.springframework.transaction.interceptor.TransactionAttribute
        Returns:
        null always
      • rollbackOn

        public boolean rollbackOn​(java.lang.Throwable ex)
        The UserTransaction must rollback regardless of the error. The rollback behaviour is implemented by simulating a caught exception. As this method will always return true, the rollback behaviour will be to rollback the transaction or mark it for rollback.
        Specified by:
        rollbackOn in interface org.springframework.transaction.interceptor.TransactionAttribute
        Returns:
        Returns true always
      • getName

        public java.lang.String getName()
        Specified by:
        getName in interface org.springframework.transaction.TransactionDefinition
      • isReadOnly

        public boolean isReadOnly()
        Specified by:
        isReadOnly in interface org.springframework.transaction.TransactionDefinition
      • getIsolationLevel

        public int getIsolationLevel()
        Specified by:
        getIsolationLevel in interface org.springframework.transaction.TransactionDefinition
      • getPropagationBehavior

        public int getPropagationBehavior()
        Specified by:
        getPropagationBehavior in interface org.springframework.transaction.TransactionDefinition
      • getTimeout

        public int getTimeout()
        Specified by:
        getTimeout in interface org.springframework.transaction.TransactionDefinition
      • setTransactionTimeout

        public void setTransactionTimeout​(int timeout)
                                   throws javax.transaction.SystemException
        Implementation required for UserTransaction.
        Specified by:
        setTransactionTimeout in interface javax.transaction.UserTransaction
        Throws:
        javax.transaction.SystemException
      • getStatus

        public int getStatus()
                      throws javax.transaction.SystemException
        This status is a combination of the internal status, as recorded during explicit operations, and the status provided by the Spring support.
        Specified by:
        getStatus in interface javax.transaction.UserTransaction
        Throws:
        javax.transaction.SystemException
        See Also:
        Status
      • setRollbackOnly

        public void setRollbackOnly()
                             throws java.lang.IllegalStateException,
                                    javax.transaction.SystemException
        Specified by:
        setRollbackOnly in interface javax.transaction.UserTransaction
        Throws:
        java.lang.IllegalStateException
        javax.transaction.SystemException
      • begin

        public void begin()
                   throws javax.transaction.NotSupportedException,
                          javax.transaction.SystemException
        Specified by:
        begin in interface javax.transaction.UserTransaction
        Throws:
        javax.transaction.NotSupportedException - if an attempt is made to reuse this instance
        javax.transaction.SystemException
      • commit

        public void commit()
                    throws javax.transaction.RollbackException,
                           javax.transaction.HeuristicMixedException,
                           javax.transaction.HeuristicRollbackException,
                           java.lang.SecurityException,
                           java.lang.IllegalStateException,
                           javax.transaction.SystemException
        Specified by:
        commit in interface javax.transaction.UserTransaction
        Throws:
        java.lang.IllegalStateException - if a transaction was not started
        javax.transaction.RollbackException
        javax.transaction.HeuristicMixedException
        javax.transaction.HeuristicRollbackException
        java.lang.SecurityException
        javax.transaction.SystemException
      • rollback

        public void rollback()
                      throws java.lang.IllegalStateException,
                             java.lang.SecurityException,
                             javax.transaction.SystemException
        Specified by:
        rollback in interface javax.transaction.UserTransaction
        Throws:
        java.lang.IllegalStateException
        java.lang.SecurityException
        javax.transaction.SystemException
      • completeTransactionAfterThrowing

        protected void completeTransactionAfterThrowing​(org.springframework.transaction.interceptor.TransactionAspectSupport.TransactionInfo txInfo,
                                                        java.lang.Throwable ex)
        Overrides:
        completeTransactionAfterThrowing in class org.springframework.transaction.interceptor.TransactionAspectSupport
      • finalize

        protected void finalize()
                         throws java.lang.Throwable
        Overrides:
        finalize in class java.lang.Object
        Throws:
        java.lang.Throwable