背景
上一篇已经介绍了定制了一个建议的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的可读性较好
网友评论