Package org.springframework.transaction.interceptor

# Class AbstractFallbackTransactionAttributeSource

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

All Implemented Interfaces:
  `org.springframework.beans.factory.Aware`, `org.springframework.context.EmbeddedValueResolverAware`, `TransactionAttributeSource`

Direct Known Subclasses:
  `AnnotationTransactionAttributeSource`

public abstract class AbstractFallbackTransactionAttributeSource extends Object implements TransactionAttributeSource, org.springframework.context.EmbeddedValueResolverAware
Abstract implementation of `TransactionAttributeSource` that caches attributes for methods and implements a fallback policy: 1. specific target method; 2. target class; 3. declaring method; 4. declaring class/interface.

Defaults to using the target class's transaction attribute if none is associated with the target method. Any transaction attribute associated with the target method completely overrides a class transaction attribute. If none found on the target class, the interface that the invoked method has been called through (in case of a JDK proxy) will be checked.

Since:
  1.1
Author:
  Rod Johnson, Juergen Hoeller

## Field Summary

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

## Constructor Summary

Constructors
Constructor
Description
`AbstractFallbackTransactionAttributeSource()`

## Method Summary

Modifier and Type
Method
Description
`protected boolean`
`allowPublicMethodsOnly()`
Should only public methods be allowed to have transactional semantics?
`protected TransactionAttribute`
`computeTransactionAttribute(Method method, Class<?> targetClass)`
Same signature as `getTransactionAttribute(java.lang.reflect.Method, java.lang.Class<?>)`, but doesn't cache the result.
`protected abstract TransactionAttribute`
`findTransactionAttribute(Class<?> clazz)`
Subclasses need to implement this to return the transaction attribute for the given class, if any.
`protected abstract TransactionAttribute`
`findTransactionAttribute(Method method)`
Subclasses need to implement this to return the transaction attribute for the given method, if any.
`protected Object`
`getCacheKey(Method method, Class<?> targetClass)`
Determine a cache key for the given method and target class.
`TransactionAttribute`
`getTransactionAttribute(Method method, Class<?> targetClass)`
Return the transaction attribute for the given method, or `null` if the method is non-transactional.
`boolean`
`hasTransactionAttribute(Method method, Class<?> targetClass)`
Determine whether there is a transaction attribute for the given method.
`void`
`setEmbeddedValueResolver(org.springframework.util.StringValueResolver resolver)`

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

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

### Methods inherited from interface org.springframework.transaction.interceptor.TransactionAttributeSource

`isCandidateClass`

## Field Details

### logger

protected final org.apache.commons.logging.Log logger
Logger available to subclasses.

As this base class is not marked Serializable, the logger will be recreated after serialization - provided that the concrete subclass is Serializable.

## Constructor Details

### AbstractFallbackTransactionAttributeSource

public AbstractFallbackTransactionAttributeSource()

## Method Details

### setEmbeddedValueResolver

public void setEmbeddedValueResolver(org.springframework.util.StringValueResolver resolver)

Specified by:
  `setEmbeddedValueResolver` in interface `org.springframework.context.EmbeddedValueResolverAware`

### hasTransactionAttribute

public boolean hasTransactionAttribute(Method method, @Nullable Class<?> targetClass)
Description copied from interface: `TransactionAttributeSource`
Determine whether there is a transaction attribute for the given method.

Specified by:
  `hasTransactionAttribute` in interface `TransactionAttributeSource`
Parameters:
  `method` - the method to introspect
  `targetClass` - the target class (can be `null`, in which case the declaring class of the method must be used)
See Also:
  - `TransactionAttributeSource.getTransactionAttribute(java.lang.reflect.Method, java.lang.Class<?>)`

### getTransactionAttribute

@Nullable public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass)
Description copied from interface: `TransactionAttributeSource`
Return the transaction attribute for the given method, or `null` if the method is non-transactional.

Specified by:
  `getTransactionAttribute` in interface `TransactionAttributeSource`
Parameters:
  `method` - the method to introspect
  `targetClass` - the target class (can be `null`, in which case the declaring class of the method must be used)
Returns:
  the matching transaction attribute, or `null` if none found

### getCacheKey

protected Object getCacheKey(Method method, @Nullable Class<?> targetClass)
Determine a cache key for the given method and target class.

Must not produce same key for overloaded methods. Must produce same key for different instances of the same method.

Parameters:
  `method` - the method (never `null`)
  `targetClass` - the target class (may be `null`)
Returns:
  the cache key (never `null`)

### computeTransactionAttribute

@Nullable protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass)
Same signature as `getTransactionAttribute(java.lang.reflect.Method, java.lang.Class<?>)`, but doesn't cache the result. `getTransactionAttribute(java.lang.reflect.Method, java.lang.Class<?>)` is effectively a caching decorator for this method.

As of 4.1.8, this method can be overridden.

Since:
  4.1.8
See Also:
  - `getTransactionAttribute(java.lang.reflect.Method, java.lang.Class<?>)`

### findTransactionAttribute

@Nullable protected abstract TransactionAttribute findTransactionAttribute(Class<?> clazz)
Subclasses need to implement this to return the transaction attribute for the given class, if any.

Parameters:
  `clazz` - the class to retrieve the attribute for
Returns:
  all transaction attribute associated with this class, or `null` if none

### findTransactionAttribute

@Nullable protected abstract TransactionAttribute findTransactionAttribute(Method method)
Subclasses need to implement this to return the transaction attribute for the given method, if any.

Parameters:
  `method` - the method to retrieve the attribute for
Returns:
  all transaction attribute associated with this method, or `null` if none

### allowPublicMethodsOnly

protected boolean allowPublicMethodsOnly()
Should only public methods be allowed to have transactional semantics?

The default implementation returns `false`.