Springboot 2.X中Spring-cache与redis整合

本文转自：Springboot 2.X中Spring-cache与redis整合

Springboot 2.X中Spring-cache与redis整合

Springboot中Spring-cache与redis整合。这也是一个不错的框架，与spring的事务使用类似，只要添加一些注解方法，就可以动态的去操作缓存了，减少代码的操作。如果这些注解不满足项目的需求，我们也可以参考spring-cache的实现思想，使用AOP代理+缓存操作来管理缓存的使用。

在这个例子中我使用的是redis，当然，因为spring-cache的存在，我们可以整合多样的缓存技术，例如Ecache、Mamercache等。

1. 在pom.xml中添加以下依赖

	org.springframework.boot
	spring-boot-starter-cache


	org.springframework.boot
	spring-boot-starter-data-redis


    org.springframework.boot
    spring-boot-starter-web

注意：spring-boot-starter-web默认引入了以下jackson相关的依赖：

        com.fasterxml.jackson.core
        jackson-annotations
        2.8.0


        com.fasterxml.jackson.core
        jackson-core
        2.8.7


        com.fasterxml.jackson.core
        jackson-databind
        2.8.7

2. redis客户端配置

无论使用spring-boot的哪个版本，我们都需要先配置redis连接，两个版本的redis客户端连接池使用有所不同。

spring-boot版本	默认客户端类型
1.5.x	jedis
2.x	lettuce

在1.5.x中，我们配置jedis连接池只需要配置 spring.redis.pool.* 开始的配置即可，如下配置

spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.pool.min-idle=0
spring.redis.pool.max-idle=8

但在2.x版本中由于引入了不同的客户端，需要指定配置哪种连接池，如下配置

在application.properties中添加如下代码:

# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接超时时间（毫秒）
spring.redis.timeout=500ms

# 设置缓存默认超过期时间为30秒  
spring.cache.redis.time-to-live.seconds=10

#jedis
# 连接池最大连接数（使用负值表示没有限制）
#spring.redis.jedis.pool.max-active=8  
# 连接池最大阻塞等待时间（使用负值表示没有限制）
#spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
#spring.redis.jedis.pool.max-idle=8  
# 连接池中的最小空闲连接
#spring.redis.jedis.pool.min-idle=0
 
#lettuce客户端   
spring.redis.lettuce.pool.min-idle=0  
spring.redis.lettuce.pool.max-idle=8  
spring.redis.lettuce.pool.max-wait=-1
spring.redis.lettuce.pool.max-active=8  
spring.redis.lettuce.shutdown-timeout=100

注：spring.redis.timeout 不要配置成0，对于 lettuce，会报这个错：io.lettuce.core.RedisCommandTimeoutException: Command timed out

3. JavaConfig方式配置

通用配置方式只能满足整个程序所有缓存都采用相同公共配置的方式，如果需要特殊处理，如我们的案列，则需要自己采用代码的方式来配置。
采用代码的方式，只要需要配置的是CacheMananger，采用Redis时具体实现我们需要使用其子类RedisCacheMananger来做配置

• 创建redis的配置类RedisConfig.java
• 注意一定要在类上加上以下两个注解:
• @Configuration 可理解为用spring的时候xml里面的标签
• @EnableCaching 注解是spring framework中的注解驱动的缓存管理功能。

package com.johnfnash.learn.redis.config;

import java.lang.reflect.Method;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
@EnableCaching // Enables Spring's annotation-driven cache management capability
public class RedisConfig extends CachingConfigurerSupport {
    @Value("${spring.redis.host}")
    private String hostName;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.cache.redis.time-to-live.seconds}")
    private int entryTTL;

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(hostName, port);
        return new LettuceConnectionFactory(config);
    }

    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            // 当没有指定缓存的 key时来根据类名、方法名和方法参数来生成key
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append('.').append(method.getName());
                if(params.length > 0) {
                    sb.append('[');
                    for (Object obj : params) {
                        sb.append(obj.toString());
                    }
                    sb.append(']');
                }
                System.out.println("keyGenerator=" + sb.toString());
                return sb.toString();
            }
        };
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        return new RedisCacheManager(
                 RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory),
                 this.getRedisCacheConfigurationWithTtl(entryTTL),  // 默认策略，未配置的 key 会使用这个
                 this.getRedisCacheConfigurationMap()               // 指定 key 策略
            );
    }

    private Map getRedisCacheConfigurationMap() {
        Map redisCacheConfigurationMap = new HashMap();
        redisCacheConfigurationMap.put("user", this.getRedisCacheConfigurationWithTtl(30)); // 单独设置某些cache的超时时间
        return redisCacheConfigurationMap;
    }

    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        // 设置CacheManager的值序列化方式为JdkSerializationRedisSerializer,
        // 但其实RedisCacheConfiguration默认就是使用StringRedisSerializer序列化key，
        // JdkSerializationRedisSerializer序列化value,所以以下注释代码为默认实现
        // ClassLoader loader = this.getClass().getClassLoader();
        // JdkSerializationRedisSerializer jdkSerializer = new
        // JdkSerializationRedisSerializer(loader);
        // RedisSerializationContext.SerializationPair