第03篇：手写JavaRPC框架之搞定序列化

科技 08-04 来源： 软件编程指南

天下代码一大抄, 抄来抄去有提高, 看你会抄不会抄！

一、前言

天下代码一大抄, 抄来抄去有提高, 看你会抄不会抄！从本篇开始后面的所有章节都是实战环节,每节一个小目标,最终我们实现完整的JavaRPC的框架,然后发布maven仓库,感兴趣的同学可以下载研究。大家如果想要获取源码的话可以私信: RPC,自动回复仓库地址。

其实这些东西并没有什么难度，只要从头到尾跟着我们一起coding，其实就会发现不过如此。所以就算是新手也不要有心里负担。还是那句话: "天下代码一大抄, 抄来抄去有提高, 看你会抄不会抄"。主要的是思想，而不是死记硬背。所以我们来主要来学习设计思想，具体的代码，收藏用的时候看下就好了。

下面我们废话就不多少，直接开始吧。

二、目标

2.1 目标介绍

RPC框架中最基础的一个功能就是通讯，而通讯的本质就是发送方将数据转换成二进制的数据流，然后通过网络管道将数据发送给服务方，服务方在通过读取管道中的二进制数据最终将数据从二进制转换成Java对象，然后供Java系统处理，处理完成后再将Java结果对象转换成二进制数据通过管道发送回去。

这里有两个重点，第一个是网络通信，就是图中的网路连接管道，第二个是管道中的二进制数据。本篇文章我们先研究后者，就是通过代码将Java对象转换成二进制数据。因为通信比较难，内容也较多，所以我们先易后难，难的放到下一篇文章在说。

这里有两个术语: 序列化和反序列化

如下实例User类，转换成二进制数据就是一个数组。这个Java对象转换二进制数据的过程叫做序列化。 而二进制数据转换成Java对象的过程叫做反序列化。

2.2 两个小目标

  • 第一个目标就是我们实现多种序列化的能力。
  • 第二个目标是来选择一个最优的序列化方案。

为什么说要选择最优的序列化方案呢? 因为我们要适配下面这两种场景。

  1. 第一种是对性能要有比较高的，这种情况就要求我们序列化和反序列的速度要足够快
  2. 第二种就是对内存和空间要有比较高的，就要求我们的序列化后的数据要足够的小。

下面就开始Coding了。

三、设计

3.1 工程结构

首先我们根据上一篇文章中定义的项目分层结构，先把需要的所有层给创建出来。然后实现序列化。

mojito/mojito-net/src/main/java/cn/lxchinesszz/mojito on  master [!+?] .├── api├── business├── codec├── exception│   ├── BusinessServerHandlerException.java│   ├── DeserializeException.java│   ├── HttpsTokenFileException.java│   ├── ProtocolException.java│   ├── RemotingException.java│   ├── SerializeException.java│   └── SignatureException.java├── exchange└── serialize    ├── AbstractSerializer.java    ├── Serializer.java    └── impl        ├── Hession2ObjectSerializer.java        ├── HessionObjectSerializer.java        ├── NettyCompactObjectSerializer.java        ├── NettyObjectSerializer.java        └── ProtostuffObjectSerializer.java

3.2 代码结构

首先我们先定义接口，为什么定义接口呢? 方便后面的扩展。 接口也非常的简单就三个方法。

  1. 负责将任意对象转换成二进制数组
  2. 将二进制数组转成Object对象
  3. 将二进制数组转换成指定的Java对象

UML图设计

3.3 实现

  • ProtostuffObjectSerializer 使用谷歌开源的序列化库,特点占用极小。
