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

java.lang.Object
  extended by com.google.common.cache.AbstractCache<K,V>
      extended by 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) are implemented in terms of get; AbstractCache.getAllPresent(java.lang.Iterable) is implemented in terms of getIfPresent; AbstractCache.putAll(java.util.Map) 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) for all keys which are not already present in the cache. All entries returned by CacheLoader.loadAll(java.lang.Iterable) will be stored in the cache, over-writing any previously cached values. This method will throw an exception if CacheLoader.loadAll(java.lang.Iterable) 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.