序列化、反序列化原理

一、 基本概念

• 序列化：将Java对象装换成字节序列

对象序列化的最主要的用处就是再传递和保存对象的时候，保存对象的完整性和可传递性.序列化把对象转换成有序字节流,以便在网络上传输或者保存在本地文件中.序列化后的字节流保存了Java对象的状态以及相关描述信息.序列化机制的核心作用就是对象状态的保存与重建.

• 反序列化:把字节序列转换成Java对象

客户端从文件或者网络上获得序列化后的对象字节流后,根据字节流中保存的对象状态以及描述信息,通过反序列化重构对象.

二、为什么需要序列化和反序列化

我们知道,当两个进程远程通信时,可以发送各种类型的数据,如文本、图片、音频、视频等，而这些数据都会以二进制序列的形式在网络上传送。
还有，当互联网电商项目并发访问很大的时候，数百万用户产生数百万个session对象，内存可能吃不消，同时用户登录后不一定需要时时刻刻用到该session对象，那么我们的web容器可以将当前并没有使用的session对象序列化到磁盘中，等到需要使用的时候再反序列化为对象！
那么当两个Java进程进行通信时,能否实现进程间对象的传送呢?如何做到呢?–答案是肯定的,这就需要Java序列化与反序列化了!

通过以我们可以清晰的知道Java序列化的好处:

1. 实现数据的持久化,通过序列化可以把数据永久的保存到硬盘中(本地文件中)
2. 利用序列化实现远程通信,即在网络上传送对象的字节序列

三、实现序列化和反序列化的方式

如果对象的String，或数组，或Enum，或Serializable，那么就可以对该对象进行序列化,否则将抛出NotSerializableException

1、JDK类库API

1. java.io.ObjectOutputStream：表示对象输出流

writeObject(Object obj)可以对参数指定的obj对象进行序列化,把得到的字节序列写到一个目标输出流中

2. java.io.ObjectInputStream：表示对象输入流

readObject()方法从输入流中读取字节序列,再把它们反序列化成为一个对象

持久化到本地文件中

	/**
     * 下面这种是把对象序列化后持久化到文件中,再从文件源反序列化为对象
     */
 @Test
    public void test1() throws IOException, ClassNotFoundException {

        //序列化
        ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("object.text"));
        obs.writeObject("hello world");
        obs.flush();
        obs.close();


        //烦序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.text"));
        String object = (String) ois.readObject();
        System.out.println(object);
        ois.close();
    }

转换为byte数组流,看字节的大小,后续和另外两种方式做对比

 /**
     * 把对象序列化输出到Byte数组输出流中,再从Byte数组输入流反序列化为对象
     */
    @Test
    public  void test2() throws IOException, ClassNotFoundException {
        User user = new User("lucy","UK",12);
        ByteArrayOutputStream bao = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bao);
        System.out.println(user);
        oos.writeObject(user);
        byte[] bytes = bao.toByteArray();
        System.out.println(Arrays.toString(bytes));
        oos.flush();
        oos.close();
        bao.close();


        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
        User object = (User) ois.readObject();
        System.out.println(object);
        ois.close();


    }

Byte的结果是

[-84, -19, 0, 5, 115, 114, 0, 32, 99, 111, 109, 46, 119, 99, 121, 46, 115, 101, 114, 105, 97, 108, 105, 122, 97, 98, 108, 101, 46, 100, 111, 109, 97, 105, 110, 46, 85, 115, 101, 114, -6, -62, -58, -32, -74, 116, 89, -124, 2, 0, 3, 76, 0, 7, 97, 100, 100, 114, 101, 115, 115, 116, 0, 18, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 76, 0, 3, 97, 103, 101, 116, 0, 19, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 73, 110, 116, 101, 103, 101, 114, 59, 76, 0, 8, 117, 115, 101, 114, 78, 97, 109, 101, 113, 0, 126, 0, 1, 120, 112, 116, 0, 2, 85, 75, 115, 114, 0, 17, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 73, 110, 116, 101, 103, 101, 114, 18, -30, -96, -92, -9, -127, -121, 56, 2, 0, 1, 73, 0, 5, 118, 97, 108, 117, 101, 120, 114, 0, 16, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 78, 117, 109, 98, 101, 114, -122, -84, -107, 29, 11, -108, -32, -117, 2, 0, 0, 120, 112, 0, 0, 0, 12, 116, 0, 4, 108, 117, 99, 121]

2、JSON方式

这里我们使用比较有代表性的Gson插件来进行序列化转换
引入依赖

<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.6</version>
        </dependency>

测试代码如下

 @Test
    public void test4() throws IOException {
        User user = new User("lucy","UK",12);

        //序列化
        Gson gson = new Gson();
        String s = gson.toJson(user);
        System.out.println(s);
        byte[] bytes = s.getBytes();
        System.out.println(Arrays.toString(bytes));

        //反序列化
        User user1 = gson.fromJson(s, User.class);
        System.out.println(JSONObject.toJSONString(user1));

        OutputStream os = new FileOutputStream("object3.text");
        os.write(bytes);
        os.close();
    }

测试结果

[123, 34, 117, 115, 101, 114, 78, 97, 109, 101, 34, 58, 34, 108, 117, 99, 121, 34, 44, 34, 97, 100, 100, 114, 101, 115, 115, 34, 58, 34, 85, 75, 34, 44, 34, 97, 103, 101, 34, 58, 49, 50, 125]

从上明细可以看出，Gson较JDK原生序列化方式性能更好

四、面试重点

1. 只会序列化对象的状态（信息），而不是序列化对象结构（方法）
2. 如果父类序列化了，那么子类自动实现了序列化，不需要再实现Serializable接口
3. 当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化，所以，引用的对象也要实现Serializable接口
4. 并非所有的对象都需要进行序列化，基于性能

当我们让某个类实现Serializable接口，在序列化时,不仅会序列化当前对象，还会对该对象引用的其他对象也进行序列化，同样的，其他对象引用的对象也将被序列化，以此类推。**所以，如果一个对象包含的成员变量是容器类对象，而这些容器所含有的元素也是容器类对象，那么这个序列化的过程就会较复杂，开销也较大。**如Spring中的ClassPathXmlApplicationContext这类容器对象

5. transient类型的成员变量不能被序列化，如果想序列化，你可以通过重写writeObject和readObject方法来实现指定字段序列化。注意：序列化和反序列化字段顺序要保持一致，需要序列化的字段都要写进方法中
6. 通过实现Externalizable接口实现序列化
   注：1 需要序列化的字段writeExternal和readExternal方法中都要处理
   2 一定要有空参构造方法

public class Student implements Externalizable {
    private static final long serialVersionUID = 506789877483725314L;

    public Student(String userName, String address, Integer age) {
        this.userName = userName;
        this.address = address;
        this.age = age;
    }

    public Student() {
    }

    private String userName;
    private  String address;
    private Integer age;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(userName);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        userName = (String) in.readObject();
    }
}

7. 可以通过控制serialVersionUID来到达允许兼容或者不兼容的问题

如果希望不同版本对象相互兼容，那么serialVersionUID 需要相同
如果不希望不同版本对象相互兼容，那么serialVersionUID 需要不同

8. 引用对象的序列化其实就是深拷贝