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 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:

    • 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:

    • 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.