public class ProtostuffObjectSerializer extends AbstractSerializer {    /**     * 线程数会有限制,不会无穷大的使用     */    private static final ThreadLocal BUFFER = InheritableThreadLocal.withInitial(() ->            LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));    @Override    @SuppressWarnings("unchecked")    public byte[] doSerialize(Object dataObject) throws SerializeException {        // // RuntimeSchema 懒加载内置缓存,所以我们不用在缓存了        Schema schema = (Schema) RuntimeSchema.getSchema(dataObject.getClass());        LinkedBuffer linkedBuffer = BUFFER.get();        byte[] bytes = ProtostuffIOUtil.toByteArray(dataObject, schema, linkedBuffer);        linkedBuffer.clear();        return bytes;    }    @Override    public Object doDeserialize(byte[] data) throws DeserializeException {        throw new UnsupportedOperationException(getClass() + "必须指定反序列化类型");    }    @Override    public  T deserialize(byte[] data, Class dataType) throws DeserializeException {        return schema(data, dataType);    }    public  T schema(byte[] data, Class dataType) throws DeserializeException {        try {            Schema schema = RuntimeSchema.getSchema(dataType);            T dataTypeObj = dataType.newInstance();            ProtostuffIOUtil.mergeFrom(data, dataTypeObj, schema);            return dataTypeObj;        } catch (InstantiationException | IllegalAccessException e) {            throw new DeserializeException(e);        }    }}
  • NettyCompactObjectSerializer Netty原生支持的序列化协议
public class NettyCompactObjectSerializer extends AbstractSerializer {    @Override    public byte[] doSerialize(Object dataObject) throws SerializeException {        try (ByteArrayOutputStream dataArr = new ByteArrayOutputStream();             CompactObjectOutputStream oeo = new CompactObjectOutputStream(dataArr)) {            oeo.writeObject(dataObject);            oeo.flush();            return dataArr.toByteArray();        } catch (IOException e) {            throw new SerializeException(e);        }    }    @Override    public Object doDeserialize(byte[] data) throws DeserializeException {        Object o;        try (CompactObjectInputStream odi = new CompactObjectInputStream(new ByteArrayInputStream(data), ClassResolvers.cacheDisabled(null))) {            o = odi.readObject();        } catch (ClassNotFoundException | IOException e) {            throw new DeserializeException(e);        }        return o;    }        private static class CompactObjectOutputStream extends ObjectOutputStream {        static final int TYPE_FAT_DESCRIPTOR = 0;        static final int TYPE_THIN_DESCRIPTOR = 1;        CompactObjectOutputStream(OutputStream out) throws IOException {            super(out);        }        @Override        protected void writeStreamHeader() throws IOException {            writeByte(STREAM_VERSION);        }        @Override        protected void writeClassDescriptor(ObjectStreamClass desc) throws IOException {            Class<?> clazz = desc.forClass();            if (clazz.isPrimitive() || clazz.isArray() || clazz.isInterface() ||                    desc.getSerialVersionUID() == 0) {                write(TYPE_FAT_DESCRIPTOR);                super.writeClassDescriptor(desc);            } else {                write(TYPE_THIN_DESCRIPTOR);                writeUTF(desc.getName());            }        }    }    /**     * 压缩     */    private static class CompactObjectInputStream extends ObjectInputStream {        static final int TYPE_FAT_DESCRIPTOR = 0;        static final int TYPE_THIN_DESCRIPTOR = 1;        private final ClassResolver classResolver;        CompactObjectInputStream(InputStream in, ClassResolver classResolver) throws IOException {            super(in);            this.classResolver = classResolver;        }        @Override        protected void readStreamHeader() throws IOException {            int version = readByte() & 0xFF;            if (version != STREAM_VERSION) {                throw new StreamCorruptedException(                        "Unsupported version: " + version);            }        }        @Override        protected ObjectStreamClass readClassDescriptor()                throws IOException, ClassNotFoundException {            int type = read();            if (type < 0) {                throw new EOFException();            }            switch (type) {                case TYPE_FAT_DESCRIPTOR:                    return super.readClassDescriptor();                case TYPE_THIN_DESCRIPTOR:                    String className = readUTF();                    Class<?> clazz = classResolver.resolve(className);                    return ObjectStreamClass.lookupAny(clazz);                default:                    throw new StreamCorruptedException(                            "Unexpected class descriptor type: " + type);            }        }        @Override        protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {            Class<?> clazz;            try {                clazz = classResolver.resolve(desc.getName());            } catch (ClassNotFoundException ignored) {                clazz = super.resolveClass(desc);            }            return clazz;        }    }}
  • HessionObjectSerializer 基于Hession序列化协议的封装
public class HessionObjectSerializer extends AbstractSerializer {    @Override    public byte[] doSerialize(Object dataObject) throws SerializeException {        HessianOutput oeo = null;        try (ByteArrayOutputStream dataArr = new ByteArrayOutputStream()) {            oeo = new HessianOutput(dataArr);            oeo.writeObject(dataObject);            oeo.flush();            return dataArr.toByteArray();        } catch (IOException e) {            throw new SerializeException(e);        } finally {            if (oeo != null) {                try {                    oeo.close();                } catch (IOException e) {                    throw new SerializeException(e);                }            }        }    }    @Override    public Object doDeserialize(byte[] data) throws DeserializeException {        Object o;        HessianInput odi = new HessianInput(new ByteArrayInputStream(data));        try {            o = odi.readObject();        } catch (IOException e) {            throw new DeserializeException(e);        }        return o;    }}
  • Hession2ObjectSerializer 对Hession2序列化的封装
public class Hession2ObjectSerializer extends AbstractSerializer {    @Override    public byte[] doSerialize(Object dataObject) throws SerializeException {        ByteArrayOutputStream dataArr = new ByteArrayOutputStream();        Hessian2Output oeo = null;        try {            oeo = new Hessian2Output(dataArr);            oeo.writeObject(dataObject);            oeo.flush();        } catch (IOException e) {            throw new SerializeException(e);        } finally {            if (oeo != null) {                try {                    oeo.close();                } catch (IOException e) {                    throw new SerializeException(e);                }            }        }        return dataArr.toByteArray();    }    @Override    public Object doDeserialize(byte[] data) throws DeserializeException {        Object o;        Hessian2Input odi = new Hessian2Input(new ByteArrayInputStream(data));        try {            o = odi.readObject();        } catch (IOException e) {            throw new DeserializeException(e);        }        return o;    }    }
如果有优化的建议，希望多多评论，指点一二。以上代码已上传，代码较多就不这里展示。感兴趣的同学可以访问下面链接，查看代码。
仓库实现
四、性能分析
4.1 性能分析
那么以上这几种序列化协议那种速度最好呢?
首先我们先看序列化的速度对比。
使用20个线程，预热3秒，执行5秒对比下吞吐量及内存使用。这里我们只截图排名第一的实现。具体的对比数据已放在github上面，感兴趣的可以自己拉下来看下。
  • ProtostuffObjectSerializer 吞吐量 10,774,518 / s
  • Hession2ObjectSerializer 吞吐量 3,200,559 / s
  • HessionObjectSerializer 吞吐量 3,307,595 / s
  • NettyCompactObjectSerializer 吞吐量 874,793 / s
从上面中的数据我们能看出Protostuff是遥遥领先,这得益于提前把数据类型,提前进行了处理并缓存，其次是友好的API涉及,可以让我们避免频繁生成堆空间。
更多详细的数据对比，可以点下面链接查看。
详细数据
4.2 序列化长度
前面Protostuff在性能上是遥遥领先,那么在数据压缩比例上究竟谁能胜出呢？ 相对于前面性能测试，这种大小测试是比较容易测试, 我们直接执行下面代码，查看结果。
    @Test    @DisplayName("序列化数据大小对比")    public void test7() {        ProtostuffObjectSerializer nettyObjectSerializer = new ProtostuffObjectSerializer();        byte[] jay = nettyObjectSerializer.serialize(new UserSerializable("周杰伦", 42));        ColorConsole.colorPrintln("{},序列化数据长度:{}", "Protostuff", jay.length);        ColorConsole.colorPrintln("{},序列化数据长度:{}", "Hession2",                new Hession2ObjectSerializer().serialize(new UserSerializable("周杰伦", 42)).length);        ColorConsole.colorPrintln("{},序列化数据长度:{}", "Hession",                new HessionObjectSerializer().serialize(new UserSerializable("周杰伦", 42)).length);        ColorConsole.colorPrintln("{},序列化数据长度:{}", "NettyCompact",                new NettyCompactObjectSerializer().serialize(new UserSerializable("周杰伦", 42)).length);    }
实现类 长度 ProtostuffObjectSerializer 13字节 Hession2ObjectSerializer 88字节 HessionObjectSerializer 98字节 NettyCompactObjectSerializer 132字节
还是Protostuff大幅度领先,那么我们的默认序列化协议就使用了吧。是不是很简单呢?
五、总结
通过这一节的实现,我们已经可以使用序列化工具,将Java对象转换成二进制数据了，那么下一篇我们就来实现如果创建网络连接管道吧。
那么你准备好跟我一起Coding了吗?
            
 

            
 
              
 
                
  • 
                  
      
    
