org.springframework.cache.jcache.interceptor

## Class DefaultJCacheOperationSource

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

- All Implemented Interfaces:
    Aware, BeanFactoryAware, SmartInitializingSingleton, JCacheOperationSource

      public class DefaultJCacheOperationSource
      extends AnnotationJCacheOperationSource
      implements BeanFactoryAware, SmartInitializingSingleton

  The default `JCacheOperationSource` implementation delegating default operations to configurable services with sensible defaults when not present.
  Since:
    4.1
  Author:
    Stephane Nicoll, Juergen Hoeller

- - ### Field Summary

    - ### Fields inherited from class org.springframework.cache.jcache.interceptor.AbstractFallbackJCacheOperationSource

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `DefaultJCacheOperationSource()` Construct a new `DefaultJCacheOperationSource` with the default key generator.
    `DefaultJCacheOperationSource(Supplier<CacheManager> cacheManager, Supplier<CacheResolver> cacheResolver, Supplier<CacheResolver> exceptionCacheResolver, Supplier<KeyGenerator> keyGenerator)` Construct a new `DefaultJCacheOperationSource` with the given cache manager, cache resolver and key generator suppliers, applying the corresponding default if a supplier is not resolvable.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `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 <T> T` | `getBean(Class<T> type)` Locate or create an instance of the specified cache strategy `type`.
    `CacheManager` | `getCacheManager()` Return the specified cache manager to use, if any.
    `CacheResolver` | `getCacheResolver()` Return the specified cache resolver to use, if any.
    `protected CacheManager` | `getDefaultCacheManager()`
    `protected CacheResolver` | `getDefaultCacheResolver()` Return the default `CacheResolver` if none is set.
    `protected CacheResolver` | `getDefaultExceptionCacheResolver()` Return the default exception `CacheResolver` if none is set.
    `protected KeyGenerator` | `getDefaultKeyGenerator()` Return the default `KeyGenerator` if none is set.
    `CacheResolver` | `getExceptionCacheResolver()` Return the specified exception cache resolver to use, if any.
    `KeyGenerator` | `getKeyGenerator()` Return the specified key generator to use.
    `void` | `setBeanFactory(BeanFactory beanFactory)` Callback that supplies the owning factory to a bean instance.
    `void` | `setCacheManager(CacheManager cacheManager)` Set the default `CacheManager` to use to lookup cache by name.
    `void` | `setCacheResolver(CacheResolver cacheResolver)` Set the `CacheResolver` to resolve regular caches.
    `void` | `setExceptionCacheResolver(CacheResolver exceptionCacheResolver)` Set the `CacheResolver` to resolve exception caches.
    `void` | `setKeyGenerator(KeyGenerator keyGenerator)` Set the default `KeyGenerator`.

    - ### Methods inherited from class org.springframework.cache.jcache.interceptor.AnnotationJCacheOperationSource

      `createCachePutOperation, createCacheRemoveAllOperation, createCacheRemoveOperation, createCacheResultOperation, determineCacheName, determineCacheResolverFactory, determineKeyGenerator, findCacheOperation, generateDefaultCacheName, getCacheDefaults, getCacheResolver, getExceptionCacheResolver`

    - ### Methods inherited from class org.springframework.cache.jcache.interceptor.AbstractFallbackJCacheOperationSource

      `allowPublicMethodsOnly, getCacheOperation`

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

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

- - ### Constructor Detail

    - #### DefaultJCacheOperationSource

          public DefaultJCacheOperationSource()

      Construct a new `DefaultJCacheOperationSource` with the default key generator.
      See Also:
        `SimpleKeyGenerator`

    - #### DefaultJCacheOperationSource

          public DefaultJCacheOperationSource(@Nullable
                                              Supplier<CacheManager> cacheManager,
                                              @Nullable
                                              Supplier<CacheResolver> cacheResolver,
                                              @Nullable
                                              Supplier<CacheResolver> exceptionCacheResolver,
                                              @Nullable
                                              Supplier<KeyGenerator> keyGenerator)

      Construct a new `DefaultJCacheOperationSource` with the given cache manager, cache resolver and key generator suppliers, applying the corresponding default if a supplier is not resolvable.
      Since:
        5.1

  - ### Method Detail

    - #### setCacheManager

          public void setCacheManager(@Nullable
                                      CacheManager cacheManager)

      Set the default `CacheManager` to use to lookup cache by name. Only mandatory if the cache resolver has not been set.

    - #### getCacheManager

          @Nullable
          public CacheManager getCacheManager()

      Return the specified cache manager to use, if any.

    - #### setCacheResolver

          public void setCacheResolver(@Nullable
                                       CacheResolver cacheResolver)

      Set the `CacheResolver` to resolve regular caches. If none is set, a default implementation using the specified cache manager will be used.

    - #### getCacheResolver

          @Nullable
          public CacheResolver getCacheResolver()

      Return the specified cache resolver to use, if any.

    - #### setExceptionCacheResolver

          public void setExceptionCacheResolver(@Nullable
                                                CacheResolver exceptionCacheResolver)

      Set the `CacheResolver` to resolve exception caches. If none is set, a default implementation using the specified cache manager will be used.

    - #### getExceptionCacheResolver

          @Nullable
          public CacheResolver getExceptionCacheResolver()

      Return the specified exception cache resolver to use, if any.

    - #### setKeyGenerator

          public void setKeyGenerator(KeyGenerator keyGenerator)

      Set the default `KeyGenerator`. If none is set, a `SimpleKeyGenerator` honoring the JSR-107 `CacheKey` and `CacheValue` will be used.

    - #### getKeyGenerator

          public KeyGenerator getKeyGenerator()

      Return the specified key generator to use.

    - #### setBeanFactory

          public void setBeanFactory(BeanFactory beanFactory)

      Description copied from interface: `BeanFactoryAware`
      Callback that supplies the owning factory to a bean instance.

      Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean.afterPropertiesSet()` or a custom init-method.

      Specified by:
        `setBeanFactory` in interface `BeanFactoryAware`
      Parameters:
        `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
      See Also:
        `BeanInitializationException`

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

    - #### getBean

          protected <T> T getBean(Class<T> type)

      Description copied from class: `AnnotationJCacheOperationSource`
      Locate or create an instance of the specified cache strategy `type`.
      Specified by:
        `getBean` in class `AnnotationJCacheOperationSource`
      Parameters:
        `type` - the type of the bean to manage
      Returns:
        the required bean

    - #### getDefaultCacheManager

          protected CacheManager getDefaultCacheManager()

    - #### getDefaultCacheResolver

          protected CacheResolver getDefaultCacheResolver()

      Description copied from class: `AnnotationJCacheOperationSource`
      Return the default `CacheResolver` if none is set.
      Specified by:
        `getDefaultCacheResolver` in class `AnnotationJCacheOperationSource`

    - #### getDefaultExceptionCacheResolver

          protected CacheResolver getDefaultExceptionCacheResolver()

      Description copied from class: `AnnotationJCacheOperationSource`
      Return the default exception `CacheResolver` if none is set.
      Specified by:
        `getDefaultExceptionCacheResolver` in class `AnnotationJCacheOperationSource`

    - #### getDefaultKeyGenerator

          protected KeyGenerator getDefaultKeyGenerator()

      Description copied from class: `AnnotationJCacheOperationSource`
      Return the default `KeyGenerator` if none is set.
      Specified by:
        `getDefaultKeyGenerator` in class `AnnotationJCacheOperationSource`