org.springframework.cache.concurrent

## 类 ConcurrentMapCache

- java.lang.Object
- - org.springframework.cache.support.AbstractValueAdaptingCache
  - - org.springframework.cache.concurrent.ConcurrentMapCache

- 所有已实现的接口:
    Cache

      public class ConcurrentMapCache
      extends AbstractValueAdaptingCache

  Simple `Cache` implementation based on the core JDK `java.util.concurrent` package.

  Useful for testing or simple caching scenarios, typically in combination with `SimpleCacheManager` or dynamically through `ConcurrentMapCacheManager`.

  Note: As `ConcurrentHashMap` (the default implementation used) does not allow for `null` values to be stored, this class will replace them with a predefined internal object. This behavior can be changed through the `ConcurrentMapCache(String, ConcurrentMap, boolean)` constructor.

  从以下版本开始:
    3.1
  作者:
    Costin Leau, Juergen Hoeller, Stephane Nicoll

- - ### 嵌套类概要

    - ### 从接口继承的嵌套类/接口 org.springframework.cache.Cache

      `Cache.ValueRetrievalException, Cache.ValueWrapper`

  - ### 构造器概要

    构造器
    限定符 | 构造器和说明
    --- | ---
    `` | `ConcurrentMapCache(String name)` Create a new ConcurrentMapCache with the specified name.
    `` | `ConcurrentMapCache(String name, boolean allowNullValues)` Create a new ConcurrentMapCache with the specified name.
    `` | `ConcurrentMapCache(String name, ConcurrentMap<Object,Object> store, boolean allowNullValues)` Create a new ConcurrentMapCache with the specified name and the given internal `ConcurrentMap` to use.
    `protected` | `ConcurrentMapCache(String name, ConcurrentMap<Object,Object> store, boolean allowNullValues, org.springframework.core.serializer.support.SerializationDelegate serialization)` Create a new ConcurrentMapCache with the specified name and the given internal `ConcurrentMap` to use.

  - ### 方法概要

    所有方法 实例方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `void` | `clear()` Remove all mappings from the cache.
    `void` | `evict(Object key)` Evict the mapping for this key from this cache if it is present.
    `protected Object` | `fromStoreValue(Object storeValue)` Convert the given value from the internal store to a user value returned from the get method (adapting `null`).
    `<T> T` | `get(Object key, Callable<T> valueLoader)` Return the value to which this cache maps the specified key, obtaining that value from `valueLoader` if necessary.
    `String` | `getName()` Return the cache name.
    `ConcurrentMap<Object,Object>` | `getNativeCache()` Return the underlying native cache provider.
    `boolean` | `isStoreByValue()` Return whether this cache stores a copy of each entry (`true`) or a reference (`false`, default).
    `protected Object` | `lookup(Object key)` Perform an actual lookup in the underlying store.
    `void` | `put(Object key, Object value)` Associate the specified value with the specified key in this cache.
    `Cache.ValueWrapper` | `putIfAbsent(Object key, Object value)` Atomically associate the specified value with the specified key in this cache if it is not set already.
    `protected Object` | `toStoreValue(Object userValue)` Convert the given user value, as passed into the put method, to a value in the internal store (adapting `null`).

    - ### 从类继承的方法 org.springframework.cache.support.AbstractValueAdaptingCache

      `get, get, isAllowNullValues, toValueWrapper`

    - ### 从类继承的方法 java.lang.Object

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