                  支付宝打赏 
    • 
                     
    
                
     
                
  • 
                  
      
    
                  微信打赏 
    • 
                     
    
            
    
            
     框架   序列化   JavaRPC 
    
            
    
			
    


    
            
            
    发表评论
    
            
    
              

    

    

    留言与评论（共有 0 条评论）
“”
    

    


    

    

    


    

    



   

    

    
验证码：
 
 
 








      

     
    		

    

    
    		

    

    
	
    
        
    
          
        
    
        
    
 

    	     
            
    
          
          
          
    
            
    相关文章
    
            
    
              
    
                
      Blitz.js 框架漏洞可能允许远程执行代码 
                  
     Blitz.js 框架漏洞可能允许远程执 
    
                
    
              
    
                
      pytest接口自动化测试框架 - Jenkins集成初探 
                  
     pytest接口自动化测试框架 - Jenki 
    
                
    
              
    
                
      Dubbo框架大牛 为什么没照搬Joshua Bloch的这个设计模式 
                  
     Dubbo框架大牛 为什么没照搬Joshua 
    
                
    
              
    
                
      TechEmpower 21轮Web框架 性能评测 - C# 的性能 和 Rust、C++并驾齐驱 
                  
     TechEmpower 21轮Web框架 性能评测 
    
                
    
              
    
                
      TMPaaS框架-通讯协议定义 
                  
     TMPaaS框架-通讯协议定义 
    
                
    
              
    
                
      6个顶级的可解释AI (XAI)的Python框架推荐 
                  
     6个顶级的可解释AI (XAI)的Python 
    
                
    
              
                
    
          
    
        
         
      
    
        
        
    
          
    
            
    推荐文章
    
          
    
          
     
            
      
                          
    
          
    
          
    
        
    
        
    
        
        
    
        
    
          
    
            
    最热点击文章
    
          
    
          
     
            
          
    
          
    
        
    
        
    
          
    
            
    热门标签