一起写RPC框架（五）RPC网络模块的搭建三 序列化

 说到序列化，这在RPC的层面上也是很重要的一个环节，因为在我们的业务层面，你传输的一个对象，是一个Object，不过在网络上，却不管你传输的是Obj1，还是Obj2，网络只认byte，所以在代码层面上，如何将对象转化成byte数组，和如何将byte数组反序列化层对象，这也是很重要的，直接影响你的整个框架的性能

java原生态的java.io.Serializable就对序列化提供了支持，不过性能和序列化的结果并不是很让人满意的，在众多的序列化工具中，例如protostuff。kryo,fastjson等等，N多序列化的工具，估计java原生的是比较差的（如果不差，这些第三方的序列化的工具也不会出现了）

关于这些序列化的工具的性能对比我们不做研究，有兴趣的可以查看：
https://github.com/eishay/jvm-serializers/wiki
有人说，不支持多种序列化方式的RPC框架，不是好的RPC框架，所以我们还是实现几个吧，我们基于SPI的方式(SPI 简介http://www.cnblogs.com/softlin/p/4321955.html)去实现protostuff，fastjson，kryo这三种序列化方式

（注：学习RPC之前，学些Jupiter之前，我也不会SPI,序列化，但是学习之后就算入门了，以后看到了也能看明白，至少能说出一二，抛开RPC不谈，这也是积累吧）

废话不多说，我们先上代码

1）先定义序列化和反序列化的接口

package org.laopopo.common.serialization;

/**
*
* @author BazingaLyn
* @description 序列化接口
* @time 2016年8月12日
* @modifytime
*/
public interface Serializer {

/**
* 将对象序列化成byte[]
* @param obj
* @return
*/
<T> byte[] writeObject(T obj);

/**
* 将byte数组反序列成对象
* @param bytes
* @param clazz
* @return
*/
<T> T readObject(byte[] bytes, Class<T> clazz);
}

2)写一个基于SPI的调用入口方法

SerializerHolder.java

package org.laopopo.common.serialization;

import org.laopopo.common.spi.BaseServiceLoader;

/**
*
* @author BazingaLyn
* @description 序列化的入口,基于SPI方式
* @time 2016年8月12日
* @modifytime
*/
public final class SerializerHolder {

// SPI
private static final Serializer serializer = BaseServiceLoader.load(Serializer.class);

public static Serializer serializerImpl() {
return serializer;
}
}

BaseServiceLoader.java

package org.laopopo.common.spi;

import java.util.ServiceLoader;

/**
*
* @author BazingaLyn
* @description SPI loader
* @time 2016年8月11日
* @modifytime
*/
public final class BaseServiceLoader {

public static <S> S load(Class<S> serviceClass) {
return ServiceLoader.load(serviceClass).iterator().next();
}
}

因为了解SPI之后，我们还知道我们需要创建一个文本文件：



Serializer中的内容我们默认使用protostuff实现序列化：

org.laopopo.common.serialization.proto.ProtoStuffSerializer

3）具体实现

①基于ProtoStuff实现：

maven依赖

<protostuff.version>1.3.5</protostuff.version>
<objenesis.version>2.1</objenesis.version>

<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>${protostuff.version}</version>
</dependency>
<dependency>
<groupId>org.objenesis</groupId>
<artifactId>objenesis</artifactId>
<version>${objenesis.version}</version>
</dependency>

具体实现类ProtoStuffSerializer.java

package org.laopopo.common.serialization.proto;

import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.RuntimeSchema;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.laopopo.common.serialization.Serializer;
import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;

/**
*
* @author BazingaLyn
* @description 使用protoStuff序列化
* 序列化的对象不需要实现java.io.Serializable 也不需要有默认的构造函数
* @time 2016年8月12日
* @modifytime
*/
public class ProtoStuffSerializer implements Serializer {

private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<Class<?>, Schema<?>>();

private static Objenesis objenesis = new ObjenesisStd(true);

@SuppressWarnings("unchecked")
public <T> byte[] writeObject(T obj) {

System.out.println("ProtoStuffSerializer Serializer");
Class<T> cls = (Class<T>) obj.getClass();
LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
try {
Schema<T> schema = getSchema(cls);
return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
} catch (Exception e) {
throw new IllegalStateException(e.getMessage(), e);
} finally {
buffer.clear();
}
}

public <T> T readObject(byte[] bytes, Class<T> clazz) {
try {
System.out.println("ProtoStuffSerializer Deserializer");
T message = objenesis.newInstance(clazz);
Schema<T> schema = getSchema(clazz);
ProtostuffIOUtil.mergeFrom(bytes, message, schema);
return message;
} catch (Exception e) {
throw new IllegalStateException(e.getMessage(), e);
}
}

@SuppressWarnings("unchecked")
private static <T> Schema<T> getSchema(Class<T> cls) {
Schema<T> schema = (Schema<T>) cachedSchema.get(cls);
if (schema == null) {
schema = RuntimeSchema.createFrom(cls);
cachedSchema.put(cls, schema);
}
return schema;
}

}

②基于fastjson实现：

maven依赖

<fastjson.version>1.2.3</fastjson.version>

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>

具体实现FastjsonSerializer.java

package org.laopopo.common.serialization.fastjson;

import org.laopopo.common.serialization.Serializer;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;

