Package org.springframework.cache.interceptor

# Class AbstractFallbackCacheOperationSource

java.lang.Object
org.springframework.cache.interceptor.AbstractFallbackCacheOperationSource

All Implemented Interfaces:
  `CacheOperationSource`

Direct Known Subclasses:
  `AnnotationCacheOperationSource`

public abstract class AbstractFallbackCacheOperationSource extends Object implements CacheOperationSource
Abstract implementation of `CacheOperationSource` that caches operations 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 declared cache operations if none are associated with the target method. Any cache operations associated with the target method completely override any class-level declarations. 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:
  3.1
Author:
  Costin Leau, 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
`AbstractFallbackCacheOperationSource()`

## Method Summary

Modifier and Type
Method
Description
`protected boolean`
`allowPublicMethodsOnly()`
Should only public methods be allowed to have caching semantics?
`protected abstract Collection<CacheOperation>`
`findCacheOperations(Class<?> clazz)`
Subclasses need to implement this to return the cache operations for the given class, if any.
`protected abstract Collection<CacheOperation>`
`findCacheOperations(Method method)`
Subclasses need to implement this to return the cache operations for the given method, if any.
`protected Object`
`getCacheKey(Method method, Class<?> targetClass)`
Determine a cache key for the given method and target class.
`Collection<CacheOperation>`
`getCacheOperations(Method method, Class<?> targetClass)`
Return the collection of cache operations for this method, or `null` if the method contains no cacheable annotations.
`boolean`
`hasCacheOperations(Method method, Class<?> targetClass)`
Determine whether there are cache operations for the given method.

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

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

### Methods inherited from interface org.springframework.cache.interceptor.CacheOperationSource

`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

### AbstractFallbackCacheOperationSource

public AbstractFallbackCacheOperationSource()

## Method Details

### hasCacheOperations

public boolean hasCacheOperations(Method method, @Nullable Class<?> targetClass)
Description copied from interface: `CacheOperationSource`
Determine whether there are cache operations for the given method.

Specified by:
  `hasCacheOperations` in interface `CacheOperationSource`
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:
  - `CacheOperationSource.getCacheOperations(java.lang.reflect.Method, java.lang.Class<?>)`

### getCacheOperations

@Nullable public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass)
Description copied from interface: `CacheOperationSource`
Return the collection of cache operations for this method, or `null` if the method contains no cacheable annotations.

Specified by:
  `getCacheOperations` in interface `CacheOperationSource`
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:
  all cache operations for this method, 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`)

### findCacheOperations

@Nullable protected abstract Collection<CacheOperation> findCacheOperations(Class<?> clazz)
Subclasses need to implement this to return the cache operations for the given class, if any.

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

### findCacheOperations

@Nullable protected abstract Collection<CacheOperation> findCacheOperations(Method method)
Subclasses need to implement this to return the cache operations for the given method, if any.

Parameters:
  `method` - the method to retrieve the cache operations for
Returns:
  all cache operations 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`.