RPC通信的序列化方式选型

背景

上一篇已经介绍了定制了一个建议的RPC框架：简易RPC实现，
之前的实现方式是Fastjson，但是为了进一步优化框架的性能。

几种常见的序列化方式

java自带的序列化，对象继承Serializable
xml，json，fastjson
Avro
Protobuf
等等

一些简单的比较

Serializable

优点： java原生，java工程中出镜率高
缺点：性能差，空间占用多，在网络通信中用得很少，需要指定serialVersionUID

xml，json，fastjson

优点：可读性好，fastjson在速度上有优势，json格式在建站，特别是对于性能要求不是很高的场景应用很广泛。
缺点：xml，json性能和空间占用上都没有优势，fastjson在国内用得很多，但是文档不全，时间类的序列化有bug，国际上口碑一般。

avro

优点：Avro 是 Hadoop 的一个子项目，Avro提供两种序列化格式：JSON格式或者Binary格式。Binary格式在空间开销和解析性能方面可以和Protobuf媲美，动态语言友好，Avro提供的机制使动态语言可以方便地处理Avro数据。avro是基于schema（模式），这和protobuf、thrift没什么区别

protobuf

优点：跨语言，可自定义数据结构。二进制消息，效率高，性能高。Netty等框架集成了该协议。序列化后码流小，性能高。提供结构化数据存储格式（XML JSON等）
缺点：二进制格式，可读性差（抓包dump后的数据很难看懂）
适用场景：

对性能要求高的RPC调用
具有良好的跨防火墙的访问属性
适合应用层对象的持久化

选型建议

受到这个文章的启发：
https://www.cnblogs.com/wkcode/p/10431096.html

耗时

空间占用

分析上图知：

XML序列化（Xstream）无论在性能和简洁性上比较差。
Thrift与Protobuf相比在时空开销方面都有一定的劣势。
Protobuf和Avro在两方面表现都非常优越。

不同的场景适用的序列化协议：

对于公司间的系统调用，如果性能要求在100ms以上的服务，基于XML的SOAP协议是一个值得考虑的方案。
基于Web browser的Ajax，以及Mobile app与服务端之间的通讯，JSON协议是首选。对于性能要求不太高，或者以动态类型语言为主，或者传输数据载荷很小的的运用场景，JSON也是非常不错的选择。
对于调试环境比较恶劣的场景，采用JSON或XML能够极大的提高调试效率，降低系统开发成本。
当对性能和简洁性有极高要求的场景，Protobuf，Thrift，Avro之间具有一定的竞争关系。
对于T级别的数据的持久化应用场景，Protobuf和Avro是首要选择。如果持久化后的数据存储在Hadoop子项目里，Avro会是更好的选择。
由于Avro的设计理念偏向于动态类型语言，对于动态语言为主的应用场景，Avro是更好的选择。
对于持久层非Hadoop项目，以静态类型语言为主的应用场景，Protobuf会更符合静态类型语言工程师的开发习惯。
如果需要提供一个完整的RPC解决方案，Thrift是一个好的选择。
如果序列化之后需要支持不同的传输层协议，或者需要跨防火墙访问的高性能场景，Protobuf可以优先考虑。
空间

Protobuf实现

结合以上信息，项目对于性能要求较高，决定使用Protobuf作为序列化协议。

Objenesis的使用

Java已经支持使用class.newinstance()的类动态实例化，但是必须要有一个合适的构造函数。而很多场景下类不能够用这种方式去实例化，例如：

构造函数需要参数（Constructors that require arguments）
有副作用的构造函数（Constructors that have side effects）
会抛出异常的构造函数（Constructors that throw exceptions）

Objenesis objenesis = new ObjenesisStd(); // or ObjenesisSerializer
MyThingy thingy1 = (MyThingy) objenesis.newInstance(MyThingy.class);

// or (a little bit more efficient if you need to create many objects)

Objenesis objenesis = new ObjenesisStd(); // or ObjenesisSerializer
ObjectInstantiator thingyInstantiator = objenesis.getInstantiatorOf(MyThingy.class);

MyThingy thingy2 = (MyThingy)thingyInstantiator.newInstance();
MyThingy thingy3 = (MyThingy)thingyInstantiator.newInstance();
MyThingy thingy4 = (MyThingy)thingyInstantiator.newInstance();

核心代码

    public static <T> String serializer(T obj) {
        Class<T> cls = (Class<T>) obj.getClass();
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try {
            Schema<T> schema = getSchema(cls);
            return new String(ProtostuffIOUtil.toByteArray(obj, schema, buffer));
        } catch (Exception e) {
            log.error("protobuf序列化失败");
            throw new IllegalStateException(e.getMessage(), e);
        } finally {
            buffer.clear();
        }
    }

    public static <T> T deserializer(byte[] bytes, Class<T> clazz) {
        try {
            T message = (T) objenesis.newInstance(clazz);
            Schema<T> schema = getSchema(clazz);
            ProtostuffIOUtil.mergeFrom(bytes, message, schema);
            return message;
        } catch (Exception e) {
            log.error("protobuf反序列化失败");
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

实验结果比较

测试对象：

@Data
public class TestObject {

    String a = "123";
    String a1 = "a1";
    String a2 = "a2";
    Integer b = 10;
    Double c = 2.5;

    List<String> d = Arrays.asList(new String[]{"1", "2"});
    Map<String, String> e = new HashMap<String, String>(){
            {
                    put("ak", "av");
            }
    };

    Object f = null;
}

分别用fastjson和protobuf，序列化/反序列化 1000次：

fastjson si result:{"a":"123","a1":"a1","a2":"a2","b":10,"c":2.5,"d":["1","2"],"e":{"ak":"av"}}
fastjson desi result:TestObject(a=123, a1=a1, a2=a2, b=10, c=2.5, d=[1, 2], e={ak=av}, f=null)
fastjson cost:362
fastjson size:76

protebuf si result:
�123��a1��a2 
)�@2�12�2;�
�ak��av<
protebuf desi result:TestObject(a=123, a1=a1, a2=a2, b=10, c=2.5, d=[1, 2], e={ak=av}, f=null)
protebuf cost:275
protebuf size:42

可以看到，

字符长度和耗时（cost，单位毫秒），protobuf优于fastjson
fastjson的可读性较好