【290期】为什么不建议使用Java序列化？

原创李二狗 Java面试题精选

今天去看牙医，他问我年级轻轻牙齿怎么磨损这么严重？我说，没有人点赞的这些年，我都是咬着牙过来的。

首先，解释一下序列化的概念

把对象转换为字节序列的过程称为对象的序列化。

什么情况下需要用到序列化

把的内存中的对象状态保存到一个文件中或者数据库中时候；
使用套接字在网络上传送对象的时候；
通过RMI传输对象的时候；

总之一句话，只要我们对内存中的对象进行持久化或网络传输, 都需要进行序列化和反序列化。

如果研究过一些常用的RPC通信框架，我们会发现它们极少使用Java自带的序列化，什么原因？

1、无法跨语言

通过Java的原生Serializable接口与ObjectOutputStream实现的序列化，只有java语言自己能通过ObjectInputStream来解码，其他语言，如C、C++、Python等等，都无法对其实现解码。而在我们实际开发生产中，有时不可避免的需要基于不同语言编写的应用程序之间进行通信，这个时候Java自带的序列化就无法搞定了。

2、性能差

我们来对比Java自带的序列化与NIO中的ByteBuffer编码的性能

UserInfo类

import java.io.Serializable;
import java.nio.ByteBuffer;
public class UserInfo implements Serializable {
    private static final long serialVersionUID = 1L;

    private Long id;

    private String name;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public byte[] codeC() {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        byte[] value = this.name.getBytes();
        buffer.putInt(value.length);
        buffer.put(value);
        buffer.putLong(this.id);
        buffer.flip();
        byte[] result = new byte[buffer.remaining()];
        buffer.get(result);
        return result;
    }

    public byte[] codeC(ByteBuffer buffer) {
        buffer.clear();
        byte[] value = this.name.getBytes();
        buffer.putInt(value.length);
        buffer.put(value);
        buffer.putLong(this.id);
        buffer.flip();
        byte[] result = new byte[buffer.remaining()];
        buffer.get(result);
        return result;
    }

}

测试类

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.nio.ByteBuffer;

public class MainTest {

    public static void main(String[] args) throws Exception {
        UserInfo info = new UserInfo();
        info.setId(1L);
        info.setName("Tom");

        int loop = 100_0000;
        ByteArrayOutputStream bout = null;
        ObjectOutputStream out = null;
        long start = System.currentTimeMillis();
        for (int i = 0; i < loop; i++) {
            bout = new ByteArrayOutputStream();
            out = new ObjectOutputStream(bout);
            out.flush();
            out.close();
            byte[] b = bout.toByteArray();
            bout.close();
        }
        System.out.println("jdk serializable time : " + (System.currentTimeMillis() - start) + " ms");

        System.out.println("------------------------------");

        start = System.currentTimeMillis();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        for (int i = 0; i < loop; i++) {
            byte[] bytes = info.codeC(buffer);
        }
        System.out.println("ByteBuffer time : " + (System.currentTimeMillis() - start) + " ms");
    }
}

输出结果：

3、序列后的码流太大

java序列化的大小是二进制编码的5倍多！

序列化后的二进制数组越大，占用的存储空间就越多，如果我们是进行网络传输，相对占用的带宽就更多，也会影响系统的性能。

我们来测试一下：

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;

public class MainTest {

    public static void main(String[] args) throws Exception {
        UserInfo info = new UserInfo();
        info.setId(1L);
        info.setName("Tom");
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(bout);
        out.writeObject(info);
        out.flush();
        out.close();
        byte[] b = bout.toByteArray();
        System.out.println("jdk serializable: " + b.length);
        bout.close();
        System.out.println("ByteBuffer : " + info.codeC().length);
    }
}