org.springframework.cache.annotation

## Annotation Type CachePut

-     @Target(value={TYPE,METHOD})
       @Retention(value=RUNTIME)
       @Inherited
       @Documented
      public @interface CachePut

  Annotation indicating that a method (or all methods on a class) triggers a `cache put` operation.

  In contrast to the `@Cacheable` annotation, this annotation does not cause the advised method to be skipped. Rather, it always causes the method to be invoked and its result to be stored in the associated cache if the `condition()` and `unless()` expressions match accordingly. Note that Java8's `Optional` return types are automatically handled and its content is stored in the cache if present.

  This annotation may be used as a meta-annotation to create custom composed annotations with attribute overrides.

  Since:
    3.1
  Author:
    Costin Leau, Phillip Webb, Stephane Nicoll, Sam Brannen
  See Also:
    `CacheConfig`

- - ### Optional Element Summary

    Optional Elements
    Modifier and Type | Optional Element and Description
    --- | ---
    `String` | `cacheManager` The bean name of the custom `CacheManager` to use to create a default `CacheResolver` if none is set already.
    `String[]` | `cacheNames` Names of the caches to use for the cache put operation.
    `String` | `cacheResolver` The bean name of the custom `CacheResolver` to use.
    `String` | `condition` Spring Expression Language (SpEL) expression used for making the cache put operation conditional.
    `String` | `key` Spring Expression Language (SpEL) expression for computing the key dynamically.
    `String` | `keyGenerator` The bean name of the custom `KeyGenerator` to use.
    `String` | `unless` Spring Expression Language (SpEL) expression used to veto the cache put operation.
    `String[]` | `value` Alias for `cacheNames()`.

- - ### Element Detail

    - #### value

          @AliasFor(value="cacheNames")
          public abstract String[] value

      Alias for `cacheNames()`.
      Default:
        {}

  - - #### cacheNames

          @AliasFor(value="value")
          public abstract String[] cacheNames

      Names of the caches to use for the cache put operation.

      Names may be used to determine the target cache (or caches), matching the qualifier value or bean name of a specific bean definition.

      Since:
        4.2
      See Also:
        `value()`, `CacheConfig.cacheNames()`
      Default:
        {}

  - - #### key

          public abstract String key

      Spring Expression Language (SpEL) expression for computing the key dynamically.

      Default is `""`, meaning all method parameters are considered as a key, unless a custom `keyGenerator()` has been set.

      The SpEL expression evaluates against a dedicated context that provides the following meta-data:

      - `#result` for a reference to the result of the method invocation. For supported wrappers such as `Optional`, `#result` refers to the actual object, not the wrapper
      - `#root.method`, `#root.target`, and `#root.caches` for references to the `method`, target object, and affected cache(s) respectively.
      - Shortcuts for the method name (`#root.methodName`) and target class (`#root.targetClass`) are also available.
      - Method arguments can be accessed by index. For instance the second argument can be accessed via `#root.args[1]`, `#p1` or `#a1`. Arguments can also be accessed by name if that information is available.
      Default:
        ""

  - - #### keyGenerator

          public abstract String keyGenerator

      The bean name of the custom `KeyGenerator` to use.

      Mutually exclusive with the `key()` attribute.

      See Also:
        `CacheConfig.keyGenerator()`
      Default:
        ""

  - - #### cacheManager

          public abstract String cacheManager

      The bean name of the custom `CacheManager` to use to create a default `CacheResolver` if none is set already.

      Mutually exclusive with the `cacheResolver()` attribute.

      See Also:
        `SimpleCacheResolver`, `CacheConfig.cacheManager()`
      Default:
        ""

  - - #### cacheResolver

          public abstract String cacheResolver

      The bean name of the custom `CacheResolver` to use.
      See Also:
        `CacheConfig.cacheResolver()`
      Default:
        ""

  - - #### condition

          public abstract String condition

      Spring Expression Language (SpEL) expression used for making the cache put operation conditional. Update the cache if the condition evaluates to `true`.

      This expression is evaluated after the method has been called due to the nature of the put operation and can therefore refer to the `result`.

      Default is `""`, meaning the method result is always cached.

      The SpEL expression evaluates against a dedicated context that provides the following meta-data:

      - `#result` for a reference to the result of the method invocation. For supported wrappers such as `Optional`, `#result` refers to the actual object, not the wrapper
      - `#root.method`, `#root.target`, and `#root.caches` for references to the `method`, target object, and affected cache(s) respectively.
      - Shortcuts for the method name (`#root.methodName`) and target class (`#root.targetClass`) are also available.
      - Method arguments can be accessed by index. For instance the second argument can be accessed via `#root.args[1]`, `#p1` or `#a1`. Arguments can also be accessed by name if that information is available.
      Default:
        ""

  - - #### unless

          public abstract String unless

      Spring Expression Language (SpEL) expression used to veto the cache put operation. Veto updating the cache if the condition evaluates to `true`.

      Default is `""`, meaning that caching is never vetoed.

      The SpEL expression evaluates against a dedicated context that provides the following meta-data:

      - `#result` for a reference to the result of the method invocation. For supported wrappers such as `Optional`, `#result` refers to the actual object, not the wrapper
      - `#root.method`, `#root.target`, and `#root.caches` for references to the `method`, target object, and affected cache(s) respectively.
      - Shortcuts for the method name (`#root.methodName`) and target class (`#root.targetClass`) are also available.
      - Method arguments can be accessed by index. For instance the second argument can be accessed via `#root.args[1]`, `#p1` or `#a1`. Arguments can also be accessed by name if that information is available.
      Since:
        3.2
      Default:
        ""