概念
序列化：将Java对象转化为字节数组
反序列化：将字节数组转化为Ｊava对象
在RPC应用中，进行跨进程远程调用的时候，需要使用特定的序列化技术，需要对进行网络传输的对象进行序列化和反序列化。
影响序列化选择有两个因素
１. 序列化之后码流的大小，如果太大，那么将会影响网络传输的性能。
2. 序列化和反序列化过程的性能
常用的序列化框架性能比较
本文主要进行以下序列化框架的对比测试：
- JDK
- FastJson
- Hessian
- Protostuff
准备
需要序列化的对象，这是一个复杂的对象。
NettyMessage
public class NettyMessage implements Serializable { //消息头
private Header header;
//消息体
private Object body;
}@Data
public class Header implements Serializable { //校验头
private int crcCode; //消息头消息体的总长度
private int length; //全局唯一id
private long sessionId; //消息类型
private MessageType type; //扩展字段
private Map<String,Object> attachment;
}@Data
public class RpcRequest implements Serializable {
private long requestId; //请求id
private String interfaceName; //调用类名
private String methodName; //调用方法名
private String[] parameterTypes; //方法参数类型
private Object[] parameters; //方法参数}
创建一个构造器创建该对象。
public class NettyMessageBuilder { public static NettyMessage build(){ NettyMessage message = new NettyMessage();
Header header = new Header();
RpcRequest request = new RpcRequest(); header.setCrcCode(1234);
header.setType(MessageType.APP_RESPONE_TYPE);
header.setLength(100);
header.setSessionId(200); Map<String,Object> map = new LinkedHashMap<>(); map.put("demoKey",(Object)"demoValue");
header.setAttachment(map); request.setInterfaceName("com.demo");
String[] types = {"java.lang.String" ,"java.lang.Integer"};
String[] param = {"java.lang.String" ,"java.lang.Integer"};
request.setParameterTypes(types);
request.setParameters(param);
request.setMethodName("buy");
request.setRequestId(123456); message.setHeader(header);
message.setBody(request); return message;
}}
定义序列化接口
public abstract class AbstractSerialize { public abstract <T> byte[] serialize(T obj);
public abstract <T> T deserialize(byte[] data, Class<T> clazz);}
JDK
实现
public class JdkSerializeUtil extends AbstractSerialize { public <T> byte[] serialize(T obj) { if (obj == null){
throw new NullPointerException();
} ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(obj);
return bos.toByteArray();
} catch (Exception ex) {
ex.printStackTrace();
}
return new byte[0];
} public <T> T deserialize(byte[] data, Class<T> clazz) {
ByteArrayInputStream bis = new ByteArrayInputStream(data); try {
ObjectInputStream ois = new ObjectInputStream(bis);
T obj = (T)ois.readObject();
return obj;
} catch (Exception ex) {
ex.printStackTrace();
} return null;
}
}
FastJson
引入pom
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.56</version>
</dependency>
实现
public class FastjsonSerializeUtil extends AbstractSerialize { public <T> byte[] serialize(T obj) {
if (obj == null){
throw new NullPointerException();
} String json = JSON.toJSONString(obj);
byte[] data = json.getBytes();
return data;
} public <T> T deserialize(byte[] data, Class<T> clazz) { T obj = JSON.parseObject(new String(data),clazz);
return obj;
}
}
Hessian
<dependency>
<groupId>com.caucho</groupId>
<artifactId>hessian</artifactId>
<version>4.0.60</version>
</dependency>
实现
@Slf4j
public class HessianSerializeUtil extends AbstractSerialize { public <T> byte[] serialize(T obj) { if (obj == null){
throw new NullPointerException();
}
try{
ByteArrayOutputStream bos = new ByteArrayOutputStream();
HessianOutput ho = new HessianOutput(bos);
ho.writeObject(obj); return bos.toByteArray();
}
catch(Exception ex){
log.error("HessianSerializeUtil序列化发生异常!"+ex);
throw new RuntimeException();
} } public <T> T deserialize(byte[] data, Class<T> clazz) { if (data == null){
throw new NullPointerException();
}
try{
ByteArrayInputStream bis = new ByteArrayInputStream(data);
HessianInput hi = new HessianInput(bis);
return (T)hi.readObject(); }
catch(Exception ex){
log.error("HessianSerializeUtil反序列化发生异常!"+ex);
throw new RuntimeException();
} }
}
Protostuff
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.6.0</version>
<scope>compile</scope>
</dependency><!-- https://mvnrepository.com/artifact/io.protostuff/protostuff-runtime -->
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>1.6.0</version>
</dependency>
实现
public class ProtostuffSerializeUtil extends AbstractSerialize { /**
* 避免每次序列化都重新申请Buffer空间
*/
private static LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
/**
* 缓存Schema
*/
private static Map<Class<?>, Schema<?>> schemaCache = new ConcurrentHashMap<Class<?>, Schema<?>>(); public <T> byte[] serialize(T obj) { if (obj == null){
throw new NullPointerException();
}
Class<T> clazz = (Class<T>) obj.getClass();
Schema<T> schema = getSchema(clazz);
byte[] data;
try {
data = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
} finally {
buffer.clear();
} return data;
} public <T> T deserialize(byte[] data, Class<T> clazz) {
Schema<T> schema = getSchema(clazz);
T obj = schema.newMessage();
ProtostuffIOUtil.mergeFrom(data, obj, schema);
return obj;
} private static <T> Schema<T> getSchema(Class<T> clazz) {
Schema<T> schema = (Schema<T>) schemaCache.get(clazz);
if (schema == null) {
//这个schema通过RuntimeSchema进行懒创建并缓存
//所以可以一直调用RuntimeSchema.getSchema(),这个方法是线程安全的
schema = RuntimeSchema.getSchema(clazz);
if (schema != null) {
schemaCache.put(clazz, schema);
}
} return schema;
}}
测试
测试方法
@Test
public void testFastJsonSerialize(){
//这里替换各种序列化实现类
AbstractSerialize serialize = new ProtostuffSerializeUtil(); NettyMessage message = NettyMessageBuilder.build(); TimeUtil timeUtil = new TimeUtil();
TimeUtil timeUtil1 = new TimeUtil(); NettyMessage result = null;
byte[] serByte = serialize.serialize(message);
System.out.println("字节长度:" + serByte.length);
result = serialize.deserialize(serByte,NettyMessage.class);
//这里设置测试次数
for(int i = 0; i< 100000; i++){
//timeUtil.init();
timeUtil.start();
serByte = serialize.serialize(message);
timeUtil.end();
//System.out.println("序列化时间："+ timeUtil.getAvrTimeUs() + " Us"); timeUtil1.start();
result = serialize.deserialize(serByte,NettyMessage.class);
timeUtil1.end(); }
System.out.println("序列化时间："+ timeUtil.getAvrTimeUs() + " Us");
System.out.println("反序列化时间："+ timeUtil1.getAvrTimeUs() + " Us"); System.out.println("结果:" + result); }
这里定义了一个TimeUtil类来计时
public class TimeUtil { private long startTime;
private long endTime;
private long timeSum;
private long count; public void init(){
timeSum = 0;
count = 0;
} public void start(){
startTime = System.nanoTime(); } public void end(){
endTime = System.nanoTime();
timeSum += (endTime-startTime);
count++;
} public long getAvrTimeNs(){
return (timeSum/count);
}
public long getAvrTimeUs(){
return (timeSum/count)/1000;
} public long getAvrTimeMs(){
return (timeSum/count)/1000000;
}}
| 码流大小(byte) | 10次(us) | 100次(us) | 1000次(us) | 10000次(us) | 100000次(us) | ||
| FastJson | 305 | 116-243 | 106-185 | 90-140 | 26-39 | 8-12 | |
| JDK | 866 | 383-777 | 502-1101 | 123-334 | 54-237 | 15-76 | |
| Hessian | 520 | 959-3836 | 376-567 | 191-329 | 99-161 | 30-47 | |
| Protostuff | 193 | 103-145 | 90-137 | 75-135 | 15-24 | 5-8 | |
注：
1. 码流单位为字节
2. 序列化耗时－反序列化耗时，单位为微秒
从以上测试可以看出
1. JDK方式的码流最大，不利于网络传输。
2. 从整体来看，Prorostuff的码流最小，序列化性能最好。
