基于JetCache整合实现一级、二级缓存方案（方案实现）

目录

一、整体方案说明

1.1 需求说明

1.2 整体方案实现组件结构图

二、Caffeine缓存实现

2.1 组件说明

2.2 组件结构图

2.3 组件Maven依赖

2.4 组件功能实现源码

2.4.1 CaffeineCacheManager扩展实现

2.4.2 CaffeineConfiguration配置类实现

2.4.3 涉及其他组件的类

2.4.3.1 缓存过期时间通用属性类

2.4.3.2 缓存配置类

三、Redis缓存实现

3.1 组件说明

3.2 组件结构图

3.3 组件Maven依赖

3.4 组件功能实现源码

3.4.1 实现Redis缓存功能

3.4.1.1 RedisCacheManager 类扩展实现

3.4.1.2 RedisBitMapUtils工具类

3.4.1.3 CacheRedisConfiguration 缓存配置类实现

3.4.1.4 EnableKuaFuCloudRedis Redis启动注解

3.4.2 实现Spring Session的Redis缓存

3.4.2.1 HttpSessionIdResolver SessionId 解析类扩展

3.4.2.2 RedisSessionSharingConfiguration 启动配置类

3.4.2.3 注解生效条件类RedisSessionSharingCondition

3.4.2.4 ConditionalOnRedisSessionSharing 注解类

四、JetCache缓存框架整合

4.1 组件说明

4.2 组件结构图

4.3 组件Maven依赖

4.4 组件功能实现源码

4.4.1 Mybatis二级缓存扩展

4.4.1.1 ExtMybatisCache 实现类

4.4.2 Spring Cache缓存扩展

4.4.2.1 JetCache缓存工厂类JetCacheCreateCacheFactory

4.4.2.2 Spring Cache扩展实现类JetCacheSpringCache

4.4.2.3 Spring CacheManager扩展实现类JetCacheSpringCacheManager

4.4.2.4 自定义缓存管理类KuaFuCloudCacheManager

4.4.3 Stamp 缓存签章接口封装

4.4.3.1 StampManager 缓存签章接口

4.4.3.2 抽象Stamp签章管理类AbstractStampManager

4.4.3.3 抽象缓存计数类AbstractCountStampManager

4.4.4 JetCache直接使用封装

4.4.4.1 JetCache单例工具类JetCacheUtils

4.4.5 JetCache注解方式启动封装

4.4.5.1 JetCache加载配置类JetCacheConfiguration

4.4.5.2 JetCache手动启动注解

4.4.6 Jpa Hibernate二级缓存扩展

4.4.6.1 DomainDataStorageAccess 接口实现

4.4.6.2 RegionFactoryTemplate 模板扩展

五、缓存 Start 启动组件封装

5.1 组件说明

5.2 组件结构图

5.3 组件Maven依赖

5.4 组件功能实现源码

5.4.1 组件启动类

5.4.2 SPI加载机制配置文件

---

一、整体方案说明

1.1 需求说明

1、基于JetCache 缓存框架，整合Caffeine和Redis，实现一级（进程级）、二级（远程分布式）缓存。

2、基于该缓存方案，实现对Spring Cache缓存的扩展。

3、实现对Jpa Hibernate、Mybatis两款ORM框架二级缓存的扩展。

4、基于Redis缓存实现对SpringBoot Session 的共享会话。

5、Stamp 签章缓存实现。

6、组件最终封装成SpringBoot start 组件，方便一键使用。

1.2 整体方案实现组件结构图

二、Caffeine缓存实现

2.1 组件说明

封装成cache-caffeine-sdk组件，该组件封装了Caffeine缓存的相关实现扩展，最终通过CaffeineConfiguration配置启动。

2.2 组件结构图

2.3 组件Maven依赖

    
        ${project.groupId}
        cache-core
    

    
        com.github.ben-manes.caffeine
        caffeine
    

    
        org.springframework
        spring-context-support
    
    

2.4 组件功能实现源码

2.4.1 CaffeineCacheManager扩展实现

package cn.kuafu.cloud.base.cache.caffeine.enhance;

import cn.kuafu.cloud.base.assistant.core.definition.constants.SymbolConstants;
import cn.kuafu.cloud.base.cache.core.properties.Expire;
import cn.kuafu.cloud.base.cache.core.properties.CacheProperties;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.caffeine.CaffeineCacheManager;

import java.util.Map;

/**
 * @author ningzhaosheng
 * @date 2022/5/13 12:11:55
 * @description 扩展的 CaffeineCacheManager
 * 用于支持 Caffeine 缓存可以针对实体进行单独的过期时间设定
 */
