Java序列化以及反序列化详解_java 手写反序列化

本文转载于
https://blog.csdn.net/weixin_41427129/article/details/105756415
作者：wadreamer

一.序列化概述

序列化：将对象写入IO流中
反序列化：从IO流中恢复对象

意义：序列化机制允许将实现序列化的Java对象转换为字节序列，并将字节序列保存在磁盘中，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使地对象可以脱离程序的运行而独立存在

使用场景：所有在网络上传输的对象都必须是可序列化的。如：RMI (远程方法调用)，传入的参数或返回的对象都是可序列化的，否则会出错。所有必须保存到磁盘的java对象都必须是可序列化的。程序创建的JavaBean最好都实现Serializable接口

二.实现序列化的方式

实现序列化有两种方式：实现Serializable接口或Externalizable接口，通常情况下，实现Serializable接口即可。两种接口的对比如下：

实现Serializable接口：

1. 系统自动存储必要的信息
2. Java内建支持，易于实现，只需要实现接口接口，不需要任何代码支持
3. 性能略差

实现Externalizable接口：

1. 自己决定要序列化哪些属性
2. 必须实现该接口内的两个方法

• void writeExternal(ObjectOutput out) throws IOException;
• void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;

3. 性能略好

三.Serializable接口

3.1 序列化

1)创建一个ObjectOutputStream输出流
2)调用OjectOutputSteam对象的writeObject ()输出可序列化对象

实体类

public class Person implements Serializable {
    private static final String author = "kun";
    private String name;
    private int height;
    private String address;
    
    public Person(){
        System.out.println("我是无参构造");
    }


    public Person(String name,int height,String address) {
        this.name = name;
        this.height = height;
        this.address = address;
    }

    public String getAddress() {
        return address;
    }

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

    public String getName() {
        return name;
    }

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

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", address='" + address + '\'' +
                '}';
    }
}

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
40
41
42
43
44
45
46
47
48
49
50
51

  // 序列化
try {
     ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
     Person p = new Person("baby",50,"上海");
     oos.writeObject(p);
 } catch (IOException e) {
     e.printStackTrace();
 }
1
2
3
4
5
6
7
8

3.2 反序列化

1)创建一个ObjectInputStream输入流
2)调用ObjectInputStream对象的readObject ()得到序列化对象

 // 反序列化
try {
      ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
      Person p = (Person) ois.readObject();
      System.out.println(p.toString());
  } catch (Exception e) {
      e.printStackTrace();
  }
1
2
3
4
5
6
7
8

输出内容如下

通过输出结果，我们知道反序列化没有调用类的构造方法，而是由JVM自己生成对象
若一个类的成员不是基本数据类型，也不是String类型的时候，则该成员必须是可序列化的，否则会导致该类无法完成序列化

比如实体类添加类ArrayTest，一个没有实现Serializable接口的类，那么序列化该类就会出现异常

3.3 常见问题

①同一对象，会被序列化多次吗？ 不会

public class TeacherTset {
    public static void main(String[] args) {
        Teacher teacher = new Teacher("Jack","38");
        // 序列化
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"));
            oos.writeObject(teacher);
            oos.writeObject(teacher);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"));
            // 反序列化的顺序和序列化的要一致
            Teacher t1 = (Teacher) ois.readObject();
            Teacher t2 = (Teacher) ois.readObject();
            System.out.println(t1.equals(t2));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

结果为true

②当一个可变的对象中的内容发生改变时，此时进行序列化，会重新序列化吗？

不会重新将此对象转换为字节序列，而是保存序列化编号

public class WirteOnChange {
    public static void main(String[] args) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("WriteOnchange.txt"));
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("WriteOnchange.txt"));

        Person person = new Person("亚索",190,"济南");
        System.out.println("修改前：" + person.toString());
        System.out.println(person.hashCode());
        oos.writeObject(person);

        person.setName("杰斯");
        System.out.println("修改后：" + person.toString());
        System.out.println(person.hashCode());
        oos.writeObject(person);

