Spring 引导本机缓存:如何按单个键/元素使缓存数据过期/删除

Question

我们正在调用联合身份验证服务来非常频繁地获取用户令牌，并且几乎在身份服务上运行负载测试。

一个潜在的解决方案是在现有应用程序中缓存用户令牌，但是使用本机弹簧缓存，我们可以使单个缓存条目过期吗？

通过下面的示例，我能够清除缓存，删除所有条目，但是我正在尝试使单个条目过期。

@Service
@CacheConfig(cacheNames =  {"userTokens"})
public class UserTokenManager {
static HashMap<String, String> userTokens = new HashMap<>();
@Cacheable
public String getUserToken(String userName){
String userToken = userTokens.get(userName);
if(userToken == null){
// call Identity service to acquire tokens
System.out.println("Adding UserName:" + userName + " Token:" + userToken);
userTokens.put(userName, userToken);
}
return userToken;
}
@CacheEvict(allEntries = true, cacheNames = { "userTokens"})
@Scheduled(fixedDelay = 3600000)
public void removeUserTokens() {
System.out.println("##############CACHE CLEANING##############, " +
"Next Cleanup scheduled at : " + new Date(System.currentTimeMillis()+ 3600000));
userTokens.clear();
}
}

Spring Boot 应用程序类如下所示：

@SpringBootApplication
@EnableCaching
@EnableScheduling
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

Answer 1

可以通过在采用缓存键的方法上使用@CacheEvict来使单个缓存条目过期。此外，通过使用 Spring 的缓存和@Cacheable，不需要 HashMap 代码(因为这实际上只是一个辅助缓存)。

简单缓存

@Service
@CacheConfig(cacheNames = {"userTokens"})
public class UserTokenManager {
private static Logger log = LoggerFactory.getLogger(UserTokenManager.class);
@Cacheable(cacheNames = {"userTokens"})
public String getUserToken(String userName) {
log.info("Fetching user token for: {}", userName);
String token = ""; //replace with call for token
return token;
}
@CacheEvict(cacheNames = {"userTokens"})
public void evictUserToken(String userName) {
log.info("Evicting user token for: {}", userName);
}
@CacheEvict(cacheNames = {"userTokens"}, allEntries = true)
public void evictAll() {
log.info("Evicting all user tokens");
}
}

例如：

1. getUserToken("Joe") -> no cache, calls API
2. getUserToken("Alice") -> no cache, calls API
3. getUserToken("Joe") -> cached
4. evictUserToken("Joe") -> evicts cache for user "Joe"
5. getUserToken("Joe") -> no cache, calls API
6. getUserToken("Alice") -> cached (as it has not been evicted)
7. evictAll() -> evicts all cache
8. getUserToken("Joe") -> no cache, calls API
9. getUserToken("Alice") -> no cache, calls API

基于 TTL 的缓存

如果您希望将令牌缓存一定时间，则除了本机 Spring 之外，还需要其他CacheManager。有多种缓存选项适用于 Spring 的@Cacheable.我将举一个使用 Caffeine 的示例，Caffeine 是 Java 8 的高性能缓存库。例如，如果您知道要将令牌缓存 30 分钟，则可能需要使用此路由。

首先，将以下依赖项添加到您的build.gradle(或者如果使用 Maven，请翻译以下内容并将其放在您的pom.xml中)。请注意，您需要使用最新版本，或者与当前 Spring 引导版本匹配的版本。

compile 'org.springframework.boot:spring-boot-starter-cache:2.1.4'
compile 'com.github.ben-manes.caffeine:caffeine:2.7.0'

添加这两个依赖项后，您所要做的就是在application.properties文件中配置caffeine规范：

spring.cache.cache-names=userTokens
spring.cache.caffeine.spec=expireAfterWrite=30m

将expireAfterWrite=30m更改为您希望代币生存的任何价值。例如，如果需要 400 秒，可以将其更改为expireAfterWrite=400s。

有用的链接：

• 咖啡因规范JavaDoc
• Spring 引导支持的缓存提供程序

Answer 2

Spring 缓存抽象是一种抽象而不是实现，因此它根本不支持显式设置 TTL，因为这是一个特定于实现的功能。例如，如果您的缓存由ConcurrentHashMap支持，则它不能支持开箱即用的 TTL。

在您的情况下，您有 2 个选择。如果你需要一个本地缓存(即每个微服务实例管理自己的缓存)，你可以用 Caffeine 替换 Spring 缓存抽象，咖啡因是由 Spring Boot 提供和管理的官方依赖项。只需要声明而不提及版本。

<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
</dependency>

然后，您可以创建缓存的实例，如下所示。您放入缓存中的每个令牌都将根据您的配置自动删除。

@Service
public class UserTokenManager {
private static Cache<String, String> tokenCache;   
@Autowired
private UserTokenManager (@Value("${token.cache.time-to-live-in-seconds}") int timeToLiveInSeconds) {
tokenCache = Caffeine.newBuilder()
.expireAfterWrite(timeToLiveInSeconds, TimeUnit.SECONDS)
// Optional listener for removal event
.removalListener((userName, tokenString, cause) -> System.out.println("TOKEN WAS REMOVED FOR USER: " + userName))
.build();
}
public String getUserToken(String userName){
// If cached, return; otherwise create, cache and return
// Guaranteed to be atomic (i.e. applied at most once per key)
return tokenCache.get(userName, userName -> this.createToken(userName));
}
private String createToken(String userName) {
// call Identity service to acquire tokens
}
}

同样，这是一个本地缓存，这意味着每个微服务将管理自己的令牌集。因此，如果您有 5 个运行同一微服务的实例，则同一用户可能在所有 5 个缓存中都有 5 个令牌，具体取决于处理其请求的实例。

另一方面，如果您需要分布式缓存(即多个微服务实例共享同一个集中式缓存)，则需要查看EHCache或Hazelcast。在这种情况下，您可以继续使用 Spring 缓存抽象，并通过从这些库中声明一个CacheManager来选择其中一个库作为您的实现(例如HazelcastCacheManager)。

然后，您可以查看相应的文档，以进一步为特定缓存(例如tokenCache)使用 TTL 配置您选择的CacheManager。我在下面提供了一个简单的 Hazelcast 配置作为示例。

@Configuration
public class DistributedCacheConfiguration {
@Bean
public HazelcastInstance hazelcastInstance(@Value("${token.cache.time-to-live-in-seconds}") int timeToLiveInSeconds) {
Config config = new Config();                  
config.setInstanceName("hazelcastInstance");

MapConfig mapConfig = config.getMapConfig("tokenCache");
mapConfig.setTimeToLiveSeconds(timeToLiveInSeconds);

return Hazelcast.newHazelcastInstance(config);
}

@Bean
public CacheManager cacheManager(HazelcastInstance hazelcastInstance) {
return new HazelcastCacheManager(hazelcastInstance);
}
}