org.springframework.transaction.interceptor

## Class TransactionAspectSupport

- java.lang.Object
- - org.springframework.transaction.interceptor.TransactionAspectSupport

- All Implemented Interfaces:
    Aware, BeanFactoryAware, InitializingBean
  Direct Known Subclasses:
    TransactionInterceptor

      public abstract class TransactionAspectSupport
      extends Object
      implements BeanFactoryAware, InitializingBean

  Base class for transactional aspects, such as the `TransactionInterceptor` or an AspectJ aspect.

  This enables the underlying Spring transaction infrastructure to be used easily to implement an aspect for any aspect system.

  Subclasses are responsible for calling methods in this class in the correct order.

  If no transaction name has been specified in the `TransactionAttribute`, the exposed name will be the `fully-qualified class name + "." + method name` (by default).

  Uses the Strategy design pattern. A `PlatformTransactionManager` implementation will perform the actual transaction management, and a `TransactionAttributeSource` is used for determining transaction definitions.

  A transaction aspect is serializable if its `PlatformTransactionManager` and `TransactionAttributeSource` are serializable.

  Since:
    1.1
  Author:
    Rod Johnson, Juergen Hoeller
  See Also:
    `setTransactionManager(org.springframework.transaction.PlatformTransactionManager)`, `setTransactionAttributes(java.util.Properties)`, `setTransactionAttributeSource(org.springframework.transaction.interceptor.TransactionAttributeSource)`

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected static interface` | `TransactionAspectSupport.InvocationCallback` Simple callback interface for proceeding with the target invocation.
    `protected class` | `TransactionAspectSupport.TransactionInfo` Opaque object used to hold Transaction information.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TransactionAspectSupport()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterPropertiesSet()` Check that required properties were set.
    `protected void` | `cleanupTransactionInfo(TransactionAspectSupport.TransactionInfo txInfo)` Reset the TransactionInfo ThreadLocal.
    `protected void` | `commitTransactionAfterReturning(TransactionAspectSupport.TransactionInfo txInfo)` Execute after successful completion of call, but not after an exception was handled.
    `protected void` | `completeTransactionAfterThrowing(TransactionAspectSupport.TransactionInfo txInfo, Throwable ex)` Handle a throwable, completing the transaction.
    `protected TransactionAspectSupport.TransactionInfo` | `createTransactionIfNecessary(Method method, Class targetClass)` Deprecated. in favor of `createTransactionIfNecessary(PlatformTransactionManager, TransactionAttribute, String)`
    `protected TransactionAspectSupport.TransactionInfo` | `createTransactionIfNecessary(PlatformTransactionManager tm, TransactionAttribute txAttr, String joinpointIdentification)` Create a transaction if necessary based on the given TransactionAttribute.
    `protected static TransactionAspectSupport.TransactionInfo` | `currentTransactionInfo()` Subclasses can use this to return the current TransactionInfo.
    `static TransactionStatus` | `currentTransactionStatus()` Return the transaction status of the current method invocation.
    `protected PlatformTransactionManager` | `determineTransactionManager(TransactionAttribute txAttr)` Determine the specific transaction manager to use for the given transaction.
    `protected BeanFactory` | `getBeanFactory()` Return the BeanFactory to use for retrieving PlatformTransactionManager beans.
    `TransactionAttributeSource` | `getTransactionAttributeSource()` Return the transaction attribute source.
    `PlatformTransactionManager` | `getTransactionManager()` Return the transaction manager, if specified.
    `protected String` | `getTransactionManagerBeanName()` Return the name of the default transaction manager bean.
    `protected Object` | `invokeWithinTransaction(Method method, Class targetClass, TransactionAspectSupport.InvocationCallback invocation)` General delegate for around-advice-based subclasses, delegating to several other template methods on this class.
    `protected String` | `methodIdentification(Method method)` Deprecated. in favor of `methodIdentification(Method, Class)`
    `protected String` | `methodIdentification(Method method, Class targetClass)` Convenience method to return a String representation of this Method for use in logging.
    `protected TransactionAspectSupport.TransactionInfo` | `prepareTransactionInfo(PlatformTransactionManager tm, TransactionAttribute txAttr, String joinpointIdentification, TransactionStatus status)` Prepare a TransactionInfo for the given attribute and status object.
    `void` | `setBeanFactory(BeanFactory beanFactory)` Set the BeanFactory to use for retrieving PlatformTransactionManager beans.
    `void` | `setTransactionAttributes(Properties transactionAttributes)` Set properties with method names as keys and transaction attribute descriptors (parsed via TransactionAttributeEditor) as values: e.g.
    `void` | `setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource)` Set the transaction attribute source which is used to find transaction attributes.
    `void` | `setTransactionAttributeSources(TransactionAttributeSource[] transactionAttributeSources)` Set multiple transaction attribute sources which are used to find transaction attributes.
    `void` | `setTransactionManager(PlatformTransactionManager transactionManager)` Specify the target transaction manager.
    `void` | `setTransactionManagerBeanName(String transactionManagerBeanName)` Specify the name of the default transaction manager bean.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### logger

          protected final Log logger

  - ### Constructor Detail

    - #### TransactionAspectSupport

          public TransactionAspectSupport()

  - ### Method Detail

    - #### currentTransactionInfo

          protected static TransactionAspectSupport.TransactionInfo currentTransactionInfo()
                                                                                    throws NoTransactionException

      Subclasses can use this to return the current TransactionInfo. Only subclasses that cannot handle all operations in one method, such as an AspectJ aspect involving distinct before and after advice, need to use this mechanism to get at the current TransactionInfo. An around advice such as an AOP Alliance MethodInterceptor can hold a reference to the TransactionInfo throughout the aspect method.

      A TransactionInfo will be returned even if no transaction was created. The `TransactionInfo.hasTransaction()` method can be used to query this.

      To find out about specific transaction characteristics, consider using TransactionSynchronizationManager's `isSynchronizationActive()` and/or `isActualTransactionActive()` methods.

      Returns:
        TransactionInfo bound to this thread, or `null` if none
      Throws:
        `NoTransactionException`
      See Also:
        `TransactionAspectSupport.TransactionInfo.hasTransaction()`, `TransactionSynchronizationManager.isSynchronizationActive()`, `TransactionSynchronizationManager.isActualTransactionActive()`

    - #### currentTransactionStatus

          public static TransactionStatus currentTransactionStatus()
                                                            throws NoTransactionException

      Return the transaction status of the current method invocation. Mainly intended for code that wants to set the current transaction rollback-only but not throw an application exception.
      Throws:
        `NoTransactionException` - if the transaction info cannot be found, because the method was invoked outside an AOP invocation context

    - #### setTransactionManagerBeanName

          public void setTransactionManagerBeanName(String transactionManagerBeanName)

      Specify the name of the default transaction manager bean.

    - #### getTransactionManagerBeanName

          protected final String getTransactionManagerBeanName()

      Return the name of the default transaction manager bean.

    - #### setTransactionManager

          public void setTransactionManager(PlatformTransactionManager transactionManager)

      Specify the target transaction manager.

    - #### getTransactionManager

          public PlatformTransactionManager getTransactionManager()

      Return the transaction manager, if specified.

    - #### setTransactionAttributes

          public void setTransactionAttributes(Properties transactionAttributes)

      Set properties with method names as keys and transaction attribute descriptors (parsed via TransactionAttributeEditor) as values: e.g. key = "myMethod", value = "PROPAGATION_REQUIRED,readOnly".

      Note: Method names are always applied to the target class, no matter if defined in an interface or the class itself.

      Internally, a NameMatchTransactionAttributeSource will be created from the given properties.

      See Also:
        `setTransactionAttributeSource(org.springframework.transaction.interceptor.TransactionAttributeSource)`, `TransactionAttributeEditor`, `NameMatchTransactionAttributeSource`

    - #### setTransactionAttributeSources

          public void setTransactionAttributeSources(TransactionAttributeSource[] transactionAttributeSources)

      Set multiple transaction attribute sources which are used to find transaction attributes. Will build a CompositeTransactionAttributeSource for the given sources.
      See Also:
        `CompositeTransactionAttributeSource`, `MethodMapTransactionAttributeSource`, `NameMatchTransactionAttributeSource`, `AnnotationTransactionAttributeSource`

    - #### setTransactionAttributeSource

          public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource)

      Set the transaction attribute source which is used to find transaction attributes. If specifying a String property value, a PropertyEditor will create a MethodMapTransactionAttributeSource from the value.
      See Also:
        `TransactionAttributeSourceEditor`, `MethodMapTransactionAttributeSource`, `NameMatchTransactionAttributeSource`, `AnnotationTransactionAttributeSource`

    - #### getTransactionAttributeSource

          public TransactionAttributeSource getTransactionAttributeSource()

      Return the transaction attribute source.

    - #### setBeanFactory

          public void setBeanFactory(BeanFactory beanFactory)

      Set the BeanFactory to use for retrieving PlatformTransactionManager beans.
      Specified by:
        `setBeanFactory` in interface `BeanFactoryAware`
      Parameters:
        `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
      See Also:
        `BeanInitializationException`

    - #### getBeanFactory

          protected final BeanFactory getBeanFactory()

      Return the BeanFactory to use for retrieving PlatformTransactionManager beans.

    - #### afterPropertiesSet

          public void afterPropertiesSet()

      Check that required properties were set.
      Specified by:
        `afterPropertiesSet` in interface `InitializingBean`

    - #### invokeWithinTransaction

          protected Object invokeWithinTransaction(Method method,
                                       Class targetClass,
                                       TransactionAspectSupport.InvocationCallback invocation)
                                            throws Throwable

      General delegate for around-advice-based subclasses, delegating to several other template methods on this class. Able to handle `CallbackPreferringPlatformTransactionManager` as well as regular `PlatformTransactionManager` implementations.
      Parameters:
        `method` - the Method being invoked
        `targetClass` - the target class that we're invoking the method on
        `invocation` - the callback to use for proceeding with the target invocation
      Returns:
        the return value of the method, if any
      Throws:
        `Throwable` - propagated from the target invocation

    - #### determineTransactionManager

          protected PlatformTransactionManager determineTransactionManager(TransactionAttribute txAttr)

      Determine the specific transaction manager to use for the given transaction.

    - #### methodIdentification

          protected String methodIdentification(Method method,
                                    Class targetClass)

      Convenience method to return a String representation of this Method for use in logging. Can be overridden in subclasses to provide a different identifier for the given method.
      Parameters:
        `method` - the method we're interested in
        `targetClass` - the class that the method is being invoked on
      Returns:
        a String representation identifying this method
      See Also:
        `ClassUtils.getQualifiedMethodName(java.lang.reflect.Method)`

    - #### methodIdentification

          @Deprecated
          protected String methodIdentification(Method method)

      Deprecated. in favor of `methodIdentification(Method, Class)`
      Convenience method to return a String representation of this Method for use in logging. Can be overridden in subclasses to provide a different identifier for the given method.
      Parameters:
        `method` - the method we're interested in
      Returns:
        a String representation identifying this method

    - #### createTransactionIfNecessary

          @Deprecated
          protected TransactionAspectSupport.TransactionInfo createTransactionIfNecessary(Method method,
                                                                                         Class targetClass)

      Deprecated. in favor of `createTransactionIfNecessary(PlatformTransactionManager, TransactionAttribute, String)`
      Create a transaction if necessary, based on the given method and class.

      Performs a default TransactionAttribute lookup for the given method.

      Parameters:
        `method` - the method about to execute
        `targetClass` - the class that the method is being invoked on
      Returns:
        a TransactionInfo object, whether or not a transaction was created. The `hasTransaction()` method on TransactionInfo can be used to tell if there was a transaction created.
      See Also:
        `getTransactionAttributeSource()`

    - #### createTransactionIfNecessary

          protected TransactionAspectSupport.TransactionInfo createTransactionIfNecessary(PlatformTransactionManager tm,
                                                                              TransactionAttribute txAttr,
                                                                              String joinpointIdentification)

      Create a transaction if necessary based on the given TransactionAttribute.

      Allows callers to perform custom TransactionAttribute lookups through the TransactionAttributeSource.

      Parameters:
        `txAttr` - the TransactionAttribute (may be `null`)
        `joinpointIdentification` - the fully qualified method name (used for monitoring and logging purposes)
      Returns:
        a TransactionInfo object, whether or not a transaction was created. The `hasTransaction()` method on TransactionInfo can be used to tell if there was a transaction created.
      See Also:
        `getTransactionAttributeSource()`

    - #### prepareTransactionInfo

          protected TransactionAspectSupport.TransactionInfo prepareTransactionInfo(PlatformTransactionManager tm,
                                                                        TransactionAttribute txAttr,
                                                                        String joinpointIdentification,
                                                                        TransactionStatus status)

      Prepare a TransactionInfo for the given attribute and status object.
      Parameters:
        `txAttr` - the TransactionAttribute (may be `null`)
        `joinpointIdentification` - the fully qualified method name (used for monitoring and logging purposes)
        `status` - the TransactionStatus for the current transaction
      Returns:
        the prepared TransactionInfo object

    - #### commitTransactionAfterReturning

          protected void commitTransactionAfterReturning(TransactionAspectSupport.TransactionInfo txInfo)

      Execute after successful completion of call, but not after an exception was handled. Do nothing if we didn't create a transaction.
      Parameters:
        `txInfo` - information about the current transaction

    - #### completeTransactionAfterThrowing

          protected void completeTransactionAfterThrowing(TransactionAspectSupport.TransactionInfo txInfo,
                                              Throwable ex)

      Handle a throwable, completing the transaction. We may commit or roll back, depending on the configuration.
      Parameters:
        `txInfo` - information about the current transaction
        `ex` - throwable encountered

    - #### cleanupTransactionInfo

          protected void cleanupTransactionInfo(TransactionAspectSupport.TransactionInfo txInfo)

      Reset the TransactionInfo ThreadLocal.

      Call this in all cases: exception or normal return!

      Parameters:
        `txInfo` - information about the current transaction (may be `null`)