1. Introduction

1.介绍

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.

在进一步阅读之前，建议先对LoadingCache类有一个基本了解。这是因为CacheLoader专门与它一起工作。

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

2.使用CacheLoader与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.

当LoadingCache出现缓存缺失，或者缓存需要被刷新时，CacheLoader将被用于计算数值。这有助于将我们的缓存逻辑封装在一个地方，使我们的代码更具凝聚力。

2.1. Maven Dependency

2.1.Maven的依赖性

First, let’s add our Maven dependency:

首先，让我们添加Maven的依赖性。

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>31.0.1-jre</version>
</dependency>

You can find the latest version in the Maven repository.

您可以在Maven资源库中找到最新版本。

2.2. Computing and Caching Values

2.2.计算和缓存值

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

现在，让我们看看如何用CacheLoadingCache实例化一个CacheLoader。

LoadingCache<String, String> loadingCache = CacheBuilder.newBuilder()
  .build(new CacheLoader<String, String>() {
    @Override
    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:

基本上，LoadingCache在需要计算一个未被缓存的值时，将调用我们的内联CacheLoader。让我们试着计算一下，当我们多次从缓存中获取某样东西时，我们的slowMethod()被调用了多少次。

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

assertThat(callCount).isEqualTo(1);
assertThat(value).isEqualTo("expectedValue");

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

2.3.刷新缓存

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");
loadingCache.refresh("key");

assertThat(callCount).isEqualTo(2);
assertThat(value).isEqualTo("key");

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

与我们随后对get()的调用不同，refresh()将强制CacheLoader再次被调用，确保我们的值是最新的。

3. Conclusion

3.结论

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.

这些例子的实现可以在GitHub上找到over。这是一个Maven项目，所以应该很容易按原样运行。