SpringBoot 整合 Redis 的配置类 RedisConfig

一、引入依赖

<!--fastjson 依赖-->
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.70</version>
</dependency>

<!--Spring boot Redis 依赖-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

二、Redis 配置 RedisConfig

@Slf4j
@Configuration
@EnableCaching
@ConditionalOnClass(RedisOperations.class)
// @EnableConfigurationProperties -> 使使用 @ConfigurationProperties 注解的类生效，即将 @ConfigurationProperties 注解的类进行一次注入
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfig extends CachingConfigurerSupport {

    /*
     * @Author wadreamer
     * @Description //TODO 设置 Redis 数据的默认过期时间，默认 6 小时
     *                     设置 @cacheable 序列化方式
     * @Date 10:06 2020/10/19
     * @Param []
     * @return org.springframework.data.redis.cache.RedisCacheConfiguration
     **/
    @Bean
    public RedisCacheConfiguration redisCacheConfiguration() {
        // 实例化 FastJsonRedisSerializer 序列化器
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);

        // 得到 Redis 的默认缓存策略
        RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig();

        // 配置 Redis 针对 value 的序列化器为 FastJsonRedisSerializer，且默认的过期时间为 6 小时
        configuration = configuration.serializeValuesWith(RedisSerializationContext.
                SerializationPair.fromSerializer(fastJsonRedisSerializer)).entryTtl(Duration.ofHours(6));

        return configuration;
    }

    /*
     * @Author wadreamer
     * @Description //TODO 使用 redisTemplate 操作 Redis
     * @Date 10:25 2020/10/19
     * @Param [redisConnectionFactory]
     * @return org.springframework.data.redis.core.RedisTemplate<java.lang.Object,java.lang.Object>
     **/
    @SuppressWarnings("all")
    @Bean(name = "redisTemplate")
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        
        // 实例化序列化器 FastJsonRedisSerializer
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);

        // value 的序列化采用 FastJsonRedisSerializer [包括 String 类型和 Hash 类型]
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);

        // 全局开启 AutoType，这里方便开发，使用全局的方式，即允许所有包的序列化和反序列化，官方不推荐使用
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        // 建议使用这种方式，小范围指定白名单，即指定小范围包的序列化和反序列化
        // ParserConfig.getGlobalInstance().addAccept("club.wadreamer.demo.entity");

        // key 的序列化采用StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        
        template.setConnectionFactory(redisConnectionFactory);

        return template;
    }

    /*
     * @Author wadreamer
     * @Description //TODO 自定义缓存 key 的生成策略，可用于 @Cacheable 和 @CacheConfig 指定序列化的 key
     * @Date 10:26 2020/10/19
     * @Param []
     * @return org.springframework.cache.interceptor.KeyGenerator
     **/
    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
            Map<String, Object> container = new HashMap<>(3);
            Class<?> targetClassClass = target.getClass();
            // 类地址
            container.put("class", targetClassClass.toGenericString());
            // 方法名称
            container.put("methodName", method.getName());
            // 包名称
            container.put("package", targetClassClass.getPackage());
            // 参数列表
            for (int i = 0; i < params.length; i++) {
                container.put(String.valueOf(i), params[i]);
            }
            // 转为JSON字符串
            String jsonString = JSON.toJSONString(container);

            // 做SHA256 Hash计算，得到一个SHA256摘要作为Key
            return DigestUtils.sha256Hex(jsonString);
        };
    }

    /*
     * @Author wadreamer
     * @Description //TODO Redis 异常处理方法
     * @Date 10:47 2020/10/19
     * @Param []
     * @return org.springframework.cache.interceptor.CacheErrorHandler
     **/
    @Bean
    @Override
    public CacheErrorHandler errorHandler() {
        // 异常处理，当 Redis 发生异常时，打印日志，但是程序仍正常走
        log.info("初始化 -> [{}]", "Redis CacheErrorHandler");
        return new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
                log.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
            }

            @Override
            public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
                log.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
            }

            @Override
            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
                log.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
            }

            @Override
            public void handleCacheClearError(RuntimeException e, Cache cache) {
                log.error("Redis occur handleCacheClearError：", e);
            }
        };
    }
}

/**
 * Value 的序列化器
 *
 * @param <T>
 * @author /
 */
class FastJsonRedisSerializer<T> implements RedisSerializer<T> {

    private final Class<T> clazz;

    FastJsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) {
        if (t == null) {
            return new byte[0];
        }
        // SerializerFeature.WriteClassName: JSON标准是不支持自省的，即不知道 json 字符串代表的数据类型，
        // 所以通过 SerializerFeature.WriteClassName, json中会带有 @type 属性指定该 json 字符串所指代的类型
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(StandardCharsets.UTF_8);
    }

    @Override
    public T deserialize(byte[] bytes) {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, StandardCharsets.UTF_8);
        return JSON.parseObject(str, clazz);
    }
}

/**
 * 重写 String 序列化器
 *
 * @author /
 */
class StringRedisSerializer implements RedisSerializer<Object> {

    private final Charset charset;

    StringRedisSerializer() {
        this(StandardCharsets.UTF_8);
    }

    private StringRedisSerializer(Charset charset) {
        // 断言
        Assert.notNull(charset, "Charset must not be null!");
        this.charset = charset;
    }

    @Override
    public String deserialize(byte[] bytes) {
        // 反序列化
        return (bytes == null ? null : new String(bytes, charset));
    }

    @Override
    public byte[] serialize(Object object) {
        // 序列化
        String string = JSON.toJSONString(object);
        if (StringUtils.isBlank(string)) {
            return null;
        }
        string = string.replace("\"", "");
        return string.getBytes(charset);
    }
}