在前一篇里面讲到了Redis缓存击穿、缓存穿透、缓存雪崩这三者区别，接下来我们讲解Spring boot 整合Redis 中的一些知识点：

之前遇到过，有的了四五年，甚至更长时间的后端Java开发，并且也在实际工作中应用到了Redis，但是从来没有真正看过将数据存储到Reids中的实际样貌，请求参数如下：

{
  "age": 18,
  "email": "122121@qq.com",  
  "userName": "lisi"
}

使用JdkSerializationRedisSerializer

JdkSerializationRedisSerializer是Spring Data Redis默认的序列化策略，它使用Java原生的序列化机制（java.io.Serializable）将对象序列化为字节数组。这种方式要求被序列化的对象必须实现Serializable接口。

请求对象类

@Data
public class UserInfoDTO  implements Serializable {

    /**
     * 年龄
     */
    @ApiModelProperty("年龄")
    @Range(min = 3,max = 50,message = "年龄必须在3到50岁之间")
    private  Integer age;

    /**
     * 电子邮箱
     */
    @ApiModelProperty("电子邮箱")
    @Email(message = "电子邮箱格式不正确")
    private  String email;

     @NotNull(message = "用户名不能为空")
    private  String userName;
}

如果对象未实现Serializable接口，系统将抛出异常

{
  "status": 500,
  "message": "Cannot serialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException:"+
    " Failed to serialize object using DefaultSerializer; nested exception is java.lang.IllegalArgumentException:"+
    " DefaultSerializer requires a Serializable payload but received an object of type [com.xxx.xxx.dto.UserInfoDTO]",
  "data": null,
  "timestamp": 1745765727552

Redis中存储的数据值如下：

\xAC\xED\x00\x05sr\x00(com.qkx.learn.annotation.dto.UserInfoDTOAV\xC1\x87\xDCL+\x97\x02\x00\x03L\x00\x03aget\x00\x13Ljava/lang/Integer;L\x00\x05emailt\x00\x12Ljava/lang/String;L\x00\x08userNameq\x00~\x00\x02xpsr\x00\x11java.lang.Integer\x12\xE2\xA0\xA4\xF7\x81\x878\x02\x00\x01I\x00\x05valuexr\x00\x10java.lang.Number\x86\xAC\x95\x1D\x0B\x94\xE0\x8B\x02\x00\x00xp\x00\x00\x00\x12t\x00\x0D122121@qq.comt\x00\x04lisi

我相信大部分的人都不知道是什么，这种最不友好。

自定义序列化方式FastJson2JsonRedisSerializer

public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
    public static final String[] JSON_WHITELIST_STR = {"org.springframework", "com.qkx.xxx"};

    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    static final Filter AUTO_TYPE_FILTER = JSONReader.autoTypeFilter(JSON_WHITELIST_STR);

    private Class<T> clazz;

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

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);

        return JSON.parseObject(str, clazz, AUTO_TYPE_FILTER);
    }
}

这个序列化方式是将缓存对象序列化的为JSON格式，JSON格式我相信每一位程序员都能看懂，Redis中的存储数据格式如下：

{
  "@type": "com.qkx.xxx.xxx.dto.UserInfoDTO",
  "age": 18,
  "email": "122121@qq.com",
  "userName": "lisi"
}

细心的朋友可能会发现多了一部分值"@type": "
com.qkx.xxx.xxx.dto.UserInfoDTO"，如果在跨平台或者跨服务调用，又没有引用关系的时，反序列化肯定会失败，除非定义为一模一样的层级结构，那么如何处理呢？其实我们只需要简单的配置一下即可，修改
FastJson2JsonRedisSerializer中的第20行代码。

  return JSON.toJSONString(t, JSONWriter.Feature.NotWriteSetClassName).getBytes(DEFAULT_CHARSET);

返回结果如下：

{
  "age": 18,
  "email": "122121@qq.com",
  "userName": "lisi"
}

Redis配置文件

@Configuration
@EnableCaching
@AutoConfigureBefore(RedisAutoConfiguration.class)
public class RedisConfig extends CachingConfigurerSupport
{
    @Bean
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
    {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
        // JdkSerializationRedisSerializer serializer = new JdkSerializationRedisSerializer();
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public DefaultRedisScript<Long> limitScript()
    {
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(limitScriptText());
        redisScript.setResultType(Long.class);
        return redisScript;
    }

    /**
     * 限流脚本
     */
    private String limitScriptText()
    {
        return "local key = KEYS[1]\n" +
                "local count = tonumber(ARGV[1])\n" +
                "local time = tonumber(ARGV[2])\n" +
                "local current = redis.call('get', key);\n" +
                "if current and tonumber(current) > count then\n" +
                "    return tonumber(current);\n" +
                "end\n" +
                "current = redis.call('incr', key)\n" +
                "if tonumber(current) == 1 then\n" +
                "    redis.call('expire', key, time)\n" +
                "end\n" +
                "return tonumber(current);";
    }
}