Introduction to Guava CacheLoader – Guava CacheLoader简介

最后修改: 2017年 2月 16日


1. Introduction


In this article, we’ll introduce the Guava CacheLoader.

在这篇文章中,我们将介绍Guava CacheLoader

Before reading further, it’s recommended that there is a basic understanding of the LoadingCache class first. This is because the CacheLoader works with it specifically.


Essentially, the CacheLoader is a function used for computing a value in the event of it not being found in a Guava LoadingCache.

本质上,CacheLoader是一个函数,用于在Guava LoadingCache中找不到的情况下计算一个值。

2. Using a CacheLoader With a LoadingCache


When there is a cache miss with a LoadingCache, or the cache needs to be refreshed, the CacheLoader will be used for calculating values. This helps to encapsulate our caching logic in one place, making our code more cohesive.


2.1. Maven Dependency


First, let’s add our Maven dependency:



You can find the latest version in the Maven repository.


2.2. Computing and Caching Values


Now, let’s see how we can instantiate a LoadingCache with a CacheLoader:


LoadingCache<String, String> loadingCache = CacheBuilder.newBuilder()
  .build(new CacheLoader<String, String>() {
    public String load(final String s) throws Exception {
      return slowMethod(s);

Essentially, the LoadingCache will call our inline CacheLoader whenever it needs to compute a value which has not been cached. Let’s try counting how many times our slowMethod() is called when we retrieve something from cache multiple times:


String value = loadingCache.get("key");
value = loadingCache.get("key");


As we can see, it was only called once. The first time the value was not cached as it had yet to be computed. The second time, it was cached from the previous call, so we could avoid the overhead of calling our slowMethod() again.

我们可以看到,它只被调用了一次。第一次的值没有被缓存,因为它还没有被计算出来。第二次,它是在前一次调用中被缓存的,所以我们可以避免再次调用我们的slowMethod() 的开销。

2.3. Refreshing the Cache


Another common problem with caching is refreshing the cache. Although the most difficult aspect is knowing when to refresh the cache, another one is knowing how.


Solving the how is simple when using the CacheLoader. The LoadingCache will simply invoke it for each value which needs to be refreshed. Let’s try this with a test:

在使用CacheLoader时,解决如何的问题很简单。LoadingCache 将简单地为每个需要被刷新的值调用它。让我们用一个测试来试试吧。

String value = loadingCache.get("key");


Unlike our subsequent calls to get(), refresh() will force the CacheLoader to be called again, making sure our values are up to date.


3. Conclusion


In this article, we’ve explained how a LoadingCache is used by a CacheLoader in order to calculate values on cache misses, and also on cache refreshes. It’s also worth checking out this more in-depth article on Guava Caching.

在这篇文章中,我们解释了LoadingCache是如何被CacheLoader使用的,以便计算缓存错过的数值,以及缓存刷新的数值。也值得看看这篇关于Guava Caching的更深入的文章。

The implementation of these examples can be found over on GitHub. This is a Maven project, so should be easy to run as is.