Package org.springframework.transaction.interceptor

# Class TransactionAspectSupport

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

All Implemented Interfaces:
  `org.springframework.beans.factory.Aware`, `org.springframework.beans.factory.BeanFactoryAware`, `org.springframework.beans.factory.InitializingBean`

Direct Known Subclasses:
  `TransactionInterceptor`

public abstract class TransactionAspectSupport extends Object implements org.springframework.beans.factory.BeanFactoryAware, org.springframework.beans.factory.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` or `ReactiveTransactionManager` implementation will perform the actual transaction management, and a `TransactionAttributeSource` (for example, annotation-based) is used for determining transaction definitions for a particular class or method.

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

Since:
  1.1
Author:
  Rod Johnson, Juergen Hoeller, Stéphane Nicoll, Sam Brannen, Mark Paluch, Sebastien Deleuze, Enric Sala
See Also:
  - `PlatformTransactionManager`
  - `ReactiveTransactionManager`
  - `setTransactionManager(org.springframework.transaction.TransactionManager)`
  - `setTransactionAttributes(java.util.Properties)`
  - `setTransactionAttributeSource(org.springframework.transaction.interceptor.TransactionAttributeSource)`

## Nested Class Summary

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

## Field Summary

Fields
Modifier and Type
Field
Description
`protected final org.apache.commons.logging.Log`
`logger`

## Constructor Summary

Constructors
Modifier
Constructor
Description
`protected`
`TransactionAspectSupport()`

## Method Summary

Modifier and Type
Method
Description
`void`
`afterPropertiesSet()`
Check that required properties were set.
`protected void`
`cleanupTransactionInfo(TransactionAspectSupport.TransactionInfo txInfo)`
Reset the TransactionInfo ThreadLocal.
`protected void`
`clearTransactionManagerCache()`
Clear the transaction manager cache.
`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(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 TransactionManager`
`determineTransactionManager(TransactionAttribute txAttr)`
Deprecated.
as of 6.2, in favor of `determineTransactionManager(TransactionAttribute, Class)`
`protected TransactionManager`
`determineTransactionManager(TransactionAttribute txAttr, Class<?> targetClass)`
Determine the specific transaction manager to use for the given transaction.
`protected final org.springframework.beans.factory.BeanFactory`
`getBeanFactory()`
Return the BeanFactory to use for retrieving `TransactionManager` beans.
`TransactionAttributeSource`
`getTransactionAttributeSource()`
Return the transaction attribute source.
`TransactionManager`
`getTransactionManager()`
Return the default transaction manager, or `null` if unknown.
`protected final 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, 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(org.springframework.beans.factory.BeanFactory beanFactory)`
Set the BeanFactory to use for retrieving `TransactionManager` beans.
`void`
`setTransactionAttributes(Properties transactionAttributes)`
Set properties with method names as keys and transaction attribute descriptors (parsed via TransactionAttributeEditor) as values: for example, key = "myMethod", value = "PROPAGATION_REQUIRED,readOnly".
`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(TransactionManager transactionManager)`
Specify the default transaction manager to use to drive transactions.
`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 Details

### logger

protected final org.apache.commons.logging.Log logger

## Constructor Details

### TransactionAspectSupport

protected TransactionAspectSupport()

## Method Details

### currentTransactionInfo

@Nullable 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:
  the 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.

This exposes the locally declared transaction boundary with its declared name and characteristics, as managed by the aspect. At runtime, the local boundary may participate in an outer transaction: If you need transaction metadata from such an outer transaction (the actual resource transaction) instead, consider using `TransactionSynchronizationManager`.

Throws:
  `NoTransactionException` - if the transaction info cannot be found, because the method was invoked outside an AOP invocation context
See Also:
  - `TransactionSynchronizationManager.getCurrentTransactionName()`
  - `TransactionSynchronizationManager.isCurrentTransactionReadOnly()`

### setTransactionManagerBeanName

public void setTransactionManagerBeanName(@Nullable String transactionManagerBeanName)
Specify the name of the default transaction manager bean.

This can either point to a traditional `PlatformTransactionManager` or a `ReactiveTransactionManager` for reactive transaction management.

### getTransactionManagerBeanName

@Nullable protected final String getTransactionManagerBeanName()
Return the name of the default transaction manager bean.

### setTransactionManager

public void setTransactionManager(@Nullable TransactionManager transactionManager)
Specify the default transaction manager to use to drive transactions.

This can either be a traditional `PlatformTransactionManager` or a `ReactiveTransactionManager` for reactive transaction management.

The default transaction manager will be used if a qualifier has not been declared for a given transaction or if an explicit name for the default transaction manager bean has not been specified.

See Also:
  - `setTransactionManagerBeanName(java.lang.String)`

### getTransactionManager

@Nullable public TransactionManager getTransactionManager()
Return the default transaction manager, or `null` if unknown.

This can either be a traditional `PlatformTransactionManager` or a `ReactiveTransactionManager` for reactive transaction management.

### setTransactionAttributes

public void setTransactionAttributes(Properties transactionAttributes)
Set properties with method names as keys and transaction attribute descriptors (parsed via TransactionAttributeEditor) as values: for example, 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(@Nullable 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

@Nullable public TransactionAttributeSource getTransactionAttributeSource()
Return the transaction attribute source.

### setBeanFactory

public void setBeanFactory(@Nullable org.springframework.beans.factory.BeanFactory beanFactory)
Set the BeanFactory to use for retrieving `TransactionManager` beans.

Specified by:
  `setBeanFactory` in interface `org.springframework.beans.factory.BeanFactoryAware`

### getBeanFactory

@Nullable protected final org.springframework.beans.factory.BeanFactory getBeanFactory()
Return the BeanFactory to use for retrieving `TransactionManager` beans.

### afterPropertiesSet

public void afterPropertiesSet()
Check that required properties were set.

Specified by:
  `afterPropertiesSet` in interface `org.springframework.beans.factory.InitializingBean`

### invokeWithinTransaction

@Nullable protected Object invokeWithinTransaction(Method method, @Nullable 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 and `ReactiveTransactionManager` implementations for reactive return types.

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

### clearTransactionManagerCache

protected void clearTransactionManagerCache()
Clear the transaction manager cache.

### determineTransactionManager

@Nullable protected TransactionManager determineTransactionManager(@Nullable TransactionAttribute txAttr, @Nullable Class<?> targetClass)
Determine the specific transaction manager to use for the given transaction.

Parameters:
  `txAttr` - the current transaction attribute
  `targetClass` - the target class that the attribute has been declared on
Since:
  6.2

### determineTransactionManager

@Deprecated @Nullable protected TransactionManager determineTransactionManager(@Nullable TransactionAttribute txAttr)
Deprecated.
as of 6.2, in favor of `determineTransactionManager(TransactionAttribute, Class)`
Determine the specific transaction manager to use for the given transaction.

### methodIdentification

@Nullable protected String methodIdentification(Method method, @Nullable 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.

The default implementation returns `null`, indicating the use of `DefaultTransactionAttribute.getDescriptor()` instead, ending up as `ClassUtils.getQualifiedMethodName(Method, Class)`.

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)`

### createTransactionIfNecessary

protected TransactionAspectSupport.TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm, @Nullable 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 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(@Nullable PlatformTransactionManager tm, @Nullable TransactionAttribute txAttr, String joinpointIdentification, @Nullable 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(@Nullable 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(@Nullable 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(@Nullable 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`)