SpringBoot整合Redis时序列化方式之JdkSerializationRedisSerializer

在说 JdkSerializationRedisSerializer之前我们可以先看看在SpringBoot集成Redis时的相关知识点：

在自动配置中的使用(以RedisTemplate为例)：

再看一下JdkSerializationRedisSerializer类

public class JdkSerializationRedisSerializer implements RedisSerializer<Object> {
   //序列化时使用对象
   private final Converter<Object, byte[]> serializer;
   //反序列化时使用对象
   private final Converter<byte[], Object> deserializer;
   //在构造器中初始化对象
   public JdkSerializationRedisSerializer() {
       this(new SerializingConverter(), new DeserializingConverter());
   }

   public JdkSerializationRedisSerializer(@Nullable ClassLoader classLoader) {
       this(new SerializingConverter(), new DeserializingConverter(classLoader));
   }
   
   public JdkSerializationRedisSerializer(Converter<Object, byte[]> serializer, Converter<byte[], Object> deserializer) {
      // 对传进来的对象进行非空判断
       Assert.notNull(serializer, "Serializer must not be null!");
       Assert.notNull(deserializer, "Deserializer must not be null!");
       this.serializer = serializer;
       this.deserializer = deserializer;
   }

  //反序列化方法
   public Object deserialize(@Nullable byte[] bytes) {
       if (SerializationUtils.isEmpty(bytes)) {
           return null;
       } else {
           try {
               return this.deserializer.convert(bytes);
           } catch (Exception var3) {
               throw new SerializationException("Cannot deserialize", var3);
           }
       }
   }
  //序列化方法
   public byte[] serialize(@Nullable Object object) {
       if (object == null) {
           return SerializationUtils.EMPTY_ARRAY;
       } else {
           try {
               return (byte[])this.serializer.convert(object);
           } catch (Exception var3) {
               throw new SerializationException("Cannot serialize", var3);
           }
       }
   }
}

分析序列化方法serialize

 public byte[] serialize(@Nullable Object object) {
     // 判断传入对象不为空
       if (object == null) {
           return SerializationUtils.EMPTY_ARRAY;
       } else {
           try {
              // 调用serialize的convert方法并将对象作为参数
               return (byte[])this.serializer.convert(object);
           } catch (Exception var3) {
               throw new SerializationException("Cannot serialize", var3);
           }
       }
   }
}

//SerializingConverter类
public class SerializingConverter implements Converter<Object, byte[]> {
    private final Serializer<Object> serializer;

    public SerializingConverter() {
    // 创建默认的序列化对象
        this.serializer = new DefaultSerializer();
    }

    public SerializingConverter(Serializer<Object> serializer) {
        Assert.notNull(serializer, "Serializer must not be null");
        this.serializer = serializer;
    }
  // 调用的convert方法
    public byte[] convert(Object source) {
        try {
          /**
          使用默认的序列化对象调用serializeToByteArray(source)方法
          其实会发现DefaultSerializer类中没有serializeToByteArray(source)方法
          但是DefaultSerializer实现了Serializer接口
          */
            return this.serializer.serializeToByteArray(source);
        } catch (Throwable var3) {
            throw new SerializationFailedException("Failed to serialize object using " + this.serializer.getClass().getSimpleName(), var3);
        }
    }
}

//DefaultSerializer类
public class DefaultSerializer implements Serializer<Object> {
    public DefaultSerializer() {
    }

    public void serialize(Object object, OutputStream outputStream) throws IOException {
        if (!(object instanceof Serializable)) {
            throw new IllegalArgumentException(this.getClass().getSimpleName() + " requires a Serializable payload but received an object of type [" + object.getClass().getName() + "]");
        } else {
            //得到对象输出流
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            // 将对象进行输出序列化
            objectOutputStream.writeObject(object);
            //刷新缓冲区
            objectOutputStream.flush();
        }
    }


// Serializer接口
@FunctionalInterface
public interface Serializer<T> {
    void serialize(T var1, OutputStream var2) throws IOException;

    default byte[] serializeToByteArray(T object) throws IOException {
         //创建一个字节数组缓冲流
        ByteArrayOutputStream out = new ByteArrayOutputStream(1024);
        //调用serialize方法并将 将要序列化的对象和字节数组缓冲流作为参数
        //而serialize的实现则在DefaultSerializer类中
        this.serialize(object, out);
        return out.toByteArray();
    }
}

分析反序列化方法deserialize

 public Object deserialize(@Nullable byte[] bytes) {
        if (SerializationUtils.isEmpty(bytes)) {
            return null;
        } else {
            try {
            // 调用deserializer的convert方法并将 将要反序列化的数组作为参数
                return this.deserializer.convert(bytes);
            } catch (Exception var3) {
                throw new SerializationException("Cannot deserialize", var3);
            }
        }
    }

///DeserializingConverter类
public class DeserializingConverter implements Converter<byte[], Object> {
    private final Deserializer<Object> deserializer;

    public DeserializingConverter() {
        // 创建默认反序列化对象
        this.deserializer = new DefaultDeserializer();
    }

    public DeserializingConverter(ClassLoader classLoader) {
        this.deserializer = new DefaultDeserializer(classLoader);
    }

    public DeserializingConverter(Deserializer<Object> deserializer) {
        Assert.notNull(deserializer, "Deserializer must not be null");
        this.deserializer = deserializer;
    }

    public Object convert(byte[] source) {
    // 创建字节数组输入流
        ByteArrayInputStream byteStream = new ByteArrayInputStream(source);

        try {
           //调用反序列化对象反deserialize方法并将字节数组输入流对象作为参数
            return this.deserializer.deserialize(byteStream);
        } catch (Throwable var4) {
            throw new SerializationFailedException("Failed to deserialize payload. Is the byte array a result of corresponding serialization for " + this.deserializer.getClass().getSimpleName() + "?", var4);
        }
    }
}

/// DefaultDeserializer类
public class DefaultDeserializer implements Deserializer<Object> {
    @Nullable
    private final ClassLoader classLoader;

    public DefaultDeserializer() {
        this.classLoader = null;
    }

    public DefaultDeserializer(@Nullable ClassLoader classLoader) {
        this.classLoader = classLoader;
    }

    public Object deserialize(InputStream inputStream) throws IOException {
        ConfigurableObjectInputStream objectInputStream = new ConfigurableObjectInputStream(inputStream, this.classLoader);

        try {
            return objectInputStream.readObject();
        } catch (ClassNotFoundException var4) {
            throw new NestedIOException("Failed to deserialize object type", var4);
        }
    }
}

小结

底层还是通过调用JDK的IO操作ObjectInputStream和ObjectOutputStream类实现对象的序列化与反序列化。