package cn.iocoder.yudao.framework.redis.config;
|
|
import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
|
import cn.hutool.core.util.StrUtil;
|
import org.redisson.spring.starter.RedissonAutoConfigurationV4;
|
import org.springframework.boot.autoconfigure.AutoConfiguration;
|
import org.springframework.context.annotation.Bean;
|
import org.springframework.data.redis.connection.RedisConnectionFactory;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.data.redis.serializer.RedisSerializer;
|
|
import java.nio.charset.StandardCharsets;
|
import java.util.HashSet;
|
import java.util.LinkedHashSet;
|
import java.util.Set;
|
import java.util.TreeSet;
|
|
import tools.jackson.core.type.TypeReference;
|
import tools.jackson.databind.ObjectMapper;
|
|
/**
|
* Redis 配置类
|
*/
|
@AutoConfiguration(before = RedissonAutoConfigurationV4.class) // 目的：使用自己定义的 RedisTemplate Bean
|
public class YudaoRedisAutoConfiguration {
|
|
/**
|
* 创建 RedisTemplate Bean，使用 JSON 序列化方式
|
*/
|
@Bean
|
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
|
// 创建 RedisTemplate 对象
|
RedisTemplate<String, Object> template = new RedisTemplate<>();
|
// 设置 RedisConnection 工厂。😈 它就是实现多种 Java Redis 客户端接入的秘密工厂。感兴趣的胖友，可以自己去撸下。
|
template.setConnectionFactory(factory);
|
// 使用 String 序列化方式，序列化 KEY 。
|
template.setKeySerializer(RedisSerializer.string());
|
template.setHashKeySerializer(RedisSerializer.string());
|
// 使用 JSON 序列化方式，序列化 VALUE
|
RedisSerializer<?> redisSerializer = buildRedisSerializer();
|
template.setValueSerializer(redisSerializer);
|
template.setHashValueSerializer(redisSerializer);
|
return template;
|
}
|
|
public static RedisSerializer<?> buildRedisSerializer() {
|
// 使用自定义序列化器，解决 Set/List 等 Collection 反序列化类型问题
|
return new TypedJsonRedisSerializer();
|
}
|
|
/**
|
* 自定义 Redis 序列化器，解决 Set/List 等 Collection 反序列化类型问题
|
*/
|
private static class TypedJsonRedisSerializer implements RedisSerializer<Object> {
|
|
private static final String JAVA_TYPE_PREFIX = "@class:";
|
private static final ObjectMapper OBJECT_MAPPER = JsonUtils.getObjectMapper();
|
private static final TypeReference<HashSet<Object>> HASH_SET_TYPE = new TypeReference<>() {};
|
private static final TypeReference<LinkedHashSet<Object>> LINKED_HASH_SET_TYPE = new TypeReference<>() {};
|
private static final TypeReference<TreeSet<Object>> TREE_SET_TYPE = new TypeReference<>() {};
|
|
@Override
|
public byte[] serialize(Object value) {
|
if (value == null) {
|
return new byte[0];
|
}
|
// 将类型信息与 JSON 一起存储
|
String json = JsonUtils.toJsonString(value);
|
String typePrefix = JAVA_TYPE_PREFIX + value.getClass().getName() + ":";
|
return (typePrefix + json).getBytes(StandardCharsets.UTF_8);
|
}
|
|
@Override
|
public Object deserialize(byte[] bytes) {
|
if (bytes == null || bytes.length == 0) {
|
return null;
|
}
|
String content = new String(bytes, StandardCharsets.UTF_8);
|
if (!content.startsWith(JAVA_TYPE_PREFIX)) {
|
// 兼容旧数据：没有类型信息的情况
|
// 检测是否为 JSON 数组，若是则转换为 HashSet
|
return deserializeLegacyData(content);
|
}
|
// 提取类型信息和 JSON
|
int colonIndex = content.indexOf(':', JAVA_TYPE_PREFIX.length());
|
if (colonIndex == -1) {
|
return deserializeLegacyData(content);
|
}
|
String className = content.substring(JAVA_TYPE_PREFIX.length(), colonIndex);
|
String json = content.substring(colonIndex + 1);
|
try {
|
Class<?> clazz = Class.forName(className);
|
// 特殊处理 Set 类型，因为 Jackson 默认会将 JSON 数组反序列化为 List
|
return deserializeWithTypeHint(json, clazz);
|
} catch (ClassNotFoundException e) {
|
// 类型不存在时，尝试兼容解析
|
return deserializeLegacyData(json);
|
} catch (Exception e) {
|
// 解析失败时，尝试兼容解析
|
return deserializeLegacyData(json);
|
}
|
}
|
|
/**
|
* 兼容旧数据（没有类型前缀）的解析
|
* 对于 JSON 数组，默认转换为 HashSet
|
*/
|
private Object deserializeLegacyData(String content) {
|
if (StrUtil.isEmpty(content)) {
|
return null;
|
}
|
content = content.trim();
|
// 判断是否为 JSON 数组
|
if (content.startsWith("[") && content.endsWith("]")) {
|
try {
|
// 数组类型默认转为 HashSet
|
return OBJECT_MAPPER.readValue(content, HASH_SET_TYPE);
|
} catch (Exception e) {
|
return JsonUtils.parseObject(content, Object.class);
|
}
|
}
|
// 其他类型直接解析
|
return JsonUtils.parseObject(content, Object.class);
|
}
|
|
private Object deserializeWithTypeHint(String json, Class<?> clazz) {
|
// 处理 Set 接口的实现类
|
if (HashSet.class.isAssignableFrom(clazz) ||
|
"java.util.Collections$UnmodifiableSet".equals(clazz.getName()) ||
|
"java.util.Collections$SingletonSet".equals(clazz.getName()) ||
|
Set.class.isAssignableFrom(clazz)) {
|
return OBJECT_MAPPER.readValue(json, HASH_SET_TYPE);
|
}
|
if (LinkedHashSet.class.isAssignableFrom(clazz)) {
|
return OBJECT_MAPPER.readValue(json, LINKED_HASH_SET_TYPE);
|
}
|
if (TreeSet.class.isAssignableFrom(clazz)) {
|
return OBJECT_MAPPER.readValue(json, TREE_SET_TYPE);
|
}
|
// 使用 Jackson 的 readValue 指定类型，确保 POJO 正确反序列化
|
return OBJECT_MAPPER.readValue(json, clazz);
|
}
|
}
|
|
}
|
