DangerWind-RPC-framework---七、序列化算法

        客户端与服务端的在交互过程中需要互相发送交换数据，这就需要对传输对象进行序列化与反序列化操作，此过程涉及到序列化算法的使用。本RPC框架支持多种序列化算法，通过SPI机制进行扩展。

       比如客户端在向服务端发送数据时，首先是客户端的序列化操作：

   Serializer serializer = ExtensionLoader.getExtensionLoader(Serializer.class)
                        .getExtension(codecName);
   bodyBytes = serializer.serialize(rpcMessage.getData());

       服务端接收到数据后要进行反序列化操作：

   Serializer serializer = ExtensionLoader.getExtensionLoader(Serializer.class)
                    .getExtension(codecName);
   if (messageType == RpcConstants.REQUEST_TYPE) {
         RpcRequest tmpValue = serializer.deserialize(bs, RpcRequest.class);
         rpcMessage.setData(tmpValue);
   } else {
         RpcResponse tmpValue = serializer.deserialize(bs, RpcResponse.class);
         rpcMessage.setData(tmpValue);
   }

       本次主要支持三种序列化算法，分别是Kryo、Hessian、ProtoStuff，首先是Kryo序列化算法：

    private final ThreadLocal<Kryo> kryoThreadLocal = ThreadLocal.withInitial(() -> {
        Kryo kryo = new Kryo();
        // 注册类是一种优化手段，可以提高序列化和反序列化的效率
        kryo.register(RpcResponse.class);
        kryo.register(RpcRequest.class);
        return kryo;
    });

    @Override
    public byte[] serialize(Object obj) {
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
             Output output = new Output(byteArrayOutputStream)) {
            Kryo kryo = kryoThreadLocal.get();
            // Object->byte:将对象序列化为byte数组
            kryo.writeObject(output, obj);
            kryoThreadLocal.remove();
            return output.toBytes();
        } catch (Exception e) {
            throw new SerializeException("Serialization failed");
        }
    }

    @Override
    public <T> T deserialize(byte[] bytes, Class<T> clazz) {
        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
             Input input = new Input(byteArrayInputStream)) {
            Kryo kryo = kryoThreadLocal.get();
            // byte->Object:从byte数组中反序列化出对对象
            Object o = kryo.readObject(input, clazz);
            kryoThreadLocal.remove();
            return clazz.cast(o);
        } catch (Exception e) {
            throw new SerializeException("Deserialization failed");
        }
    }

       Kryo序列化算法性能较好，但是是线程不安全的，因此需要进行线程隔离，通过ThreadLocal为每个线程维护一个Kryo对象，使用完毕后就remove掉，之后需要使用时再次在threadLocal中初始化一个Kryo对象，这也是withInitial懒加载的过程。

      接下来是Hessian序列化算法：

    @Override
    public byte[] serialize(Object obj) {
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            HessianOutput hessianOutput = new HessianOutput(byteArrayOutputStream);
            hessianOutput.writeObject(obj);

            return byteArrayOutputStream.toByteArray();
        } catch (Exception e) {
            throw new SerializeException("Serialization failed");
        }

    }

    @Override
    public <T> T deserialize(byte[] bytes, Class<T> clazz) {

        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes)) {
            HessianInput hessianInput = new HessianInput(byteArrayInputStream);
            Object o = hessianInput.readObject();

            return clazz.cast(o);

        } catch (Exception e) {
            throw new SerializeException("Deserialization failed");
        }

    }

       最后是ProtoStuff序列化算法：

    private static final LinkedBuffer BUFFER = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);

    @Override
    public byte[] serialize(Object obj) {
        Class<?> clazz = obj.getClass();
        Schema schema = RuntimeSchema.getSchema(clazz);
        byte[] bytes;
        try {
            bytes = ProtostuffIOUtil.toByteArray(obj, schema, BUFFER);
        } finally {
            BUFFER.clear();
        }
        return bytes;
    }

    @Override
    public <T> T deserialize(byte[] bytes, Class<T> clazz) {
        Schema<T> schema = RuntimeSchema.getSchema(clazz);
        T obj = schema.newMessage();
        ProtostuffIOUtil.mergeFrom(bytes, obj, schema);
        return obj;
    }

        BUFFER可以避免每次序列化时重新申请缓冲区空间，提高序列化的效率。三种序列化算法的实现过程中，主要是需要对线程不安全的隐患进行处理，比如进行隔离等操作，以保证序列化操作的正确执行。