java.lang.Object
- org.springframework.cache.interceptor.AbstractCacheInvoker
- - org.springframework.cache.interceptor.CacheAspectSupport

All Implemented Interfaces:
Aware, BeanFactoryAware, InitializingBean, SmartInitializingSingleton
Direct Known Subclasses:
CacheInterceptor
```
public abstract class CacheAspectSupport
extends AbstractCacheInvoker
implements BeanFactoryAware, InitializingBean, SmartInitializingSingleton
```
Base class for caching aspects, such as the CacheInterceptor or an AspectJ aspect.
This enables the underlying Spring caching infrastructure to be used easily to implement an aspect for any aspect system.
Subclasses are responsible for calling relevant methods in the correct order.
Uses the Strategy design pattern. A CacheOperationSource is used for determining caching operations, a KeyGenerator will build the cache keys, and a CacheResolver will resolve the actual cache(s) to use.
Note: A cache aspect is serializable but does not perform any actual caching after deserialization.
Since:
3.1
Author:
Costin Leau, Juergen Hoeller, Chris Beams, Phillip Webb, Sam Brannen, Stephane Nicoll

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`protected class`	`CacheAspectSupport.CacheOperationContext`	A `CacheOperationInvocationContext` context for a `CacheOperation`.
`protected static class`	`CacheAspectSupport.CacheOperationMetadata`	Metadata of a cache operation that does not depend on a particular invocation which makes it a good candidate for caching.

Field Summary
Fields
Modifier and Type Field Description
protected Log logger

Constructor Summary
Constructors
Constructor Description
CacheAspectSupport()

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`void`	`afterPropertiesSet()`	Invoked by the containing `BeanFactory` after it has set all bean properties and satisfied `BeanFactoryAware`, `ApplicationContextAware` etc.
`void`	`afterSingletonsInstantiated()`	Invoked right at the end of the singleton pre-instantiation phase, with a guarantee that all regular singleton beans have been created already.
`protected void`	`clearMetadataCache()`	Clear the cached metadata.
`protected Object`	`execute(CacheOperationInvoker invoker, Object target, Method method, Object[] args)`
`protected <T> T`	`getBean(String beanName, Class<T> expectedType)`	Return a bean with the specified name and type.
`protected CacheAspectSupport.CacheOperationMetadata`	`getCacheOperationMetadata(CacheOperation operation, Method method, Class<?> targetClass)`	Return the `CacheAspectSupport.CacheOperationMetadata` for the specified operation.
`CacheOperationSource`	`getCacheOperationSource()`	Return the CacheOperationSource for this cache aspect.
`CacheResolver`	`getCacheResolver()`	Return the default `CacheResolver` that this cache aspect delegates to.
`protected Collection<? extends Cache>`	`getCaches(CacheOperationInvocationContext<CacheOperation> context, CacheResolver cacheResolver)`
`KeyGenerator`	`getKeyGenerator()`	Return the default `KeyGenerator` that this cache aspect delegates to.
`protected CacheAspectSupport.CacheOperationContext`	`getOperationContext(CacheOperation operation, Method method, Object[] args, Object target, Class<?> targetClass)`
`protected Object`	`invokeOperation(CacheOperationInvoker invoker)`	Execute the underlying operation (typically in case of cache miss) and return the result of the invocation.
`protected String`	`methodIdentification(Method method, Class<?> targetClass)`	Convenience method to return a String representation of this Method for use in logging.
`void`	`setApplicationContext(ApplicationContext applicationContext)`	Deprecated. as of 4.3, in favor of `setBeanFactory(org.springframework.beans.factory.BeanFactory)`
`void`	`setBeanFactory(BeanFactory beanFactory)`	Set the containing `BeanFactory` for `CacheManager` and other service lookups.
`void`	`setCacheManager(CacheManager cacheManager)`	Set the `CacheManager` to use to create a default `CacheResolver`.
`void`	`setCacheOperationSources(CacheOperationSource... cacheOperationSources)`	Set one or more cache operation sources which are used to find the cache attributes.
`void`	`setCacheResolver(CacheResolver cacheResolver)`	Set the default `CacheResolver` that this cache aspect should delegate to if no specific cache resolver has been set for the operation.
`void`	`setKeyGenerator(KeyGenerator keyGenerator)`	Set the default `KeyGenerator` that this cache aspect should delegate to if no specific key generator has been set for the operation.

Methods inherited from class org.springframework.cache.interceptor.AbstractCacheInvoker
doClear, doEvict, doGet, doPut, getErrorHandler, setErrorHandler

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
  - CacheAspectSupport
```
public CacheAspectSupport()
```
- Method Detail
  - setCacheOperationSources
```
public void setCacheOperationSources(CacheOperationSource... cacheOperationSources)
```
    Set one or more cache operation sources which are used to find the cache attributes. If more than one source is provided, they will be aggregated using a CompositeCacheOperationSource.
  - getCacheOperationSource
```
public CacheOperationSource getCacheOperationSource()
```
    Return the CacheOperationSource for this cache aspect.
  - setKeyGenerator
```
public void setKeyGenerator(KeyGenerator keyGenerator)
```
    Set the default KeyGenerator that this cache aspect should delegate to if no specific key generator has been set for the operation.
    The default is a SimpleKeyGenerator.
  - getKeyGenerator
```
public KeyGenerator getKeyGenerator()
```
    Return the default KeyGenerator that this cache aspect delegates to.
  - setCacheResolver
