java之序列化与反序列化的详细解析（全）_java序列化和反序列化原理

前言

经常看到一些源码或者代码项目中继承一个Serializable 接口，但是究其原因有时候却很难讲清楚

这篇文章涉及一些IO流可看我之前的文章
java NIO从入门到精通（全）

1. 定义

序列化（Serialize）：内存当中的java对象放到硬盘文件中，java对象存储到文件中，将java对象的状态保存下来的过程，需要使用ObjectOutputStream类

反序列化（DeSerialize）：将硬盘上的数据重新恢复到内存中，恢复成java对象。需要使用ObjectInputStream类

通俗的说，序列化就是通过网络中的管道，切成一个一个小的数据包（有编号，拆分）放到硬盘文件。一个个小的数据包（组装）恢复到内存中，就是反序列化

或者也可以这样理解

序列化是指把一个Java对象变成二进制内容，因为要在网络中传输，而且要快便捷，本质上是一个byte[]数组，序列化后可以将其数组保存到网络中传输
。反序列化，即把一个二进制内容（也就是byte[]数组）变回Java对象

对象的序列化主要有两种用途：

• 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；（持久化对象）
• 在网络上传送对象的字节序列。（网络传输对象）

2. 细节

java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中

2.1 API接口

ObjectOutputStream和ObjectInputStream类

序列化和反序列化需要使用的两个类的api接口：

①java.io.ObjectInputStream：对象输入流
使用该类的readObject()方法从输入流中读取字节序列
将字节序列反序列化为一个对象

②java.io.ObjectOutputStream：对象输出流
使用该类的writeObject(Object obj)方法将传入的obj对象进行序列化
得到的字节序列写入输出流中输出

Serializable接口

• 一般出现这个错误java.io.NotSerializableException，说明创建的实体类对象对象没有继承序列化
• 参与序列化和反序列化的实体类对象，必须实现Serializable接口
• 参与序列化的ArrayList集合以及集合中的元素User都需要实现 java.io.Serializable接口。

通过查看其Serializable接口的源码，只是一个标志接口：

public interface Serializable {
}
1
2

接口中的代码没有实体的，但却要继承，主要是起到一个标识的作用，jvm看到实体类继承了Serializable这个接口，就会自动为该类生成一个版本序列号

2.2 版本序列号

所谓的版本序列号

java虚拟机识别一个类的时候先通过类名，如果类名一致，再通过序列化版本号

同一个文件中源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件，并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变。所以一般写上序列号之后，即使改动了之后，也可以识别到该类，一般要写上序列号

一般这个序列号写在继承 Serializable接口的的实体类下面

private static final long serialVersionUID = 1L; // java虚拟机识别一个类的时候先通过类名，如果类名一致，再通过序列化版本号。
1

2.3 idea自动生成版本序列号

建议将序列化版本号手动的写出来。不建议自动生成

具体自动生成的步骤如下

将其打勾即可
之后只要继承了Serializable这个接口，就可以通过快捷键自动生成

3. 对象-代码实战

先创建一个实体类

public class Student implements Serializable {

    private int no;
    private String name;

    public Student() {
    }

    public Student(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

3.1 序列化

通过序列其对象

public class ObjectOutputStreamTest01 {
    public static void main(String[] args) throws Exception{
        // 创建java对象
        Student s = new Student(1111, "zhangsan");
        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));

        // 序列化对象
        oos.writeObject(s);

        // 刷新
        oos.flush();
        // 关闭
        oos.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

查看其文件目录的时候
会生成一个students的文件
文件内部大致如下

这种情况类似买东西将其放置于购物车，断网断电的时候，数据被保存到此处，也就是序列化。反序列化就是将其恢复出来，从而在页面中可以看到信息还保存着

3.2 反序列化

具体代码为

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/*
反序列化
 */
public class ObjectInputStreamTest01 {
    public static void main(String[] args) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("students"));
        // 开始反序列化，读
        Object obj = ois.readObject();
        // 反序列化回来是一个学生对象，所以会调用学生对象的toString方法。
        System.out.println(obj);
        ois.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

通过反序列化的输出，在终端中输出页面显示为

4. 集合-代码实战

一般不可以直接传输多个对象进行序列化或者反序列化
应该将其多个对象放到集合中去

transient关键字表示游离的，不参与序列化。
将其添加到属性中，不参与其序列化，最后生成的反序列化的值是null

java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中

先创建一个实体类对象

import java.io.Serializable;

public class User implements Serializable {
    private int no;
    // transient关键字表示游离的，不参与序列化。
    private transient String name; // name不参与序列化操作！

    public User() {
    }

    public User(int no, String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

4.1 序列化

代码具体实现为

public class ObjectOutputStreamTest02 {
    public static void main(String[] args) throws Exception{
        List<User> userList = new ArrayList<>();
        userList.add(new User(1,"zhangsan"));
        userList.add(new User(2, "lisi"));
        userList.add(new User(3, "wangwu"));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("users"));

        // 序列化一个集合，这个集合对象中放了很多其他对象。
        oos.writeObject(userList);

        oos.flush();
        oos.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.2 反序列化

/*
反序列化集合
 */
public class ObjectInputStreamTest02 {
    public static void main(String[] args) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("users"));
        //Object obj = ois.readObject();
        //System.out.println(obj instanceof List);
        List<User> userList = (List<User>)ois.readObject();
        for(User user : userList){
            System.out.println(user);
        }
        ois.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15