SpringBoot 2.x 整合 redis 做缓存,并支持自定义过期时间

SpringBoot 2.2.0是最新版本，至少在我写这篇文章的此时此刻，为啥用最新版本？因为最新版本的改动相较于2.2.0之前的版本对于redis还是有些改动，所以上新版本之前大伙要注意一下这个问题，我们使用redis接管spring的缓存机制，用于直接使用@Cacheable标记来缓存结果，并随意设定过期时间。

一、redis的相关配置

1、引入spring-redis的依赖

<!-- spring boot redis集成 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- spring boot redis连接池集成 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>

2、配置redis数据库

redis:
database: 3
host: tst.mindmedia.cn
port: 6379
password: M1ndmed1a
timeout: 60000
lettuce: #由于Spring Boot2.x 的改动，连接池相关配置需要通过spring.redis.lettuce.pool或者 spring.redis.jedis.pool 进行配置
pool:
max-active: 200 #连接池最大连接数(使用负值表示没有限制) 默认8
max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
min-idle: 0 #连接池中的最小空闲连接
max-idle: 10 #连接池中的最大空闲连接

3、配置CacheManager

/**
* redis配置类
*
* @author guoyong
* @date 0001/2019-11-11 上午 11:48
*/
@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {
/**
* 默认缓存的过期时间，该过期时间将作用于没有指定过期时间的缓存上
*/
private static final Duration timeToLive = Duration.ofHours(1);

@Bean(name = "redisTemplate")
public RedisTemplate<String, Object redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object template = new RedisTemplate<();
template.setConnectionFactory(redisConnectionFactory);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jdk提供的
template.setValueSerializer(new JdkSerializationRedisSerializer());
// hash的value序列化方式采用jdk提供的
template.setHashValueSerializer(new JdkSerializationRedisSerializer());template.afterPropertiesSet();
return template;
}

@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
RedisSerializer<String redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer<Object jackson2JsonRedisSerializer = getJackson2JsonRedisSerializer();
// 配置序列化（解决乱码的问题）.disableCachingNullValues() 是否允许缓存空值
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
.computePrefixWith(keyPrefix()).entryTtl(timeToLive);
RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
return new RedisAutoCacheManager(redisCacheWriter, redisCacheConfiguration);
}

private Jackson2JsonRedisSerializer<Object getJackson2JsonRedisSerializer() {
Jackson2JsonRedisSerializer<Object jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<(Object.class);
//解决查询缓存转换异常的问题
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.activateDefaultTyping(om.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
return jackson2JsonRedisSerializer;
}

/**
* 缓存前缀（追加一个冒号 : ）官方的keyPrefix为给key值末尾追加两个冒号，不知何故，所以这里自定义一下
*
* @return
*/
private CacheKeyPrefix keyPrefix() {
return name - name + ":";
}
}

/**
* 重载RedisCacheManager就为了自定义缓存的过期时间
*
* @author guoyong
* @date 0001/2019-11-11 上午 11:54
*/
public class RedisAutoCacheManager extends RedisCacheManager {

private static final String SPLIT_FLAG = "#";
private static final int CACHE_LENGTH = 2;

public RedisAutoCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
super(cacheWriter, defaultCacheConfiguration);
}

@Override
protected Collection<RedisCache loadCaches() {
return super.loadCaches();
}

@Override
protected RedisCache getMissingCache(String name) {
return super.getMissingCache(name);
}

@Override
public Map<String, RedisCacheConfiguration getCacheConfigurations() {
return super.getCacheConfigurations();
}

@Override
protected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {
if (StringUtils.isBlank(name) || !name.contains(SPLIT_FLAG)) {
return super.createRedisCache(name, cacheConfig);
}
String[] cacheArray = name.split(SPLIT_FLAG);
if (cacheArray.length < CACHE_LENGTH) {
return super.createRedisCache(name, cacheConfig);
}
if (cacheConfig != null) {
long cacheAge = Long.parseLong(cacheArray[1]);
name = name.substring(0, name.lastIndexOf(SPLIT_FLAG));
cacheConfig = cacheConfig.entryTtl(Duration.ofSeconds(cacheAge));
}
return super.createRedisCache(name, cacheConfig);
}

@Override
public void setTransactionAware(boolean transactionAware) {
super.setTransactionAware(transactionAware);
}

@Override
public boolean isTransactionAware() {
return super.isTransactionAware();
}

@Override
protected Cache decorateCache(Cache cache) {
return super.decorateCache(cache);
}

@Override
public void afterPropertiesSet() {
super.afterPropertiesSet();
}

@Override
public void initializeCaches() {
super.initializeCaches();
}

@Override
public Cache getCache(String name) {
return super.getCache(name);
}

@Override
public Collection<String getCacheNames() {
return super.getCacheNames();
}

@Override
public int hashCode() {
return super.hashCode();
}

@Override
public boolean equals(Object obj) {
return super.equals(obj);
}

@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}

@Override
public String toString() {
return super.toString();
}

@Override
protected void finalize() throws Throwable {
super.finalize();
}
}

排版真的一件令人痛苦的事情，从事程序员这个行业这么久，从CSDN上看了无数的文章，今天终于还是忍不住把最近对springboot 2相关的研究发上来跟大家交流，有问题随时找我沟通,在放1个使用示例

/**
* 用户信息缓存24小时，redis过期时间为秒
*/
private static final String MP_KEY_MEM_APP = "MP:KEY:MEM:APP#" + 24 * 3600;

@Autowired
private MpMemberMapper mpMemberMapper;

@Cacheable(value = MP_KEY_MEM_APP, key = "#mpAppId+':'+#openId")
public MpMember getMpMember(String mpAppId, String openId) {
MpMember mpMemberSearch = new MpMember();
mpMemberSearch.setMpAppId(mpAppId);
mpMemberSearch.setOpenId(openId);
log.debug("getMpMember by Db mpAppId {} openId {}", mpAppId, openId);
return mpMemberMapper.selectOne(mpMemberSearch);
}

@CacheEvict(value = MP_KEY_MEM_APP, key = "#mpMember.mpAppId+':'+#mpMember.openId")
public int insert(MpMember mpMember) {
mpMember.initInsert();
return mpMemberMapper.insert(mpMember);
}

@CacheEvict(value = MP_KEY_MEM_APP, key = "#mpMember.mpAppId+':'+#mpMember.openId")
public int updateByPrimaryKeySelective(MpMember mpMember) {
mpMember.initUpdate();
return mpMemberMapper.updateByPrimaryKeySelective(mpMember);
}

集成时碰到的问题

// value序列化方式采用jdk提供的
template.setValueSerializer(new JdkSerializationRedisSerializer());
// hash的value序列化方式采用jdk提供的
template.setHashValueSerializer(new JdkSerializationRedisSerializer());

这两个值的序列化方式过变更为Jackson2JsonRedisSerializer的话，使用@Cacheable标记缓存的结果将无法被正常读取出来，会抛解析异常，具体机理我没有仔细研究，有知道的小伙伴欢迎diss我，然后告诉我具体原因

RedisCacheConfiguration.disableCachingNullValues()

是否允许缓存空值，这个值需要特别关注一下，如果启用了，会导致使用@Cacheable缓存标记时会缓存空值，可能会导致非预期的结果，因为有些业务因为时效性的原因是不允许缓存空结果的