/**
*
* @author BazingaLyn
* @description 使用fastjson序列化
* 需要有无参构造函数
* @time 2016年8月12日
* @modifytime
*/
public class FastjsonSerializer implements Serializer {

@Override
public <T> byte[] writeObject(T obj) {
System.out.println("FastjsonSerializer Serializer");
return JSON.toJSONBytes(obj, SerializerFeature.SortField);
}

@Override
public <T> T readObject(byte[] bytes, Class<T> clazz) {
System.out.println("FastjsonSerializer Deserializer");
return JSON.parseObject(bytes, clazz, Feature.SortFeidFastMatch);
}

}

③基于kryo实现

maven依赖

<kryo.version>2.21</kryo.version>

<dependency>
<groupId>com.esotericsoftware.kryo</groupId>
<artifactId>kryo</artifactId>
<version>${kryo.version}</version>
</dependency>

具体的实现KryoSerializer.java

package org.laopopo.common.serialization.kryo;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

import org.laopopo.common.serialization.Serializer;

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.serializers.JavaSerializer;

/**
*
* @author BazingaLyn
* @description 使用Kryo序列化
* 需要实现java.io.Serializable接口
* @time 2016年8月12日
* @modifytime
*/
public class KryoSerializer implements Serializer {

@Override
public <T> byte[] writeObject(T obj) {
System.out.println("KryoSerializer serializer");
Kryo kryo = new Kryo();
kryo.setReferences(false);
kryo.register(obj.getClass(), new JavaSerializer());

ByteArrayOutputStream baos = new ByteArrayOutputStream();
Output output = new Output(baos);
kryo.writeClassAndObject(output, obj);
output.flush();
output.close();

byte[] b = baos.toByteArray();
try {
baos.flush();
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
return b;
}

@SuppressWarnings("unchecked")
@Override
public <T> T readObject(byte[] bytes, Class<T> clazz) {
System.out.println("KryoSerializer deserializer");
Kryo kryo = new Kryo();
kryo.setReferences(false);
kryo.register(clazz, new JavaSerializer());

ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
Input input = new Input(bais);
return (T) kryo.readClassAndObject(input);
}

}

我们做个简单的测试，先定义一个要序列化的稍微复杂一点的类

package org.laopopo.example.netty;

import java.io.Serializable;

import org.laopopo.common.exception.remoting.RemotingCommmonCustomException;
import org.laopopo.common.transport.body.CommonCustomBody;

public class TestCommonCustomBody implements CommonCustomBody,Serializable {

/**
*
*/
private static final long serialVersionUID = 7679994718274344134L;

private int id;

private String name;

private ComplexTestObj complexTestObj;

public TestCommonCustomBody() {
}

public TestCommonCustomBody(int id, String name, ComplexTestObj complexTestObj) {
this.id = id;
this.name = name;
this.complexTestObj = complexTestObj;
}

public ComplexTestObj getComplexTestObj() {
return complexTestObj;
}

public void setComplexTestObj(ComplexTestObj complexTestObj) {
this.complexTestObj = complexTestObj;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public void checkFields() throws RemotingCommmonCustomException {

}

@Override
public String toString() {
return "TestCommonCustomBody [id=" + id + ", name=" + name + ", complexTestObj=" + complexTestObj + "]";
}

public static class ComplexTestObj implements Serializable {

/**
*
*/
private static final long serialVersionUID = 5694424296393939225L;

private String attr1;

private Integer attr2;

public ComplexTestObj() {
}

public ComplexTestObj(String attr1, Integer attr2) {
super();
this.attr1 = attr1;
this.attr2 = attr2;
}

public String getAttr1() {
return attr1;
}

public void setAttr1(String attr1) {
this.attr1 = attr1;
}

public Integer getAttr2() {
return attr2;
}

public void setAttr2(Integer attr2) {
this.attr2 = attr2;
}

@Override
public String toString() {
return "ComplexTestObj [attr1=" + attr1 + ", attr2=" + attr2 + "]";
}

}

}

测试类SerializerTest.java

package org.laopopo.example.serializer;

import org.laopopo.example.netty.TestCommonCustomBody;
import org.laopopo.example.netty.TestCommonCustomBody.ComplexTestObj;
import static org.laopopo.common.serialization.SerializerHolder.serializerImpl;

/**
*
* @author BazingaLyn
* @description
*
* 1)使用protoStuff序列化测试
* 修改org.laopopo.common.serialization.Serializer中的内容为：
* org.laopopo.common.serialization.proto.ProtoStuffSerializer
*
* 2)使用fastjson序列化测试
* 修改org.laopopo.common.serialization.Serializer中的内容为：
* org.laopopo.common.serialization.fastjson.FastjsonSerializer
*
* 3)使用kryo序列化测试
* 修改org.laopopo.common.serialization.Serializer中的内容为：
* org.laopopo.common.serialization.kryo.KryoSerializer
*
* @time 2016年8月12日
* @modifytime
*/
public class SerializerTest {

public static void main(String[] args) {

long beginTime = System.currentTimeMillis();

for(int i = 0;i < 100000;i++){
ComplexTestObj complexTestObj = new ComplexTestObj("attr1", 2);
TestCommonCustomBody commonCustomHeader = new TestCommonCustomBody(1, "test",complexTestObj);
byte[] bytes = serializerImpl().writeObject(commonCustomHeader);

TestCommonCustomBody body = serializerImpl().readObject(bytes, TestCommonCustomBody.class);
}

long endTime = System.currentTimeMillis();

System.out.println((endTime - beginTime));

}

}

三次运行的结果是：







在这边并没有很规范的去测试性能，不过，看起结果至少在一个数量级上，这就是序列化部分的内容

本节END~ 如果有错误的地方欢迎纠正