一些常用Java序列化框架的比较

概念

序列化：将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的码流最小，序列化性能最好。