Package com.google.common.cache

Class CacheLoader<K,​V>

  • @GwtCompatible(emulated=true)
public abstract class CacheLoader<K,​V>
extends Object
    Computes or retrieves values, based on a key, for use in populating a 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);

    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

    • Constructor Detail

      • CacheLoader

        protected CacheLoader()
        Constructor for use by subclasses.

    • Method Detail

      • load

        public abstract V load​(K key)
                throws Exception
        Computes or retrieves the value corresponding to key.
        Parameters:
        key - the non-null key whose value should be loaded
        Returns:
        the value associated with key; must not be null
        Throws:
        Exception - if unable to load the result
        InterruptedException - 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

      • loadAll

        public Map<K,​V> loadAll​(Iterable<? extends K> keys)
                       throws Exception
        Computes or retrieves the values corresponding to 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.

        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:
        Exception - if unable to load the result
        InterruptedException - 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
        Since:
        11.0

      • from

        @CheckReturnValue
public static <K,​V> CacheLoader<K,​V> from​(Function<K,​V> function)
        Returns a cache loader that uses function 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.
        Parameters:
        function - the function to be used for loading values; must never return null
        Returns:
        a cache loader that loads values by passing each key to function

      • from

        @CheckReturnValue
public static <V> CacheLoader<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 subclass CacheLoader and implement load instead.
        Parameters:
        supplier - the supplier to be used for loading values; must never return null
        Returns:
        a cache loader that loads values by calling Supplier.get(), irrespective of the key