Spring Boot Cache 整合redis 缓存 以及缓存失效期设置

本文整合了springboot cache 和 redis 缓存的配置以及使用。

1.maven依赖

# cache依赖
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
#redis依赖
<dependency>  
      <groupId>org.springframework.boot</groupId>  
      <artifactId>spring-boot-starter-data-redis</artifactId>  
  </dependency> 

2.配置文件 application.yml

（以下配置信息是整合cache和redis的重要配置信息）

至于其他配置可以根据自身需要添加，redis配置这里不在描述

spring:
  cache:
    type: redis

3.redis bean配置类

@Configuration
@ConfigurationProperties(prefix = "redis")
public class RedisConfig {

	private String hostName;
	
	private Integer port;
	
	private String password;
	
	private Integer timeout;
	
    private Integer maxIdle;

    private Integer maxTotal;

    private Integer maxWaitMillis;

    private Integer minEvictableIdleTimeMillis;

    private Integer numTestsPerEvictionRun;

    private long timeBetweenEvictionRunsMillis;

    private boolean testOnBorrow;

    private boolean testWhileIdle;

    private String clusterNodes; 

    private Integer mmaxRedirectsac;

4.配置redis连接池 和 RedisTemplate 对象

/**
 * 
* @ClassName: RedisAppConfig
* @Description: redis数据配置
* @version: V1.0
 */
@Configuration
@EnableConfigurationProperties(RedisConfig.class)
public class RedisAppConfig {

	protected final static Logger log = LoggerFactory.getLogger(RedisAppConfig.class);
	
	@Autowired
	private RedisConfig redisConfig; 
    /**
     * JedisPoolConfig 连接池
     * @return
     */
    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大空闲数
        jedisPoolConfig.setMaxIdle(redisConfig.getMaxIdle());
        // 连接池的最大数据库连接数
        jedisPoolConfig.setMaxTotal(redisConfig.getMaxTotal());
        // 最大建立连接等待时间
        jedisPoolConfig.setMaxWaitMillis(redisConfig.getMaxWaitMillis());
        // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
        jedisPoolConfig.setMinEvictableIdleTimeMillis(redisConfig.getMinEvictableIdleTimeMillis());
        // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
        jedisPoolConfig.setNumTestsPerEvictionRun(redisConfig.getNumTestsPerEvictionRun());
        // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(redisConfig.getTimeBetweenEvictionRunsMillis());
        // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
        jedisPoolConfig.setTestOnBorrow(redisConfig.isTestOnBorrow());
        // 在空闲时检查有效性, 默认false
        jedisPoolConfig.setTestWhileIdle(redisConfig.isTestWhileIdle());
        log.info("Redis连接池创建完成");
        return jedisPoolConfig;
    }
    
    
    /**
     * 实例化 RedisTemplate 对象
     *
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！  
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setStringSerializer(new StringRedisSerializer());
        // 开启事务
//        redisTemplate.setEnableTransactionSupport(true);
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        log.info("实例化 RedisTemplate 对象完成");
        return redisTemplate;
    }
    
 
}    

5.springCache 和redis 配置整合类

CacheManager 和spring boot 1.5 版本的注入方式

    //缓存管理器
    @Bean 
    public CacheManager cacheManager( RedisTemplate<String, Object> redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        //设置缓存过期时间 
        cacheManager.setDefaultExpiration(10000);
        return cacheManager;
    }

CacheManager 和spring boot 2.0 版本的注入方式

并设置了指定缓存的失效期

**
 * spring cache  整合 redis 配置
 */
@Slf4j
@Configuration
public class CacheRedisConfig {


    /**
     * CacheManager 重新注入配置
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //初始化一个RedisCacheWriter
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);

        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
        //设置默认超过期时间是30秒
//        defaultCacheConfig.entryTtl(Duration.ofSeconds(30));
        //初始化RedisCacheManager
        RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig,this.getRedisCacheConfigurationMap());
        log.info("实例化CacheManager");
        return cacheManager;
    }

    /**
     * 设置 event cacheName的失效时间
     * @return
     */
    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        redisCacheConfigurationMap.put("event", this.getRedisCacheConfigurationWithTtl(4*60*60));
//        redisCacheConfigurationMap.put("BasicDataCache", this.getRedisCacheConfigurationWithTtl(30*60));
        return redisCacheConfigurationMap;
    }

    /**
     * 缓存配置json序列化，和指定失效时间
     * @param seconds
     * @return
     */
    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }



}

启动缓存

@SpringBootApplication
@EnableCaching//启动缓存
public class BootApplication {
  public static void main(String[] args) throws Exception {
    SpringApplication.run(BootApplication.class, args);
  }
  
  

}

6.到这里配置基本完成了

下面是几个重要的注解以及对象

• |Cache 缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、 ConcurrentMapCache等

• CacheManager 缓存管理器，管理各种缓存（Cache）组件

• @Cacheable 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存

• @CacheEvict 清空缓存 @CachePut 保证方法被调用，又希望结果被缓存

• @EnableCaching 开启基于注解的缓存

• keyGenerator 缓存数据时key生成策略

• serialize 缓存数据时value序列化策略

@Cacheable/@CachePut/@CacheEvict 主要的参数

value	缓存的名称，在 spring 配置文件中定义，必须指定 至少一个	例如： @Cacheable(value=”mycache”) 或者 @Cacheable(value={”cache1”,”cache2”}
key	缓存的 key，可以为空，如果指定要按照 SpEL 表达 式编写，如果不指定，则缺省按照方法的所有参数 进行组合	例如： @Cacheable(value=”testcache”,key=”#userName”
condition	缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存/清除缓存，在 调用方法之前之后都能判断	例如： @Cacheable(value=”testcache”,condition=”#userNam e.length()>2”)
allEntries (@CacheEvict )	是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存	例如：@CachEvict(value=”testcache”,allEntries=true)
beforeInvocation (@CacheEvict)	是否在方法执行前就清空，缺省为 false，如果指定 为 true，则在方法还没有执行的时候就清空缓存， 缺省情况下，如果方法执行抛出异常，则不会清空 缓存	例如：@CachEvict(value=”testcache”， beforeInvocation=true)
unless (@CachePut) (@Cacheable)	用于否决缓存的，不像condition，该表达式只在方 法执行之后判断，此时可以拿到返回值result进行判 断。条件为true不会缓存，fasle才缓存	例如：@Cacheable(value=”testcache”,unless=”#result == null”)

关于更多的如何使用请前往

https://blog.csdn.net/weixin_36279318/article/details/82820880