org.springframework.cache.jcache.interceptor

## Class AbstractFallbackJCacheOperationSource

- java.lang.Object
- - org.springframework.cache.jcache.interceptor.AbstractFallbackJCacheOperationSource

- All Implemented Interfaces:
    JCacheOperationSource
  Direct Known Subclasses:
    AnnotationJCacheOperationSource

      public abstract class AbstractFallbackJCacheOperationSource
      extends Object
      implements JCacheOperationSource

  Abstract implementation of `JCacheOperationSource` that caches attributes for methods and implements a fallback policy: 1. specific target method; 2. declaring method.

  This implementation caches attributes by method after they are first used.

  Since:
    4.1
  Author:
    Stephane Nicoll, Juergen Hoeller
  See Also:
    `AbstractFallbackCacheOperationSource`

- - ### Field Summary

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

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractFallbackJCacheOperationSource()`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected boolean` | `allowPublicMethodsOnly()` Should only public methods be allowed to have caching semantics?
    `protected abstract JCacheOperation<?>` | `findCacheOperation(Method method, Class<?> targetType)` Subclasses need to implement this to return the caching operation for the given method, if any.
    `JCacheOperation<?>` | `getCacheOperation(Method method, Class<?> targetClass)` Return the cache operations for this method, or `null` if the method contains no JSR-107 related metadata.

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

    - #### AbstractFallbackJCacheOperationSource

          public AbstractFallbackJCacheOperationSource()

  - ### Method Detail

    - #### getCacheOperation

          public JCacheOperation<?> getCacheOperation(Method method,
                                                      @Nullable
                                                      Class<?> targetClass)

      Description copied from interface: `JCacheOperationSource`
      Return the cache operations for this method, or `null` if the method contains no JSR-107 related metadata.
      Specified by:
        `getCacheOperation` in interface `JCacheOperationSource`
      Parameters:
        `method` - the method to introspect
        `targetClass` - the target class (may be `null`, in which case the declaring class of the method must be used)
      Returns:
        the cache operation for this method, or `null` if none found

    - #### findCacheOperation

          @Nullable
          protected abstract JCacheOperation<?> findCacheOperation(Method method,
                                                                             @Nullable
                                                                             Class<?> targetType)

      Subclasses need to implement this to return the caching operation for the given method, if any.
      Parameters:
        `method` - the method to retrieve the operation for
        `targetType` - the target class
      Returns:
        the cache operation associated with this method (or `null` if none)

    - #### allowPublicMethodsOnly

          protected boolean allowPublicMethodsOnly()

      Should only public methods be allowed to have caching semantics?

      The default implementation returns `false`.