001/*
002 * Copyright (C) 2011 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 */
014
015package com.google.common.cache;
016
017import static com.google.common.base.Preconditions.checkNotNull;
018
019import com.google.common.annotations.GwtCompatible;
020import com.google.common.annotations.GwtIncompatible;
021import com.google.common.base.Function;
022import com.google.common.base.Supplier;
023import com.google.common.util.concurrent.Futures;
024import com.google.common.util.concurrent.ListenableFuture;
025import com.google.common.util.concurrent.ListenableFutureTask;
026import java.io.Serializable;
027import java.util.Map;
028import java.util.concurrent.Callable;
029import java.util.concurrent.Executor;
030
031/**
032 * Computes or retrieves values, based on a key, for use in populating a {@link LoadingCache}.
033 *
034 * <p>Most implementations will only need to implement {@link #load}. Other methods may be
035 * overridden as desired.
036 *
037 * <p>Usage example:
038 *
039 * <pre>{@code
040 * CacheLoader<Key, Graph> loader = new CacheLoader<Key, Graph>() {
041 *   public Graph load(Key key) throws AnyException {
042 *     return createExpensiveGraph(key);
043 *   }
044 * };
045 * LoadingCache<Key, Graph> cache = CacheBuilder.newBuilder().build(loader);
046 * }</pre>
047 *
048 * <p>Since this example doesn't support reloading or bulk loading, it can also be specified much
049 * more simply:
050 *
051 * <pre>{@code
052 * CacheLoader<Key, Graph> loader = CacheLoader.from(key -> createExpensiveGraph(key));
053 * }</pre>
054 *
055 * @author Charles Fry
056 * @since 10.0
057 */
058@GwtCompatible(emulated = true)
059public abstract class CacheLoader<K, V> {
060  /**
061   * Constructor for use by subclasses.
062   */
063  protected CacheLoader() {}
064
065  /**
066   * Computes or retrieves the value corresponding to {@code key}.
067   *
068   * @param key the non-null key whose value should be loaded
069   * @return the value associated with {@code key}; <b>must not be null</b>
070   * @throws Exception if unable to load the result
071   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is
072   *     treated like any other {@code Exception} in all respects except that, when it is caught,
073   *     the thread's interrupt status is set
074   */
075  public abstract V load(K key) throws Exception;
076
077  /**
078   * Computes or retrieves a replacement value corresponding to an already-cached {@code key}. This
079   * method is called when an existing cache entry is refreshed by
080   * {@link CacheBuilder#refreshAfterWrite}, or through a call to {@link LoadingCache#refresh}.
081   *
082   * <p>This implementation synchronously delegates to {@link #load}. It is recommended that it be
083   * overridden with an asynchronous implementation when using
084   * {@link CacheBuilder#refreshAfterWrite}.
085   *
086   * <p><b>Note:</b> <i>all exceptions thrown by this method will be logged and then swallowed</i>.
087   *
088   * @param key the non-null key whose value should be loaded
089   * @param oldValue the non-null old value corresponding to {@code key}
090   * @return the future new value associated with {@code key}; <b>must not be null, must not return
091   *     null</b>
092   * @throws Exception if unable to reload the result
093   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is
094   *     treated like any other {@code Exception} in all respects except that, when it is caught,
095   *     the thread's interrupt status is set
096   * @since 11.0
097   */
098  @GwtIncompatible // Futures
099  public ListenableFuture<V> reload(K key, V oldValue) throws Exception {
100    checkNotNull(key);
101    checkNotNull(oldValue);
102    return Futures.immediateFuture(load(key));
103  }
104
105  /**
106   * Computes or retrieves the values corresponding to {@code keys}. This method is called by
107   * {@link LoadingCache#getAll}.
108   *
109   * <p>If the returned map doesn't contain all requested {@code keys} then the entries it does
110   * contain will be cached, but {@code getAll} will throw an exception. If the returned map
111   * contains extra keys not present in {@code keys} then all returned entries will be cached, but
112   * only the entries for {@code keys} will be returned from {@code getAll}.
113   *
114   * <p>This method should be overridden when bulk retrieval is significantly more efficient than
115   * many individual lookups. Note that {@link LoadingCache#getAll} will defer to individual calls
116   * to {@link LoadingCache#get} if this method is not overridden.
117   *
118   * @param keys the unique, non-null keys whose values should be loaded
119   * @return a map from each key in {@code keys} to the value associated with that key; <b>may not
120   *     contain null values</b>
121   * @throws Exception if unable to load the result
122   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is
123   *     treated like any other {@code Exception} in all respects except that, when it is caught,
124   *     the thread's interrupt status is set
125   * @since 11.0
126   */
127  public Map<K, V> loadAll(Iterable<? extends K> keys) throws Exception {
128    // This will be caught by getAll(), causing it to fall back to multiple calls to
129    // LoadingCache.get
130    throw new UnsupportedLoadingOperationException();
131  }
132
133  /**
134   * Returns a cache loader that uses {@code function} to load keys, without supporting either
135   * reloading or bulk loading. This allows creating a cache loader using a lambda expression.
136   *
137   * @param function the function to be used for loading values; must never return {@code null}
138   * @return a cache loader that loads values by passing each key to {@code function}
139   */
140  public static <K, V> CacheLoader<K, V> from(Function<K, V> function) {
141    return new FunctionToCacheLoader<K, V>(function);
142  }
143
144  private static final class FunctionToCacheLoader<K, V> extends CacheLoader<K, V>
145      implements Serializable {
146    private final Function<K, V> computingFunction;
147
148    public FunctionToCacheLoader(Function<K, V> computingFunction) {
149      this.computingFunction = checkNotNull(computingFunction);
150    }
151
152    @Override
153    public V load(K key) {
154      return computingFunction.apply(checkNotNull(key));
155    }
156
157    private static final long serialVersionUID = 0;
158  }
159
160  /**
161   * Returns a cache loader based on an <i>existing</i> supplier instance. Note that there's no need
162   * to create a <i>new</i> supplier just to pass it in here; just subclass {@code CacheLoader} and
163   * implement {@link #load load} instead.
164   *
165   * @param supplier the supplier to be used for loading values; must never return {@code null}
166   * @return a cache loader that loads values by calling {@link Supplier#get}, irrespective of the
167   *     key
168   */
169  public static <V> CacheLoader<Object, V> from(Supplier<V> supplier) {
170    return new SupplierToCacheLoader<V>(supplier);
171  }
172
173  /**
174   * Returns a {@code CacheLoader} which wraps {@code loader}, executing calls to
175   * {@link CacheLoader#reload} using {@code executor}.
176   *
177   * <p>This method is useful only when {@code loader.reload} has a synchronous implementation, such
178   * as {@linkplain #reload the default implementation}.
179   *
180   * @since 17.0
181   */
182  @GwtIncompatible // Executor + Futures
183  public static <K, V> CacheLoader<K, V> asyncReloading(
184      final CacheLoader<K, V> loader, final Executor executor) {
185    checkNotNull(loader);
186    checkNotNull(executor);
187    return new CacheLoader<K, V>() {
188      @Override
189      public V load(K key) throws Exception {
190        return loader.load(key);
191      }
192
193      @Override
194      public ListenableFuture<V> reload(final K key, final V oldValue) throws Exception {
195        ListenableFutureTask<V> task =
196            ListenableFutureTask.create(
197                new Callable<V>() {
198                  @Override
199                  public V call() throws Exception {
200                    return loader.reload(key, oldValue).get();
201                  }
202                });
203        executor.execute(task);
204        return task;
205      }
206
207      @Override
208      public Map<K, V> loadAll(Iterable<? extends K> keys) throws Exception {
209        return loader.loadAll(keys);
210      }
211    };
212  }
213
214  private static final class SupplierToCacheLoader<V> extends CacheLoader<Object, V>
215      implements Serializable {
216    private final Supplier<V> computingSupplier;
217
218    public SupplierToCacheLoader(Supplier<V> computingSupplier) {
219      this.computingSupplier = checkNotNull(computingSupplier);
220    }
221
222    @Override
223    public V load(Object key) {
224      checkNotNull(key);
225      return computingSupplier.get();
226    }
227
228    private static final long serialVersionUID = 0;
229  }
230
231  /**
232   * Exception thrown by {@code loadAll()} to indicate that it is not supported.
233   *
234   * @since 19.0
235   */
236  public static final class UnsupportedLoadingOperationException
237      extends UnsupportedOperationException {
238    // Package-private because this should only be thrown by loadAll() when it is not overridden.
239    // Cache implementors may want to catch it but should not need to be able to throw it.
240    UnsupportedLoadingOperationException() {}
241  }
242
243  /**
244   * Thrown to indicate that an invalid response was returned from a call to {@link CacheLoader}.
245   *
246   * @since 11.0
247   */
248  public static final class InvalidCacheLoadException extends RuntimeException {
249    public InvalidCacheLoadException(String message) {
250      super(message);
251    }
252  }
253}