```
public void setCacheResolver(CacheResolver cacheResolver)
```
    Set the default CacheResolver that this cache aspect should delegate to if no specific cache resolver has been set for the operation.
    The default resolver resolves the caches against their names and the default cache manager.
    See Also:
    setCacheManager(org.springframework.cache.CacheManager), SimpleCacheResolver
  - getCacheResolver
```
public CacheResolver getCacheResolver()
```
    Return the default CacheResolver that this cache aspect delegates to.
  - setCacheManager
```
public void setCacheManager(CacheManager cacheManager)
```
    Set the CacheManager to use to create a default CacheResolver. Replace the current CacheResolver, if any.
    See Also:
    setCacheResolver(org.springframework.cache.interceptor.CacheResolver), SimpleCacheResolver
  - setBeanFactory
```
public void setBeanFactory(BeanFactory beanFactory)
```
    Set the containing BeanFactory for CacheManager and other service lookups.
    Specified by:
    setBeanFactory in interface BeanFactoryAware
    Parameters:
    beanFactory - owning BeanFactory (never null). The bean can immediately call methods on the factory.
    Since:
    4.3
    See Also:
    BeanInitializationException
  - setApplicationContext
```
@Deprecated
public void setApplicationContext(ApplicationContext applicationContext)
```
    Deprecated.
    as of 4.3, in favor of setBeanFactory(org.springframework.beans.factory.BeanFactory)
  - afterPropertiesSet
```
public void afterPropertiesSet()
```
    Description copied from interface: InitializingBean
    Invoked by the containing BeanFactory after it has set all bean properties and satisfied BeanFactoryAware, ApplicationContextAware etc.
    This method allows the bean instance to perform validation of its overall configuration and final initialization when all bean properties have been set.
    Specified by:
    afterPropertiesSet in interface InitializingBean
  - afterSingletonsInstantiated
```
public void afterSingletonsInstantiated()
```
    Description copied from interface: SmartInitializingSingleton
    Invoked right at the end of the singleton pre-instantiation phase, with a guarantee that all regular singleton beans have been created already. ListableBeanFactory.getBeansOfType(java.lang.Class<T>) calls within this method won't trigger accidental side effects during bootstrap.
    NOTE: This callback won't be triggered for singleton beans lazily initialized on demand after BeanFactory bootstrap, and not for any other bean scope either. Carefully use it for beans with the intended bootstrap semantics only.
    Specified by:
    afterSingletonsInstantiated in interface SmartInitializingSingleton
  - methodIdentification
```
protected String methodIdentification(Method method,
                                      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.
    Parameters:
    method - the method we're interested in
    targetClass - class the method is on
    Returns:
    log message identifying this method
    See Also:
    ClassUtils.getQualifiedMethodName(java.lang.reflect.Method)
  - getCaches
```
protected Collection<? extends Cache> getCaches(CacheOperationInvocationContext<CacheOperation> context,
                                                CacheResolver cacheResolver)
```
  - getOperationContext
```
protected CacheAspectSupport.CacheOperationContext getOperationContext(CacheOperation operation,
                                                                       Method method,
                                                                       Object[] args,
                                                                       Object target,
                                                                       Class<?> targetClass)
```
  - getCacheOperationMetadata
```
protected CacheAspectSupport.CacheOperationMetadata getCacheOperationMetadata(CacheOperation operation,
                                                                              Method method,
                                                                              Class<?> targetClass)
```
    Return the CacheAspectSupport.CacheOperationMetadata for the specified operation.
    Resolve the CacheResolver and the KeyGenerator to be used for the operation.
    Parameters:
    operation - the operation
    method - the method on which the operation is invoked
    targetClass - the target type
    Returns:
    the resolved metadata for the operation
  - getBean
```
protected <T> T getBean(String beanName,
                        Class<T> expectedType)
```
    Return a bean with the specified name and type. Used to resolve services that are referenced by name in a CacheOperation.
    Parameters:
    beanName - the name of the bean, as defined by the operation
    expectedType - type for the bean
    Returns:
    the bean matching that name
    Throws:
    NoSuchBeanDefinitionException - if such bean does not exist
    See Also:
    CacheOperation.getKeyGenerator(), CacheOperation.getCacheManager(), CacheOperation.getCacheResolver()
  - clearMetadataCache
```
protected void clearMetadataCache()
```
    Clear the cached metadata.
  - execute
```
protected Object execute(CacheOperationInvoker invoker,
                         Object target,
                         Method method,
                         Object[] args)
```
  - invokeOperation
```
protected Object invokeOperation(CacheOperationInvoker invoker)
```
    Execute the underlying operation (typically in case of cache miss) and return the result of the invocation. If an exception occurs it will be wrapped in a CacheOperationInvoker.ThrowableWrapper: the exception can be handled or modified but it must be wrapped in a CacheOperationInvoker.ThrowableWrapper as well.
    Parameters:
    invoker - the invoker handling the operation being cached
    Returns:
    the result of the invocation
    See Also:
    CacheOperationInvoker.invoke()

Class CacheAspectSupport

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.springframework.cache.interceptor.AbstractCacheInvoker

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

CacheAspectSupport

Method Detail

setCacheOperationSources

getCacheOperationSource

setKeyGenerator

getKeyGenerator

setCacheResolver

getCacheResolver

setCacheManager

setBeanFactory

setApplicationContext

afterPropertiesSet

afterSingletonsInstantiated

methodIdentification

getCaches

getOperationContext

getCacheOperationMetadata

getBean

clearMetadataCache

execute

invokeOperation