public class KuaFuCloudCaffeineCacheManager extends CaffeineCacheManager {
    private static final Logger log = LoggerFactory.getLogger(KuaFuCloudCaffeineCacheManager.class);

    private final CacheProperties cacheProperties;

    // 构造方法
    public KuaFuCloudCaffeineCacheManager(CacheProperties cacheProperties) {
        this.cacheProperties = cacheProperties;
        this.setAllowNullValues(cacheProperties.getAllowNullValues());
    }

    // 构造方法
    public KuaFuCloudCaffeineCacheManager(CacheProperties cacheProperties, String... cacheNames) {
        super(cacheNames);
        this.cacheProperties = cacheProperties;
        this.setAllowNullValues(cacheProperties.getAllowNullValues());
    }

    // 覆盖CaffeineCacheManager 的 createNativeCaffeineCache方法，实现Caffeine创建本地缓存方法
    // 主要支持Duration 过期时间配置
    @Override
    protected Cache createNativeCaffeineCache(String name) {
        Map expires = cacheProperties.getExpires();
        if (MapUtils.isNotEmpty(expires)) {
            String key = StringUtils.replace(name, SymbolConstants.COLON, cacheProperties.getSeparator());
            if(expires.containsKey(key)) {
                Expire expire = expires.get(key);
                log.debug("[KuaFuCloud-Base-Cache] |- CACHE - Caffeine cache [{}] is setted to use CUSTEM exprie.", name);
                return Caffeine.newBuilder().expireAfterWrite(expire.getDuration(), expire.getUnit()).build();
            }
        }

        return super.createNativeCaffeineCache(name);
    }
}

2.4.2 CaffeineConfiguration配置类实现

package cn.kuafu.cloud.base.cache.caffeine.configuration;

import cn.kuafu.cloud.base.cache.caffeine.enhance.KuaFuCloudCaffeineCacheManager;
import cn.kuafu.cloud.base.cache.core.properties.CacheProperties;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

/**
 * @author ningzhaosheng
 * @date 2022/5/13 14:15:20
 * @description Caffeine配置
 */
@Configuration(proxyBeanMethods = false)
public class CaffeineConfiguration {
    private static final Logger log = LoggerFactory.getLogger(CaffeineConfiguration.class);

    @Autowired
    private CacheProperties cacheProperties;

    @PostConstruct
    public void postConstruct() {
        log.debug("[KuaFuCloud-Base-Cache] |- SDK [Cache Caffeine] Auto Configure.");
    }

    // 注入 Caffeine缓存类
    @Bean
    public Caffeine caffeine() {
        Caffeine caffeine = Caffeine.newBuilder()
                .expireAfterWrite(cacheProperties.getDuration(), cacheProperties.getUnit());

        log.trace("[KuaFuCloud-Base-Cache] |- Bean [Caffeine] Auto Configure.");

        return caffeine;
    }

    // 注入 CaffeineCacheManager 类
    @Bean
    @ConditionalOnMissingBean(CaffeineCacheManager.class)
    public CaffeineCacheManager caffeineCacheManager(Caffeine caffeine) {
        KuaFuCloudCaffeineCacheManager caffeineCacheManager = new KuaFuCloudCaffeineCacheManager(cacheProperties);
        caffeineCacheManager.setCaffeine(caffeine);
        log.trace("[KuaFuCloud-Base-Cache] |- Bean [Caffeine Cache Manager] Auto Configure.");
        return caffeineCacheManager;
    }
}

2.4.3 涉及其他组件的类

2.4.3.1 缓存过期时间通用属性类

package cn.kuafu.cloud.base.cache.core.properties;

import org.apache.commons.lang3.ObjectUtils;

import java.time.Duration;
import java.util.concurrent.TimeUnit;

/**
 * @author ningzhaosheng
 * @date 2022/5/12 22:00:42
 * @description 缓存过期时间通用属性
 */
public class Expire {
    /**
     * 统一缓存时长，默认：1
     */
    private Long duration = 1L;

    /**
     * 统一缓存时长单位，默认：小时。
     */
    private TimeUnit unit = TimeUnit.HOURS;

    /**
     * Redis缓存TTL设置，默认：1小时，单位小时
     * 

     * 使用Duration类型，配置参数形式如下：
     * "?ns" //纳秒
     * "?us" //微秒
     * "?ms" //毫秒
     * "?s" //秒
     * "?m" //分
     * "?h" //小时
     * "?d" //天
     */
    private Duration ttl;

