anchor.diff:  `org.springframework.cache.Cache` and `org.springframework.cache.CacheManager` interfaces.
   
   Spring provides <<cache-store-configuration, a few implementations>> of that abstraction:
  -JDK `java.util.concurrent.ConcurrentMap` based caches, https://www.ehcache.org/[Ehcache 2.x],
  -Gemfire cache, https://github.com/ben-manes/caffeine/wiki[Caffeine], and JSR-107
  -compliant caches (such as Ehcache 3.x). See <<cache-plug>> for more information on
  -plugging in other cache stores and providers.
  +JDK `java.util.concurrent.ConcurrentMap` based caches, Gemfire cache,
  +https://github.com/ben-manes/caffeine/wiki[Caffeine], and JSR-107 compliant caches (such
  +as Ehcache 3.x). See <<cache-plug>> for more information on plugging in other cache
  +stores and providers.
   
   IMPORTANT: The caching abstraction has no special handling for multi-threaded and
   multi-process environments, as such features are handled by the cache implementation.
  
positive.code: interference to the invoker.
  
  IMPORTANT: This approach works only for methods that are guaranteed to return the same
  output (result) for a given input (or arguments) no matter how many times it is invoked.
  
  The caching abstraction provides other cache-related operations, such as the ability
  to update the content of the cache or to remove one or all entries. These are useful if
  
negative.code: store. For those that do not support JSR-107 you need to provide a `CacheManager` and a
  `Cache` implementation. This may sound harder than it is, since, in practice, the classes
  tend to be simple https://en.wikipedia.org/wiki/Adapter_pattern[adapters] that map the
  caching abstraction framework on top of the storage API, as the _Caffeine_ classes do.
  Most `CacheManager` classes can use the classes in the
  `org.springframework.cache.support` package (such as `AbstractCacheManager` which takes
  care of the boiler-plate code, leaving only the actual mapping to be completed). We hope
  