Class CacheLoader<K,V>
- java.lang.Object
-
- com.google.common.cache.CacheLoader<K,V>
-
@GwtCompatible(emulated=true) public abstract class CacheLoader<K,V> extends java.lang.Object
Computes or retrieves values, based on a key, for use in populating aLoadingCache
.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);
Since this example doesn't support reloading or bulk loading, if you're able to use lambda expressions it can be specified even more easily:
CacheLoader<Key, Graph> loader = CacheLoader.from(key -> createExpensiveGraph(key));
- Since:
- 10.0
- Author:
- Charles Fry
-
-
Nested Class Summary
Nested Classes Modifier and Type Class Description static class
CacheLoader.InvalidCacheLoadException
Thrown to indicate that an invalid response was returned from a call toCacheLoader
.static class
CacheLoader.UnsupportedLoadingOperationException
Exception thrown byloadAll()
to indicate that it is not supported.
-
Constructor Summary
Constructors Modifier Constructor Description protected
CacheLoader()
Constructor for use by subclasses.
-
Method Summary
All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Modifier and Type Method Description static <K,V>
CacheLoader<K,V>asyncReloading(CacheLoader<K,V> loader, java.util.concurrent.Executor executor)
static <K,V>
CacheLoader<K,V>from(Function<K,V> function)
Returns a cache loader that usesfunction
to load keys, and without supporting either reloading or bulk loading.static <V> CacheLoader<java.lang.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 tokey
.java.util.Map<K,V>
loadAll(java.lang.Iterable<? extends K> keys)
Computes or retrieves the values corresponding tokeys
.ListenableFuture<V>
reload(K key, V oldValue)
Computes or retrieves a replacement value corresponding to an already-cachedkey
.
-
-
-
Constructor Detail
-
CacheLoader
protected CacheLoader()
Constructor for use by subclasses.
-
-
Method Detail
-
load
public abstract V load(K key) throws java.lang.Exception
Computes or retrieves the value corresponding tokey
.- Parameters:
key
- the non-null key whose value should be loaded- Returns:
- the value associated with
key
; must not be null - Throws:
java.lang.Exception
- if unable to load the resultjava.lang.InterruptedException
- if this method is interrupted.InterruptedException
is treated like any otherException
in all respects except that, when it is caught, the thread's interrupt status is set
-
reload
@GwtIncompatible public ListenableFuture<V> reload(K key, V oldValue) throws java.lang.Exception
Computes or retrieves a replacement value corresponding to an already-cachedkey
. This method is called when an existing cache entry is refreshed byCacheBuilder.refreshAfterWrite(long, java.util.concurrent.TimeUnit)
, or through a call toLoadingCache.refresh(K)
.This implementation synchronously delegates to
load(K)
. It is recommended that it be overridden with an asynchronous implementation when usingCacheBuilder.refreshAfterWrite(long, java.util.concurrent.TimeUnit)
.Note: all exceptions thrown by this method will be logged and then swallowed.
- Parameters:
key
- the non-null key whose value should be loadedoldValue
- the non-null old value corresponding tokey
- Returns:
- the future new value associated with
key
; must not be null, must not return null - Throws:
java.lang.Exception
- if unable to reload the resultjava.lang.InterruptedException
- if this method is interrupted.InterruptedException
is treated like any otherException
in all respects except that, when it is caught, the thread's interrupt status is set- Since:
- 11.0
-
loadAll
public java.util.Map<K,V> loadAll(java.lang.Iterable<? extends K> keys) throws java.lang.Exception
Computes or retrieves the values corresponding tokeys
. This method is called byLoadingCache.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, butgetAll
will throw an exception. If the returned map contains extra keys not present inkeys
then all returned entries will be cached, but only the entries forkeys
will be returned fromgetAll
.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 toLoadingCache.get(K)
if this method is not overridden.- Parameters:
keys
- the unique, non-null keys whose values should be loaded- Returns:
- a map from each key in
keys
to the value associated with that key; may not contain null values - Throws:
java.lang.Exception
- if unable to load the resultjava.lang.InterruptedException
- if this method is interrupted.InterruptedException
is treated like any otherException
in all respects except that, when it is caught, the thread's interrupt status is set- Since:
- 11.0
-
from
public static <K,V> CacheLoader<K,V> from(Function<K,V> function)
Returns a cache loader that usesfunction
to load keys, and without supporting either reloading or bulk loading. This is most useful when you can pass a lambda expression. Otherwise it is useful mostly when you already have an existing function instance.The returned object is serializable if
function
is serializable.- Parameters:
function
- the function to be used for loading values; must never returnnull
- Returns:
- a cache loader that loads values by passing each key to
function
-
from
public static <V> CacheLoader<java.lang.Object,V> from(Supplier<V> supplier)
Returns a cache loader based on an existing supplier instance. Note that there's no need to create a new supplier just to pass it in here; just subclassCacheLoader
and implementload
instead.The returned object is serializable if
supplier
is serializable.- Parameters:
supplier
- the supplier to be used for loading values; must never returnnull
- Returns:
- a cache loader that loads values by calling
Supplier.get()
, irrespective of the key
-
asyncReloading
@GwtIncompatible public static <K,V> CacheLoader<K,V> asyncReloading(CacheLoader<K,V> loader, java.util.concurrent.Executor executor)
Returns aCacheLoader
which wrapsloader
, executing calls toreload(K, V)
usingexecutor
.This method is useful only when
loader.reload
has a synchronous implementation, such as the default implementation.- Since:
- 17.0
-
-