    public Long getDuration() {
        return duration;
    }

    public void setDuration(Long duration) {
        this.duration = duration;
    }

    public TimeUnit getUnit() {
        return unit;
    }

    public void setUnit(TimeUnit unit) {
        this.unit = unit;
    }

    public Duration getTtl() {
        if (ObjectUtils.isEmpty(this.ttl)) {
            this.ttl = convertToDuration(this.duration, this.unit);
        }
        return ttl;
    }

    private Duration convertToDuration(Long duration, TimeUnit timeUnit) {
        switch (timeUnit) {
            case DAYS:
                return Duration.ofDays(duration);
            case HOURS:
                return Duration.ofHours(duration);
            case SECONDS:
                return Duration.ofSeconds(duration);
            default:
                return Duration.ofMinutes(duration);
        }
    }
}

2.4.3.2 缓存配置类

package cn.kuafu.cloud.base.cache.core.properties;

import cn.kuafu.cloud.base.cache.core.constants.CacheConstants;
import com.google.common.base.MoreObjects;
import org.springframework.boot.context.properties.ConfigurationProperties;

import java.util.HashMap;
import java.util.Map;

/**
 * @author ningzhaosheng
 * @date 2022/5/13 11:55:06
 * @description 缓存配置属性
 */
@ConfigurationProperties(prefix = CacheConstants.PROPERTY_PREFIX_CACHE)
public class CacheProperties extends Expire {
    /**
     * 是否允许存储空值
     */
    private Boolean allowNullValues = true;

    /**
     * 缓存名称转换分割符。默认值，"-"
     * 

     * 默认缓存名称采用 Redis Key 格式（使用 ":" 分割），使用 ":" 分割的字符串作为Map的Key，":"会丢失。
     * 指定一个分隔符，用于 ":" 分割符的转换
     */
    private String separator = "-";

    /**
     * 针对不同实体单独设置的过期时间，如果不设置，则统一使用默认时间。
     */
    private Map expires = new HashMap<>();

    public Boolean getAllowNullValues() {
        return allowNullValues;
    }

    public void setAllowNullValues(Boolean allowNullValues) {
        this.allowNullValues = allowNullValues;
    }

    public Map getExpires() {
        return expires;
    }

    public void setExpires(Map expires) {
        this.expires = expires;
    }

    public String getSeparator() {
        return separator;
    }

    public void setSeparator(String separator) {
        this.separator = separator;
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this)
                .add("allowNullValues", allowNullValues)
                .add("separator", separator)
                .toString();
    }
}

三、Redis缓存实现

3.1 组件说明

封装成cache-redis-sdk组件。

1、该组件封装了Redis缓存的相关实现扩展，最终通过CacheRedisConfiguration配置启动。

2、基于Redis，实现SpringBoot Session共享，支持通过条件判断和注解形式选择是否开启session共享

3.2 组件结构图

3.3 组件Maven依赖

        
            ${project.groupId}
            cache-core
        

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

        
            org.springframework.session
            spring-session-data-redis
        
        
            org.springframework.boot
            spring-boot-starter-web
            compile
            true
        

        
            org.springframework.boot
            spring-boot-starter-webflux
            compile
            true
        
    

3.4 组件功能实现源码

3.4.1 实现Redis缓存功能

3.4.1.1 RedisCacheManager 类扩展实现

package cn.kuafu.cloud.base.cache.redis.enhance;

import cn.kuafu.cloud.base.assistant.core.definition.constants.SymbolConstants;
import cn.kuafu.cloud.base.cache.core.properties.Expire;
import cn.kuafu.cloud.base.cache.core.properties.CacheProperties;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.cache.RedisCache;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;

import java.util.Map;

/**
 * @author ningzhaosheng
 * @date 2022/5/13 12:07:49
 * @description 扩展的RedisCacheManager
 * 用于支持 Redis 缓存可以针对实体进行单独的过期时间设定
 */
public class KuaFuCloudRedisCacheManager extends RedisCacheManager {
    private static final Logger log = LoggerFactory.getLogger(KuaFuCloudRedisCacheManager.class);

    private CacheProperties cacheProperties;

