@GwtCompatible(emulated=true) public abstract class CacheLoader<K,V> extends Object
LoadingCache
.
Most implementations will only need to implement load(K)
. Other methods may be
overridden as desired.
Usage example:
CacheLoader<Key, Graph> loader = new CacheLoader<Key, Graph>() {
public Graph load(Key key) throws AnyException {
return createExpensiveGraph(key);
}
};
LoadingCache<Key, Graph> cache = CacheBuilder.newBuilder().build(loader);
Modifier and Type | Class and Description |
---|---|
static class |
CacheLoader.InvalidCacheLoadException
Thrown to indicate that an invalid response was returned from a call to
CacheLoader . |
static class |
CacheLoader.UnsupportedLoadingOperationException
Exception thrown by
loadAll() to indicate that it is not supported. |
Modifier | Constructor and Description |
---|---|
protected |
CacheLoader()
Constructor for use by subclasses.
|
Modifier and Type | Method and Description |
---|---|
static <K,V> CacheLoader<K,V> |
asyncReloading(CacheLoader<K,V> loader,
Executor executor)
|
static <K,V> CacheLoader<K,V> |
from(Function<K,V> function)
Returns a cache loader based on an existing function instance.
|
static <V> CacheLoader<Object,V> |
from(Supplier<V> supplier)
Returns a cache loader based on an existing supplier instance.
|
abstract V |
load(K key)
Computes or retrieves the value corresponding to
key . |
Map<K,V> |
loadAll(Iterable<? extends K> keys)
Computes or retrieves the values corresponding to
keys . |
ListenableFuture<V> |
reload(K key,
V oldValue)
Computes or retrieves a replacement value corresponding to an already-cached
key . |
protected CacheLoader()
public abstract V load(K key) throws Exception
key
.key
- the non-null key whose value should be loadedkey
; must not be nullException
- if unable to load the resultInterruptedException
- if this method is interrupted. InterruptedException
is
treated like any other Exception
in all respects except that, when it is caught,
the thread's interrupt status is set@GwtIncompatible public ListenableFuture<V> reload(K key, V oldValue) throws Exception
key
. This
method is called when an existing cache entry is refreshed by
CacheBuilder.refreshAfterWrite(long, java.util.concurrent.TimeUnit)
, or through a call to LoadingCache.refresh(K)
.
This implementation synchronously delegates to load(K)
. It is recommended that it be
overridden with an asynchronous implementation when using
CacheBuilder.refreshAfterWrite(long, java.util.concurrent.TimeUnit)
.
Note: all exceptions thrown by this method will be logged and then swallowed.
key
- the non-null key whose value should be loadedoldValue
- the non-null old value corresponding to key
key
; must not be null, must not return
nullException
- if unable to reload the resultInterruptedException
- if this method is interrupted. InterruptedException
is
treated like any other Exception
in all respects except that, when it is caught,
the thread's interrupt status is setpublic Map<K,V> loadAll(Iterable<? extends K> keys) throws Exception
keys
. This method is called by
LoadingCache.getAll(java.lang.Iterable<? extends K>)
.
If the returned map doesn't contain all requested keys
then the entries it does
contain will be cached, but getAll
will throw an exception. If the returned map
contains extra keys not present in keys
then all returned entries will be cached, but
only the entries for keys
will be returned from getAll
.
This method should be overridden when bulk retrieval is significantly more efficient than
many individual lookups. Note that LoadingCache.getAll(java.lang.Iterable<? extends K>)
will defer to individual calls
to LoadingCache.get(K)
if this method is not overridden.
keys
- the unique, non-null keys whose values should be loadedkeys
to the value associated with that key; may not
contain null valuesException
- if unable to load the resultInterruptedException
- if this method is interrupted. InterruptedException
is
treated like any other Exception
in all respects except that, when it is caught,
the thread's interrupt status is setpublic static <K,V> CacheLoader<K,V> from(Function<K,V> function)
CacheLoader
and
implement load
instead.function
- the function to be used for loading values; must never return null
function
public static <V> CacheLoader<Object,V> from(Supplier<V> supplier)
CacheLoader
and
implement load
instead.supplier
- the supplier to be used for loading values; must never return null
Supplier.get()
, irrespective of the
key@GwtIncompatible public static <K,V> CacheLoader<K,V> asyncReloading(CacheLoader<K,V> loader, Executor executor)
CacheLoader
which wraps loader
, executing calls to
reload(K, V)
using executor
.
This method is useful only when loader.reload
has a synchronous implementation, such
as the default implementation.
Copyright © 2010-2017. All Rights Reserved.