- - ### 构造器详细资料

    - #### ConcurrentMapCache

          public ConcurrentMapCache(String name)

      Create a new ConcurrentMapCache with the specified name.
      参数:
        `name` - the name of the cache

    - #### ConcurrentMapCache

          public ConcurrentMapCache(String name,
                                    boolean allowNullValues)

      Create a new ConcurrentMapCache with the specified name.
      参数:
        `name` - the name of the cache
        `allowNullValues` - whether to accept and convert `null` values for this cache

    - #### ConcurrentMapCache

          public ConcurrentMapCache(String name,
                                    ConcurrentMap<Object,Object> store,
                                    boolean allowNullValues)

      Create a new ConcurrentMapCache with the specified name and the given internal `ConcurrentMap` to use.
      参数:
        `name` - the name of the cache
        `store` - the ConcurrentMap to use as an internal store
        `allowNullValues` - whether to allow `null` values (adapting them to an internal null holder value)

    - #### ConcurrentMapCache

          protected ConcurrentMapCache(String name,
                                       ConcurrentMap<Object,Object> store,
                                       boolean allowNullValues,
                                       @Nullable
                                       org.springframework.core.serializer.support.SerializationDelegate serialization)

      Create a new ConcurrentMapCache with the specified name and the given internal `ConcurrentMap` to use. If the `SerializationDelegate` is specified, `store-by-value` is enabled
      参数:
        `name` - the name of the cache
        `store` - the ConcurrentMap to use as an internal store
        `allowNullValues` - whether to allow `null` values (adapting them to an internal null holder value)
        `serialization` - the `SerializationDelegate` to use to serialize cache entry or `null` to store the reference
      从以下版本开始:
        4.3

  - ### 方法详细资料

    - #### isStoreByValue

          public final boolean isStoreByValue()

      Return whether this cache stores a copy of each entry (`true`) or a reference (`false`, default). If store by value is enabled, each entry in the cache must be serializable.
      从以下版本开始:
        4.3

    - #### getName

          public final String getName()

      从接口复制的说明: `Cache`
      Return the cache name.

    - #### getNativeCache

          public final ConcurrentMap<Object,Object> getNativeCache()

      从接口复制的说明: `Cache`
      Return the underlying native cache provider.

    - #### lookup

          @Nullable
          protected Object lookup(Object key)

      从类复制的说明: `AbstractValueAdaptingCache`
      Perform an actual lookup in the underlying store.
      指定者:
        `lookup` 在类中 `AbstractValueAdaptingCache`
      参数:
        `key` - the key whose associated value is to be returned
      返回:
        the raw store value for the key, or `null` if none

    - #### get

          @Nullable
          public <T> T get(Object key,
                                      Callable<T> valueLoader)

      从接口复制的说明: `Cache`
      Return the value to which this cache maps the specified key, obtaining that value from `valueLoader` if necessary. This method provides a simple substitute for the conventional "if cached, return; otherwise create, cache and return" pattern.

      If possible, implementations should ensure that the loading operation is synchronized so that the specified `valueLoader` is only called once in case of concurrent access on the same key.

      If the `valueLoader` throws an exception, it is wrapped in a `Cache.ValueRetrievalException`

      参数:
        `key` - the key whose associated value is to be returned
      返回:
        the value to which this cache maps the specified key

    - #### put

          public void put(Object key,
                          @Nullable
                          Object value)

      从接口复制的说明: `Cache`
      Associate the specified value with the specified key in this cache.

      If the cache previously contained a mapping for this key, the old value is replaced by the specified value.

      参数:
        `key` - the key with which the specified value is to be associated
        `value` - the value to be associated with the specified key

    - #### putIfAbsent

          @Nullable
          public Cache.ValueWrapper putIfAbsent(Object key,
                                                           @Nullable
                                                           Object value)

      从接口复制的说明: `Cache`
      Atomically associate the specified value with the specified key in this cache if it is not set already.

      This is equivalent to:

           Object existingValue = cache.get(key);
           if (existingValue == null) {
               cache.put(key, value);
               return null;
           } else {
               return existingValue;
           }

      except that the action is performed atomically. While all out-of-the-box `CacheManager` implementations are able to perform the put atomically, the operation may also be implemented in two steps, e.g. with a check for presence and a subsequent put, in a non-atomic way. Check the documentation of the native cache implementation that you are using for more details.
      参数:
        `key` - the key with which the specified value is to be associated
        `value` - the value to be associated with the specified key
      返回:
        the value to which this cache maps the specified key (which may be `null` itself), or also `null` if the cache did not contain any mapping for that key prior to this call. Returning `null` is therefore an indicator that the given `value` has been associated with the key.

    - #### evict

          public void evict(Object key)

      从接口复制的说明: `Cache`
      Evict the mapping for this key from this cache if it is present.
      参数:
        `key` - the key whose mapping is to be removed from the cache

    - #### clear

          public void clear()

      从接口复制的说明: `Cache`
      Remove all mappings from the cache.

    - #### toStoreValue

          protected Object toStoreValue(@Nullable
                                        Object userValue)

      从类复制的说明: `AbstractValueAdaptingCache`
      Convert the given user value, as passed into the put method, to a value in the internal store (adapting `null`).
      覆盖:
        `toStoreValue` 在类中 `AbstractValueAdaptingCache`
      参数:
        `userValue` - the given user value
      返回:
        the value to store

    - #### fromStoreValue

          protected Object fromStoreValue(@Nullable
                                          Object storeValue)

      从类复制的说明: `AbstractValueAdaptingCache`
      Convert the given value from the internal store to a user value returned from the get method (adapting `null`).
      覆盖:
        `fromStoreValue` 在类中 `AbstractValueAdaptingCache`
      参数:
        `storeValue` - the store value
      返回:
        the value to return to the user