    // 构造函数
    public KuaFuCloudRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, CacheProperties cacheProperties) {
        super(cacheWriter, defaultCacheConfiguration);
        this.cacheProperties = cacheProperties;
    }

    // 构造函数
    public KuaFuCloudRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, CacheProperties cacheProperties, String... initialCacheNames) {
        super(cacheWriter, defaultCacheConfiguration, initialCacheNames);
        this.cacheProperties = cacheProperties;
    }

    // 构造函数
    public KuaFuCloudRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, boolean allowInFlightCacheCreation, CacheProperties cacheProperties, String... initialCacheNames) {
        super(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation, initialCacheNames);
        this.cacheProperties = cacheProperties;
    }

    // 构造函数
    public KuaFuCloudRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map initialCacheConfigurations, CacheProperties cacheProperties) {
        super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations);
        this.cacheProperties = cacheProperties;
    }

    // 构造函数
    public KuaFuCloudRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map initialCacheConfigurations, boolean allowInFlightCacheCreation) {
        super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations, allowInFlightCacheCreation);
    }

     // 覆盖实现 RedisCacheManager 类的 createRedisCache方法，加入自定义缓存过期时间策略
    @Override
    protected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {
        Map expires = cacheProperties.getExpires();
        if (MapUtils.isNotEmpty(expires)) {
            String key = StringUtils.replace(name, SymbolConstants.COLON, cacheProperties.getSeparator());
            if (expires.containsKey(key)) {
                Expire expire = expires.get(key);
                log.debug("[KuaFuCloud-Base-Cache] |- CACHE - Redis cache [{}] is setted to use CUSTEM exprie.", name);
                cacheConfig = cacheConfig.entryTtl(expire.getTtl());
            }
        }

        return super.createRedisCache(name, cacheConfig);
    }
}

3.4.1.2 RedisBitMapUtils工具类

package cn.kuafu.cloud.base.cache.redis.util;

import com.google.common.hash.Funnels;
import com.google.common.hash.Hashing;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.nio.charset.StandardCharsets;

/**
 * @author ningzhaosheng
 * @date 2023/2/16 16:24:06
 * @description 
Description: Redis BitMap 工具类 
 * 

 * · Redis的Bitmaps这个“数据结构”可以实现对位的操作。Bitmaps本身不是一种数据结构，实际上就是字符串，但是它可以对字符串的位进行操作
 * · 可把Bitmaps想象成一个以位为单位数组，数组中的每个单元只能存0或者1，数组的下标在bitmaps中叫做偏移量
 * · 单个bitmaps的最大长度是512MB，即2^32个比特位
 * 

 * bitmaps的最大优势是节省存储空间。比如在一个以自增id代表不同用户的系统中，我们只需要512MB空间就可以记录40亿用户的某个单一信息，相比mysql节省了大量的空间
 * 

 * · 有两种类型的位操作：一类是对特定bit位的操作，比如设置/获取某个特定比特位的值。另一类是批量bit位操作，例如在给定范围内统计为1的比特位个数
 * 

 * 1.1 优点：
 * 

 * 节省空间：通过一个bit位来表示某个元素对应的值或者状态，其中key就是对应元素的值。实际上8个bit可以组成一个Byte，所以是及其节省空间的。
 * 

 * 效率高：setbit和getbit的时间复杂度都是O(1)，其他位运算效率也高。
 * 

 * 1.2 缺点：
 * 本质上位只有0和1的区别，所以用位做业务数据记录，就不需要在意value的值。
 * @see 
 */
@Component
public class RedisBitMapUtils {
    private static StringRedisTemplate stringRedisTemplate;

