## com.google.common.cache
Class AbstractLoadingCache<K,V>

    java.lang.Object
      com.google.common.cache.AbstractCache<K,V>
          com.google.common.cache.AbstractLoadingCache<K,V>

All Implemented Interfaces:
  Function<K,V>, Cache<K,V>, LoadingCache<K,V>

    @Beta
    public abstract class AbstractLoadingCache<K,V>

extends AbstractCache<K,V>
implements LoadingCache<K,V>

This class provides a skeletal implementation of the `Cache` interface to minimize the effort required to implement this interface.

To implement a cache, the programmer needs only to extend this class and provide an implementation for the `LoadingCache.get(Object)` and `Cache.getIfPresent(java.lang.Object)` methods. `getUnchecked(K)`, `AbstractCache.get(Object, Callable)`, and `getAll(java.lang.Iterable<? extends K>)` are implemented in terms of `get`; `AbstractCache.getAllPresent(java.lang.Iterable<?>)` is implemented in terms of `getIfPresent`; `AbstractCache.putAll(java.util.Map<? extends K, ? extends V>)` is implemented in terms of `AbstractCache.put(K, V)`, `AbstractCache.invalidateAll(Iterable)` is implemented in terms of `AbstractCache.invalidate(java.lang.Object)`. The method `AbstractCache.cleanUp()` is a no-op. All other methods throw an `UnsupportedOperationException`.

Since:
  11.0
Author:
  Charles Fry

Nested Class Summary

Nested classes/interfaces inherited from class com.google.common.cache.AbstractCache
`AbstractCache.SimpleStatsCounter, AbstractCache.StatsCounter`

Constructor Summary
`protected` `AbstractLoadingCache()` Constructor for use by subclasses.

Method Summary
`V` `apply(K key)` Discouraged.
`ImmutableMap<K,V>` `getAll(Iterable<? extends K> keys)` Returns a map of the values associated with `keys`, creating or retrieving those values if necessary.
`V` `getUnchecked(K key)` Returns the value associated with `key` in this cache, first loading that value if necessary.
`void` `refresh(K key)` Loads a new value for key `key`, possibly asynchronously.

Methods inherited from class com.google.common.cache.AbstractCache
`asMap, cleanUp, get, getAllPresent, invalidate, invalidateAll, invalidateAll, put, putAll, size, stats`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface com.google.common.cache.LoadingCache
`asMap, get`

Methods inherited from interface com.google.common.cache.Cache
`cleanUp, get, getAllPresent, getIfPresent, invalidate, invalidateAll, invalidateAll, put, putAll, size, stats`

Methods inherited from interface com.google.common.base.Function
`equals`

Constructor Detail

### AbstractLoadingCache

    protected AbstractLoadingCache()

  Constructor for use by subclasses.

Method Detail

### getUnchecked

    public V getUnchecked(K key)

  Description copied from interface: `LoadingCache`
  Returns the value associated with `key` in this cache, first loading that value if necessary. No observable state associated with this cache is modified until loading completes. Unlike `LoadingCache.get(K)`, this method does not throw a checked exception, and thus should only be used in situations where checked exceptions are not thrown by the cache loader.

  If another call to `LoadingCache.get(K)` or `LoadingCache.getUnchecked(K)` is currently loading the value for `key`, simply waits for that thread to finish and returns its loaded value. Note that multiple threads can concurrently load values for distinct keys.

  Caches loaded by a `CacheLoader` will call `CacheLoader.load(K)` to load new values into the cache. Newly loaded values are added to the cache using `Cache.asMap().putIfAbsent` after loading has completed; if another value was associated with `key` while the new value was loading then a removal notification will be sent for the new value.

  Warning: this method silently converts checked exceptions to unchecked exceptions, and should not be used with cache loaders which throw checked exceptions. In such cases use `LoadingCache.get(K)` instead.

  Specified by:
    `getUnchecked` in interface `LoadingCache<K,V>`

### getAll

    public ImmutableMap<K,V> getAll(Iterable<? extends K> keys)
                             throws ExecutionException

  Description copied from interface: `LoadingCache`
  Returns a map of the values associated with `keys`, creating or retrieving those values if necessary. The returned map contains entries that were already cached, combined with newly loaded entries; it will never contain null keys or values.

  Caches loaded by a `CacheLoader` will issue a single request to `CacheLoader.loadAll(java.lang.Iterable<? extends K>)` for all keys which are not already present in the cache. All entries returned by `CacheLoader.loadAll(java.lang.Iterable<? extends K>)` will be stored in the cache, over-writing any previously cached values. This method will throw an exception if `CacheLoader.loadAll(java.lang.Iterable<? extends K>)` returns `null`, returns a map containing null keys or values, or fails to return an entry for each requested key.

  Note that duplicate elements in `keys`, as determined by `Object.equals(java.lang.Object)`, will be ignored.

  Specified by:
    `getAll` in interface `LoadingCache<K,V>`
  Throws:
    `ExecutionException` - if a checked exception was thrown while loading the values

### apply

    public final V apply(K key)

  Description copied from interface: `LoadingCache`
  Discouraged. Provided to satisfy the `Function` interface; use `LoadingCache.get(K)` or `LoadingCache.getUnchecked(K)` instead.

  Specified by:
    `apply` in interface `Function<K,V>`
  Specified by:
    `apply` in interface `LoadingCache<K,V>`

### refresh

    public void refresh(K key)

  Description copied from interface: `LoadingCache`
  Loads a new value for key `key`, possibly asynchronously. While the new value is loading the previous value (if any) will continue to be returned by `get(key)` unless it is evicted. If the new value is loaded successfully it will replace the previous value in the cache; if an exception is thrown while refreshing the previous value will remain, and the exception will be logged (using `Logger`) and swallowed.

  Caches loaded by a `CacheLoader` will call `CacheLoader.reload(K, V)` if the cache currently contains a value for `key`, and `CacheLoader.load(K)` otherwise. Loading is asynchronous only if `CacheLoader.reload(K, V)` was overridden with an asynchronous implementation.

  Returns without doing anything if another thread is currently loading the value for `key`. If the cache loader associated with this cache performs refresh asynchronously then this method may return before refresh completes.

  Specified by:
    `refresh` in interface `LoadingCache<K,V>`

Copyright © 2010-2012. All Rights Reserved.