您的位置：首页 > 编程语言 > Java开发

Spring Boot Cache使用方法整合代码实例

2020-03-11 17:51 597 查看

参考：

使用本地Caffeine缓存

引入依赖包

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
<version>2.6.2</version>
</dependency>

自定义Caffeine配置

CachingConfig.java

package com.vcredit.vmp.checkcenter.config;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.vcredit.vmp.checkcenter.common.properties.CaffeineCacheProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import java.time.Duration;
import java.util.*;
/**
* 缓存配置
* @author kancy
*/
@Configuration
@EnableCaching
public class CachingConfig {

@Autowired
CaffeineCacheProperties caffeineCacheProperties;

/**
* 创建基于Caffeine的Cache Manager
* @return
*/
@Bean
@Primary
@ConditionalOnProperty(prefix = "system.cache.caffeine" , name = "enabled", havingValue = "true")
public CacheManager caffeineCacheManager() {
SimpleCacheManager cacheManager = new SimpleCacheManager();
Map<String, CaffeineCache> cacheMap = new HashMap();

// 设置全局配置的本地缓存
List<String> globalCacheNames = caffeineCacheProperties.getCacheName();
if(globalCacheNames !=null && !globalCacheNames.isEmpty()){
addCacheObject(cacheMap, globalCacheNames, caffeineCacheProperties.getExpireAfterWrite(),
caffeineCacheProperties.getExpireAfterAccess(), caffeineCacheProperties.getMaximumSize());
}

// 设置自定义属性缓存, 可以覆盖全局缓存
List<CaffeineCacheProperties.Config> configs = caffeineCacheProperties.getConfigs();
if(configs != null && !configs.isEmpty()){
for (CaffeineCacheProperties.Config config : configs) {
List<String> cacheNames = config.getCacheName();
if (cacheNames == null || cacheNames.isEmpty()){
continue;
}
Duration expireAfterWrite = Optional.ofNullable(config.getExpireAfterWrite()).orElse(caffeineCacheProperties.getExpireAfterWrite());
Duration expireAfterAccess = Optional.ofNullable(config.getExpireAfterAccess()).orElse(caffeineCacheProperties.getExpireAfterAccess());
Long maximumSize = Optional.ofNullable(config.getMaximumSize()).orElse(caffeineCacheProperties.getMaximumSize());
addCacheObject(cacheMap, cacheNames, expireAfterWrite, expireAfterAccess, maximumSize);
}
}
// 加入到缓存管理器进行管理
cacheManager.setCaches(cacheMap.values());
return cacheManager;
}

private void addCacheObject(Map<String, CaffeineCache> cacheMap, List<String> cacheNames, Duration expireAfterWrite, Duration expireAfterAccess, Long maximumSize) {
for (String cacheName : cacheNames) {
// spring.cache.caffeine: maximumSize=500,expireAfterAccess=10s,expireAfterWrite=15s
Caffeine<Object, Object> recordStats = Caffeine.newBuilder().recordStats().maximumSize(maximumSize);
if(expireAfterAccess != null) recordStats.expireAfterAccess(expireAfterAccess);
if(expireAfterWrite != null) recordStats.expireAfterWrite(expireAfterWrite);
Cache<Object, Object> cache = recordStats.build();
CaffeineCache caffeineCache = new CaffeineCache(cacheName,cache);

// 覆盖添加
cacheMap.put(cacheName, caffeineCache);
}
}
}

CaffeineCacheProperties.java

package com.vcredit.vmp.checkcenter.common.properties;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import java.time.Duration;
import java.util.List;
/**
* Caffeine本地缓存自定义配置
* @author kancy
*/
@Getter
@Setter
@Configuration
@ConfigurationProperties("system.cache.caffeine")
@ConditionalOnProperty(prefix = "system.cache.caffeine" , name = "enabled", havingValue = "true")
public class CaffeineCacheProperties {
private List<String> cacheName;
private Duration expireAfterWrite;
private Duration expireAfterAccess;
private Long maximumSize = Long.valueOf(-1);
private List<Config> configs;
@Getter
@Setter
public static class Config {
private List<String> cacheName;
Duration expireAfterWrite;
Duration expireAfterAccess;
Long maximumSize;
}
}

application.yml

system.cache.caffeine:
enabled: true
# 全局配置
cacheName: cache1,cache2,cache3
expireAfterWrite: 60s
expireAfterAccess: 30s
maximumSize: 500
# 自定义配置，cacheName相同可覆盖全局
configs:
- cacheName: checkApplyCache
expireAfterAccess: 10s
- cacheName: userQueryCache
expireAfterAccess: 15s

使用缓存

@Cacheable(value = { "checkApplyCache" }, key="#req.md5")
public Result check(CheckReq req) {
// your code...
return Result.ok();
}

以上就是本文的全部内容，希望对大家的学习有所帮助

您可能感兴趣的文章:

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： Spring Boot Cache

相关文章推荐

新的分享

章节导航