    @Autowired
    @Qualifier(value = "stringRedisTemplate")
    public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
        RedisBitMapUtils.stringRedisTemplate = stringRedisTemplate;
    }

    /**
     * 计算 Hash 值
     *
     * @param key bitmap结构的key
     * @return Hash 值
     */
    private static long hash(String key) {
        return Math.abs(Hashing.murmur3_128().hashObject(key, Funnels.stringFunnel(StandardCharsets.UTF_8)).asInt());
    }


    /**
     * 设置与 param 对应的二进制位的值，{@param param}会经过hash计算进行存储。
     *
     * @param key   bitmap数据结构的key
     * @param param 要设置偏移的key，该key会经过hash运算。
     * @param value true：即该位设置为1，否则设置为0
     * @return 返回设置该value之前的值。
     */
    public static Boolean setBit(String key, String param, boolean value) {
        return stringRedisTemplate.opsForValue().setBit(key, hash(param), value);
    }

    /**
     * 查询与指定 param 对应二进制位的值，{@param param}会经过hash计算进行存储。
     *
     * @param key   bitmap结构的key
     * @param param 要移除偏移的key，该key会经过hash运算。
     * @return 若偏移位上的值为1，那么返回true。
     */
    public static boolean getBit(String key, String param) {
        return Boolean.TRUE.equals(stringRedisTemplate.opsForValue().getBit(key, hash(param)));
    }

    /**
     * 将指定offset偏移量的值设置为1；
     *
     * @param key    bitmap结构的key
     * @param offset 指定的偏移量。
     * @param value  true：即该位设置为1，否则设置为0
     * @return 返回设置该value之前的值。
     */
    public static Boolean setBit(String key, Long offset, boolean value) {
        return stringRedisTemplate.opsForValue().setBit(key, offset, value);
    }

    /**
     * 获取指定 offset 偏移量的值；
     *
     * @param key    bitmap结构的key
     * @param offset 指定的偏移量。
     * @return 若偏移位上的值为 1，那么返回true。
     */
    public static Boolean getBit(String key, long offset) {
        return stringRedisTemplate.opsForValue().getBit(key, offset);
    }

    /**
     * 统计对应的bitmap上value为1的数量
     *
     * @param key bitmap的key
     * @return value等于1的数量
     */
    public static Long bitCount(String key) {
        return stringRedisTemplate.execute((RedisCallback) connection -> connection.stringCommands().bitCount(key.getBytes(StandardCharsets.UTF_8)));
    }

    /**
     * 统计指定范围中value为1的数量
     *
     * @param key   bitMap中的key
     * @param start 该参数的单位是byte（1byte=8bit），{@code setBit(key,7,true);}进行存储时，单位是bit。那么只需要统计[0,1]便可以统计到上述set的值。
     * @param end   该参数的单位是byte。
     * @return 在指定范围[start*8,end*8]内所有value=1的数量
     */
    public static Long bitCount(String key, int start, int end) {
        return stringRedisTemplate.execute((RedisCallback) connection -> connection.stringCommands().bitCount(key.getBytes(), start, end));
    }

    /**
     * 对一个或多个保存二进制的字符串key进行元操作，并将结果保存到saveKey上。
     * 

     * bitop and saveKey key [key...]，对一个或多个key逻辑并，结果保存到saveKey。
     * bitop or saveKey key [key...]，对一个或多个key逻辑或，结果保存到saveKey。
     * bitop xor saveKey key [key...]，对一个或多个key逻辑异或，结果保存到saveKey。
     * bitop xor saveKey key，对一个或多个key逻辑非，结果保存到saveKey。
     * 

     *
     * @param op      元操作类型；
     * @param saveKey 元操作后将结果保存到saveKey所在的结构中。
     * @param destKey 需要进行元操作的类型。
     * @return 1：返回元操作值。
     */
    public static Long bitOp(RedisStringCommands.BitOperation op, String saveKey, String... destKey) {
        byte[][] bytes = new byte[destKey.length][];
        for (int i = 0; i < destKey.length; i++) {
            bytes[i] = destKey[i].getBytes();
        }
        return stringRedisTemplate.execute((RedisCallback) connection -> connection.stringCommands().bitOp(op, saveKey.getBytes(), bytes));
    }

    /**
     * 对一个或多个保存二进制的字符串key进行元操作，并将结果保存到saveKey上，并返回统计之后的结果。
     *
     * @param op      元操作类型；
     * @param saveKey 元操作后将结果保存到saveKey所在的结构中。
     * @param destKey 需要进行元操作的类型。
     * @return 返回saveKey结构上value=1的所有数量值。
     */
    public static Long bitOpResult(RedisStringCommands.BitOperation op, String saveKey, String... destKey) {
        bitOp(op, saveKey, destKey);
        return bitCount(saveKey);
    }
}

3.4.1.3 CacheRedisConfiguration 缓存配置类实现

package cn.kuafu.cloud.base.cache.redis.configuration;

import cn.kuafu.cloud.base.cache.core.properties.CacheProperties;
import cn.kuafu.cloud.base.cache.redis.enhance.KuaFuCloudRedisCacheManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
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.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import javax.annotation.PostConstruct;

/**
 * @author ningzhaosheng
 * @date 2022/5/13 14:26:19
 * @description Redis缓存配置
 */
@Configuration(proxyBeanMethods = false)
@Import(RedisSessionSharingConfiguration.class)
public class CacheRedisConfiguration {
    private static final Logger log = LoggerFactory.getLogger(CacheRedisConfiguration.class);

    @PostConstruct
    public void postConstruct() {
        log.debug("[KuaFuCloud-Base-Cache] |- SDK [Cache Redis] Auto Configure.");
    }

    private RedisSerializer keySerializer() {
        return new StringRedisSerializer();
    }

    private RedisSerializer