        Person p1 = (Person) ois.readObject();
        Person p2 = (Person) ois.readObject();
        // 序列化后更改属性序列化不变
        System.out.println(p1 == p2);
        System.out.println(p1.getName().equals(p2.getName()));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.4 transient

使用transient修饰的属性，java序列化时会忽略该属性。而当反序列化时，被transient修饰的属性则赋予默认值。对于引用类型则为null，boolean类型为false，基本类型为0

实体类

public class Person implements Serializable {
    private static final String author = "kun";
    private String name;
    private int height;
    private transient String address;
    // 省略了构造、set、get、toString()
1
2
3
4
5
6

public class WriteObject {
    public static void main(String[] args) {
        // 序列化
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
            Person p = new Person("baby",50,"上海");
            oos.writeObject(p);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
            Person p = (Person) ois.readObject();
            System.out.println(p.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

可以看到，我们虽然设置了上海，但反序列化后却是null，正是transient起了作用

四.自定义序列化

通过下面的方法可以实现自定义序列化，可以控制序列化的方式或对序列化数据进行编码加密等

• private void writeObject(java.io.ObjectOutputStream out) throws IOException
• private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException
• private void readObjectNoData() throws ObjectStreamException

通过重写writeObject()与readObject()方法，可选择哪些属性要序列化。如果writeObject使用了某种规则进行序列化，则readObject要使用相反的规则进行反序列化，以便能正确反序列化对

注意，必须是private访问符，这不是重写，更不是重载，方法名要严格一致，只是类的一个方法

public class Person implements Serializable {
    
    private static final String author = "kun";
    private String name;
    private int height;
    private String address;
	// 省略了构造、set、get、toString()

    // 自定义序列化，必须是private，我们只序列化了两个属性
    private void writeObject(ObjectOutputStream oos) throws IOException {
        oos.writeObject(new StringBuilder(this.name).reverse());
        oos.writeInt(height);
        System.out.println("我是自定义序列化");
    }
    // 自定义反序列化
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        this.name = ((StringBuilder) ois.readObject()).reverse().toString();
        this.height = ois.readInt();
        System.out.println("我是自定义反序列化");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class Custom {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person person = new Person("kun", 178,"广州");
        //序列化
        ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
        //调用我们自定义的writeObject()方法
        out.writeObject(person);
        out.close();

        //反序列化
        ObjectInputStream in=new ObjectInputStream(new FileInputStream("./obj.txt"));
        //调用自定义的readObject()方法
        Person person1=(Person) in.readObject();


        String s = person1.toString();
        System.out.println(s);

        out.close();
        in.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

可以看到，我们没有序列化address，反序列化为null，类似于transient的作用

当序列化流不完整时，readObjectNoData() 方法可以正确地初始化反序列化的对象。例如，使用不同类接收反序列化对象，或者序列化流被篡改，系统都会调用readObjectNoData()来初始化反序列化对象

五.彻底的自定义序列化

以下两个方法会在序列化前或反序列化后自动调用，可以实现更加彻底的自定义序列化

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;

ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;
1
2
3

直接看示例

writeReplace()

public class Teacher implements Serializable{
    private String name;
    private String age;

	// 省略.....
    private Object writeReplace() throws ObjectStreamException {
        ArrayList<String> list = new ArrayList<>();
        list.add(this.name);
        list.add(this.age);
        System.out.println("writeReplace()");
        return list;
    }

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
        ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"));

        Teacher teacher = new Teacher("布隆", "10");
        oos.writeObject(teacher);

        ArrayList<String> list = (ArrayList) ios.readObject();
        System.out.println(list);
    }
}


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

我们序列化了一个Teacher类，却反序列化出一个List，因为实际我们是序列化的 writeReplace()

readResolve()

public class Teacher implements Serializable{
    private String name;
    private String age;

    // 省略....

    // 替代反序列化输出的对象，反序列化出来的对象会被立即丢弃，此方法在readObject()后调用
    private Object readResolve() throws ObjectStreamException {
        System.out.println("readResolve()");
        return new Person("德莱文", 165,"苏州");
    }


    public static void main(String[] args) throws IOException, IOException, ClassNotFoundException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Person.txt"));
        ObjectInputStream ios = new ObjectInputStream(new FileInputStream("Person.txt"));
        // 序列化一个Teacher类
        Teacher teacher = new Teacher("加里奥", "23");
        oos.writeObject(teacher);
        // 反序列化
        Person p1 = (Person) ios.readObject();
        System.out.println(p1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

我们序列化了一个Teacher类，反序列化出来一个Person类，因为readResolve()替代反序列化输出的对象，反序列化出来的对象会被立即丢弃，此方法在readObject()后调用

writeReplace()会“修改”序列化的类，而readResolve()会“修改”反序列化出来的类

六.Externalizable

Externalizable接口不同于Serializable接口，该接口需要强制重写两个方法

public interface Externalizable extends java.io.Serializable {
    void writeExternal(ObjectOutput out) throws IOException;
    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
1
2
3
4

public class PersonExternal implements Externalizable {
    private String name;
    private int age;

    // 必须提供无参构造函数
    public PersonExternal() {
        System.out.println("调用无参构造方法！！");
    }

    public PersonExternal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // 将读取的字符串反转后赋值给name实例变量
        this.name = ((StringBuilder) in.readObject()).reverse().toString();
        System.out.println("将name按相同的规则反序列化输出：" + name);
        this.age = in.readInt();
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // 将name反转后写入二进制流
        StringBuilder reverse = new StringBuilder(name).reverse();
        System.out.println("将name反转并序列化写入二进制流：" + reverse.toString());
        out.writeObject(reverse);
        out.writeInt(age);
    }

    @Override
    public String toString() {
        // TODO 自动生成的方法存根
        return "Person{'name' :" + name + ", 'age' :" + age + "}";
    }

    public static void main(String[] args) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("PersonExternal.txt"));
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("PersonExternal.txt"));

        System.out.println("序列化ing");
        oos.writeObject(new PersonExternal("cindy", 23));

        System.out.println("反序列化ing");
        PersonExternal pe = (PersonExternal) ois.readObject();

        System.out.println(pe.toString());
    }


}
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
40
41
42
43
44
45
46
47
48
49
50
51
52

可以看到的是，实现Externalizable接口必须提供public的无参构造器，因为在反序列化的时候需要通过反射创建对象

七.serialVersionUID

版本号，就是类的一个静态final常量，其作用就是控制反序列化的正确性

序列化版本号可自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，这样随着class的升级，就无法正确反序列化
不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化

建议手动指定版本号！

直接看代码有啥作用

现在Person类中没有指定版本号

private static final String author = "kun";
  private String name;
  private int height;
  private String address;
1
2
3
4

序列化一次

// 序列化
try {
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
    Person p = new Person("baby",50,"上海");
    oos.writeObject(p);
} catch (IOException e) {
    e.printStackTrace();
}
1
2
3
4
5
6
7
8

在反序列化之前，我们修改了类的属性

private static final String author = "kun";
  private String name;
  private int height;
  private String address;
  private String school;
1
2
3
4
5

// 反序列化
try {
     ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
     Person p = (Person) ois.readObject();
     System.out.println(p.toString());
 } catch (Exception e) {
     e.printStackTrace();
 }
1
2
3
4
5
6
7
8

报错了，版本不一致？为啥，因为当前本地的实体类和序列化文件中的属性不一致，更改了属性，导致版本也改变了

然后我们添加一个版本序列化号，添加新属性后也不修改版本号

private static final long serialVersionUID = 1L;
    private static final String author = "kun";
    private String name;
    private int height;
    private String address;
1
2
3
4
5

重复上述步骤，发现序列化成功了，只不过新添加的属性被赋值为null了

如果我们不手动指定版本号，永远不会反序列化成功，因添加完新属性后，系统自动生成的版本号就会改变，而我们手动指定已经给他写死了（当然我们也可以更改版本号），这也是为什么要手动指定版本号，自己体会下

• 只是修改了方法，反序列化不影响，则无需修改版本号
• 只是修改了静态变量，瞬态变量（transient修饰的变量），反序列化不受影响，无需修改版本号
• 修改了非瞬态变量，则可能导致反序列化失败。如果新类中实例变量的类型与序列化时类的类型不一致，则会反序列化失败，这时候需要更改serialVersionUID。如果只是新增了实例变量，则反序列化回来新增的是默认值

八.一些小细节

a) 对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化

b) 所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口

c) 如果想让某个变量不被序列化，使用transient修饰

d) 序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错

e) 反序列化时必须有序列化对象的class文件

f) 当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取

g) 单例类序列化，需要重写readResolve()方法；否则会破坏单例原则

i) 同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化

j) 建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级

k) 数组不能显式地声明serialVersionUID，因为它们始终都有默认的计算值，但是对于数组类，无需匹配serialVersionUID

l) 可以通过序列化和反序列化的方式实现对象的深复制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21