1. 概述
缓存数据意味着我们的应用程序无需访问较慢的存储层，从而提高性能和响应速度。我们可以使用任何内存实现库（如Caffeine）来实现缓存。
尽管这样做提高了数据检索的性能，但如果应用程序部署到多个副本集，那么缓存不会在实例之间共享。为了解决这个问题，我们可以引入一个所有实例都可以访问的分布式缓存层。
在本教程中，我们将学习如何在Spring中实现二级缓存机制。我们将演示如何使用Spring的缓存支持来实现这两个层，以及当本地缓存层发生缓存未命中时如何调用分布式缓存层。
2. Spring Boot示例应用
假设我们需要构建一个简单的应用程序，它调用数据库来获取一些数据。
2.1. Maven依赖
首先，我们包含spring-boot-starter-web依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>3.1.5</version>
</dependency>
2.2. 实现Spring服务
我们将实现一个从存储库获取数据的Spring服务。
首先，让我们定义Customer类：
public class Customer implements Serializable {
private String id;
private String name;
private String email;
// 标准getter和setter
}
然后，我们实现CustomerService类和一个getCustomer方法：
@Service
public class CustomerService {
private final CustomerRepository customerRepository;
public Customer getCustomer(String id) {
return customerRepository.getCustomerById(id);
}
}
最后，我们定义CustomerRepository接口：
public interface CustomerRepository extends CrudRepository<Customer, String> {
}
现在，我们将实现两级缓存。
3. 实现第一级缓存
我们将利用Spring的缓存支持和Caffeine库来实现第一级缓存。
3.1. Caffeine依赖
让我们包含spring-boot-starter-cache和caffeine依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
<version>3.1.5</version>
</dependency>
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
<version>3.1.8</version>
</dependency>
3.2. 启用Caffeine缓存
要启用Caffeine缓存，我们需要添加一些缓存相关的配置。
首先，我们在CacheConfig类中添加@EnableCaching注解，并包含一些Caffeine缓存配置：
@Configuration
@EnableCaching
public class CacheConfig {
@Bean
public CaffeineCache caffeineCacheConfig() {
return new CaffeineCache("customerCache", Caffeine.newBuilder()
.expireAfterWrite(Duration.ofMinutes(1))
.initialCapacity(1)
.maximumSize(2000)
.build());
}
}
接下来，我们使用SimpleCacheManager类添加CaffeineCacheManager bean并设置缓存配置：
@Bean
public CacheManager caffeineCacheManager(CaffeineCache caffeineCache) {
SimpleCacheManager manager = new SimpleCacheManager();
manager.setCaches(Arrays.asList(caffeineCache));
return manager;
}
3.3. 添加@Cacheable注解
要启用上述缓存，我们需要在getCustomer方法中添加@Cacheable注解：
@Cacheable(cacheNames = "customerCache", cacheManager = "caffeineCacheManager")
public Customer getCustomer(String id) {
}
如前所述，这在单实例部署环境中效果很好，但当应用程序运行多个副本时效果不佳。
4. 实现第二级缓存
我们将使用Redis服务器实现第二级缓存。当然，我们也可以使用任何其他分布式缓存（如Memcached）。这一层缓存可以被我们应用程序的所有副本访问。
4.1. Redis依赖
让我们添加spring-boot-starter-data-redis依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>3.1.5</version>
</dependency>
4.2. 启用Redis缓存
我们需要添加Redis缓存相关的配置以在应用程序中启用它。
首先，让我们配置RedisCacheConfiguration bean并设置一些属性：
@Bean
public RedisCacheConfiguration cacheConfiguration() {
return RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofMinutes(5))
.disableCachingNullValues()
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
}
然后，我们使用RedisCacheManager类启用CacheManager：
@Bean
public CacheManager redisCacheManager(RedisConnectionFactory connectionFactory, RedisCacheConfiguration cacheConfiguration) {
return RedisCacheManager.RedisCacheManagerBuilder
.fromConnectionFactory(connectionFactory)
.withCacheConfiguration("customerCache", cacheConfiguration)
.build();
}
4.3. 添加@Caching和@Cacheable注解
我们将使用@Caching和@Cacheable注解将第二级缓存包含在getCustomer方法中：
@Caching(cacheable = {
@Cacheable(cacheNames = "customerCache", cacheManager = "caffeineCacheManager"),
@Cacheable(cacheNames = "customerCache", cacheManager = "redisCacheManager")
})
public Customer getCustomer(String id) {
}
请注意，Spring将从第一个可用的缓存中获取缓存对象。如果两个缓存管理器都未命中，它将运行实际方法。
5. 实现集成测试
为了验证我们的设置，我们将实现一些集成测试并验证两个缓存。
首先，我们将创建一个集成测试，使用嵌入式Redis服务器来验证两个缓存：
@Test
void givenCustomerIsPresent_whenGetCustomerCalled_thenReturnCustomerAndCacheIt() {
String CUSTOMER_ID = "100";
Customer customer = new Customer(CUSTOMER_ID, "test", "test@example.com");
given(customerRepository.findById(CUSTOMER_ID))
.willReturn(customer);
Customer customerCacheMiss = customerService.getCustomer(CUSTOMER_ID);
assertThat(customerCacheMiss).isEqualTo(customer);
verify(customerRepository, times(1)).findById(CUSTOMER_ID);
assertThat(caffeineCacheManager.getCache("customerCache").get(CUSTOMER_ID).get()).isEqualTo(customer);
assertThat(redisCacheManager.getCache("customerCache").get(CUSTOMER_ID).get()).isEqualTo(customer);
}
我们将运行上述测试用例，发现它运行正常。
接下来，让我们想象一个场景：第一级缓存数据因过期而被逐出，然后我们尝试获取相同的客户。那么这应该是第二级缓存Redis的命中。同一客户的任何进一步缓存命中都应该是第一级缓存。
让我们实现上述测试场景，在本地缓存过期后检查两个缓存：
@Test
void givenCustomerIsPresent_whenGetCustomerCalledTwiceAndFirstCacheExpired_thenReturnCustomerAndCacheIt() throws InterruptedException {
String CUSTOMER_ID = "102";
Customer customer = new Customer(CUSTOMER_ID, "test", "test@example.com");
given(customerRepository.findById(CUSTOMER_ID))
.willReturn(customer);
Customer customerCacheMiss = customerService.getCustomer(CUSTOMER_ID);
TimeUnit.SECONDS.sleep(3);
Customer customerCacheHit = customerService.getCustomer(CUSTOMER_ID);
verify(customerRepository, times(1)).findById(CUSTOMER_ID);
assertThat(customerCacheMiss).isEqualTo(customer);
assertThat(customerCacheHit).isEqualTo(customer);
assertThat(caffeineCacheManager.getCache("customerCache").get(CUSTOMER_ID).get()).isEqualTo(customer);
assertThat(redisCacheManager.getCache("customerCache").get(CUSTOMER_ID).get()).isEqualTo(customer);
}
当我们运行上述测试时，我们将看到Caffeine缓存对象出现意外的断言错误：
org.opentest4j.AssertionFailedError:
expected: Customer(id=102, name=test, test@example.com)
but was: null
...
at com.baeldung.caching.twolevelcaching.CustomerServiceCachingIntegrationTest.
givenCustomerIsPresent_whenGetCustomerCalledTwiceAndFirstCacheExpired_thenReturnCustomerAndCacheIt(CustomerServiceCachingIntegrationTest.java:91)
从上面的日志中可以明显看出，客户对象在逐出后不在Caffeine缓存中，即使我们再次调用相同的方法，它也不会从第二级缓存恢复。对于这个用例来说，这不是理想的情况，因为每当第一级缓存过期时，它永远不会更新，直到第二级缓存也过期。这会给Redis缓存带来额外的负载。
请注意，Spring不会管理多个缓存之间的任何数据，即使它们是为同一个方法声明的。
这告诉我们我们需要在再次访问第一级缓存时更新它。
6. 实现自定义CacheInterceptor
为了更新第一级缓存，我们需要实现一个自定义缓存拦截器，以便在访问缓存时进行拦截。
我们将添加一个拦截器来检查当前缓存类是否为Redis类型，如果本地缓存不存在，那么我们可以更新缓存值。
让我们通过重写doGet方法来实现自定义CacheInterceptor：
public class CustomerCacheInterceptor extends CacheInterceptor {
private final CacheManager caffeineCacheManager;
@Override
protected Cache.ValueWrapper doGet(Cache cache, Object key) {
Cache.ValueWrapper existingCacheValue = super.doGet(cache, key);
if (existingCacheValue != null && cache.getClass() == RedisCache.class) {
Cache caffeineCache = caffeineCacheManager.getCache(cache.getName());
if (caffeineCache != null) {
caffeineCache.putIfAbsent(key, existingCacheValue.get());
}
}
return existingCacheValue;
}
}
我们还需要注册CustomerCacheInterceptor bean以启用它：
@Bean
public CacheInterceptor cacheInterceptor(CacheManager caffeineCacheManager, CacheOperationSource cacheOperationSource) {
CacheInterceptor interceptor = new CustomerCacheInterceptor(caffeineCacheManager);
interceptor.setCacheOperationSources(cacheOperationSource);
return interceptor;
}
@Bean
public CacheOperationSource cacheOperationSource() {
return new AnnotationCacheOperationSource();
}
请注意，自定义拦截器将在Spring代理方法内部调用get缓存方法时拦截调用。
我们将重新运行集成测试，并看到上述测试用例通过。
7. 结论
在本文中，我们学习了如何使用Spring的缓存支持与Caffeine和Redis实现两级缓存。我们还演示了如何使用自定义缓存拦截器实现来更新第一级Caffeine缓存。
一如既往，示例代码可以在GitHub上找到。