默认序列化方案
在上一篇文章《Spring Data Redis(一)》中,我们执行了这样一个操作:
redisTemplate.opsForValue().set("student:1","kirito");
试图使用RedisTemplate在Redis中存储一个键为“student:1”,值为“kirito”的String类型变量(redis中通常使用‘:’作为键的分隔符)。那么是否真的如我们所预想的那样,在Redis中存在这样的键值对呢?
这可以说是Redis中最基础的操作了,但严谨起见,还是验证一下为妙,使用RedisDesktopManager可视化工具,或者redis-cli都可以查看redis中的数据。
emmmmm,大概能看出是我们的键值对,但前面似乎多了一些奇怪的16进制字符,在不了解RedisTemplate工作原理的情况下,自然会对这个现象产生疑惑。
首先看看springboot如何帮我们自动完成RedisTemplate的配置:
@Configuration
protected static class RedisConfiguration {
@Bean
@ConditionalOnMissingBean(name = "redisTemplate")
public RedisTemplate<Object, Object> redisTemplate(
RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}
没看出什么特殊的设置,于是我们进入RedisTemplate自身的源码中一窥究竟。
首先是在类开头声明了一系列的序列化器:
private boolean enableDefaultSerializer = true;// 配置默认序列化器
private RedisSerializer<?> defaultSerializer;
private ClassLoader classLoader;
private RedisSerializer keySerializer = null;
private RedisSerializer valueSerializer = null;
private RedisSerializer hashKeySerializer = null;
private RedisSerializer hashValueSerializer = null;
private RedisSerializer<String> stringSerializer = new StringRedisSerializer();
看到了我们关心的 keySerializer
和 valueSerializer
,在RedisTemplate.afterPropertiesSet()方法中,可以看到,默认的序列化方案:
public void afterPropertiesSet() {
super.afterPropertiesSet();
boolean defaultUsed = false;
if (defaultSerializer == null) {
defaultSerializer = new JdkSerializationRedisSerializer(
classLoader != null ? classLoader : this.getClass().getClassLoader());
}
if (enableDefaultSerializer) {
if (keySerializer == null) {
keySerializer = defaultSerializer;
defaultUsed = true;
}
if (valueSerializer == null) {
valueSerializer = defaultSerializer;
defaultUsed = true;
}
if (hashKeySerializer == null) {
hashKeySerializer = defaultSerializer;
defaultUsed = true;
}
if (hashValueSerializer == null) {
hashValueSerializer = defaultSerializer;
defaultUsed = true;
}
}
...
initialized = true;
}
默认的方案是使用了 JdkSerializationRedisSerializer
,所以导致了前面的结果,注意:字符串和使用jdk序列化之后的字符串是两个概念。
我们可以查看set方法的源码:
public void set(K key, V value) {
final byte[] rawValue = rawValue(value);
execute(new ValueDeserializingRedisCallback(key) {
protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
connection.set(rawKey, rawValue);
return null;
}
}, true);
}
最终与Redis交互使用的是原生的connection,键值则全部是字节数组,意味着所有的序列化都依赖于应用层完成,Redis只认字节!这也是引出本节介绍的初衷,序列化是与Redis打交道很关键的一个环节。
在我不长的使用Redis的时间里,其实大多数操作是字符串操作,键值均为字符串,String.getBytes()即可满足需求。spring-data-redis也考虑到了这一点,其一,提供了StringRedisSerializer的实现,其二,提供了StringRedisTemplate,继承自RedisTemplate。
public class StringRedisTemplate extends RedisTemplate<String, String>{
public StringRedisTemplate() {
RedisSerializer<String> stringSerializer = new StringRedisSerializer();
setKeySerializer(stringSerializer);
setValueSerializer(stringSerializer);
setHashKeySerializer(stringSerializer);
setHashValueSerializer(stringSerializer);
}
...
}
即只能存取字符串。尝试执行如下的代码:
@Autowired
StringRedisTemplate stringRedisTemplate;
stringRedisTemplate.opsForValue().set("student:2", "SkYe");
再同样观察RedisDesktopManager中的变化:
由于更换了序列化器,我们得到的结果也不同了。
理论上,字符串(本质是字节)其实是万能格式,是否可以使用StringRedisTemplate将复杂的对象存入Redis中,答案当然是肯定的。可以在应用层手动将对象序列化成字符串,如使用fastjson,jackson等工具,反序列化时也是通过字符串还原出原来的对象。而如果是用 redisTemplate.opsForValue().set("student:3",newStudent(3,"kirito"));
便是依赖于内部的序列化器帮我们完成这样的一个流程,和使用 stringRedisTemplate.opsForValue().set("student:3",JSON.toJSONString(newStudent(3,"kirito")));
其实是一个等价的操作。但有两点得时刻记住两点:
曾经在review代码时发现,项目组的两位同事操作redis,一个使用了RedisTemplate,一个使用了StringRedisTemplate,当他们操作同一个键时,key虽然相同,但由于序列化器不同,导致无法获取成功。差异虽小,但影响是非常可怕的。
另外一点是,微服务不同模块连接了同一个Redis,在共享内存中交互数据,可能会由于版本升级,模块差异,导致相互的序列化方案不一致,也会引起问题。如果项目中途切换了序列化方案,也可能会引起Redis中老旧持久化数据的反序列化异常,同样需要引起注意。最优的方案自然是在项目初期就统一好序列化方案,所有模块引用同一份依赖,避免不必要的麻烦(或者干脆全部使用默认配置)。
无论是RedisTemplate中默认使用的 JdkSerializationRedisSerializer
,还是StringRedisTemplate中使用的 StringRedisSerializer
都是实现自统一的接口 RedisSerializer
public interface RedisSerializer<T> {
byte[] serialize(T t) throws SerializationException;
T deserialize(byte[] bytes) throws SerializationException;
}
在spring-data-redis中提供了其他的默认实现,用于替换默认的序列化方案。
我们可能出于什么样的目的修改序列化器呢?按照个人理解可以总结为以下几点:
可以将全局的RedisTemplate覆盖,也可以在使用时在局部实例化一个RedisTemplate替换(不依赖于IOC容器)需要根据实际的情况选择替换的方式,以Jackson2JsonRedisSerializer为例介绍全局替换的方式:
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate redisTemplate = new RedisTemplate();
redisTemplate.setConnectionFactory(redisConnectionFactory);
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();// <1>
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
redisTemplate.setKeySerializer(new StringRedisSerializer()); // <2>
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // <2>
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
<1> 修改Jackson序列化时的默认行为
<2> 手动指定RedisTemplate的Key和Value的序列化器
然后使用RedisTemplate进行保存:
@Autowired
StringRedisTemplate stringRedisTemplate;
public void test() {
Student student3 = new Student();
student3.setName("kirito");
student3.setId("3");
student3.setHobbies(Arrays.asList("coding","write blog","eat chicken"));
redisTemplate.opsForValue().set("student:3",student3);
}
紧接着,去RedisDesktopManager中查看结果:
标准的JSON格式
我们也可以考虑根据自己项目和需求的特点,扩展序列化器,这是非常方便的。比如前面提到的,为了追求性能,可能考虑使用Kryo序列化器替换缓慢的JDK序列化器,如下是一个参考实现(为了demo而写,未经过生产验证)
public class KryoRedisSerializer<T> implements RedisSerializer<T> {
private final static Logger logger = LoggerFactory.getLogger(KryoRedisSerializer.class);
private static final ThreadLocal<Kryo> kryos = new ThreadLocal<Kryo>() {
protected Kryo initialValue() {
Kryo kryo = new Kryo();
return kryo;
};
};
@Override
public byte[] serialize(Object obj) throws SerializationException {
if (obj == null) {
throw new RuntimeException("serialize param must not be null");
}
Kryo kryo = kryos.get();
Output output = new Output(64, -1);
try {
kryo.writeClassAndObject(output, obj);
return output.toBytes();
} finally {
closeOutputStream(output);
}
}
@Override
public T deserialize(byte[] bytes) throws SerializationException {
if (bytes == null) {
return null;
}
Kryo kryo = kryos.get();
Input input = null;
try {
input = new Input(bytes);
return (T) kryo.readClassAndObject(input);
} finally {
closeInputStream(input);
}
}
private static void closeOutputStream(OutputStream output) {
if (output != null) {
try {
output.flush();
output.close();
} catch (Exception e) {
logger.error("serialize object close outputStream exception", e);
}
}
}
private static void closeInputStream(InputStream input) {
if (input != null) {
try {
input.close();
} catch (Exception e) {
logger.error("serialize object close inputStream exception", e);
}
}
}
}
由于Kyro是线程不安全的,所以使用了一个ThreadLocal来维护,也可以挑选其他高性能的序列化方案如Hessian,Protobuf...