Java的序列化和反序列化

Posted 2022-12-09 想作会飞的鱼

一、什么是序列化

简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。
Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。
使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的”状态”，即它的成员变量。由此可知， 对象序列化不会关注类中的静态变量 。

那么什么情况下需要序列化呢？

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

二、实现序列化和反序列化的步骤

1、JDK类库中序列化API

• java.io.ObjectOutputStream：表示对象输出流，它的writeObject(Object obj)方法可以对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
• java.io.ObjectInputStream：表示对象输入流，它的readObject()方法源输入流中读取字节序列，再把它们反序列化成为一个对象，并将其返回。

2、实现序列化的要求

只有实现了Serializable或Externalizable接口的类的对象才能被序列化，否则抛出异常。

3、实现Java对象序列化与反序列化的具体方法

假定一个Student类，它的对象需要序列化，可以有如下三种方法：
方法一：若Student类仅仅实现了Serializable接口，则可以按照以下方式进行序列化和反序列化。

ObjectOutputStream采用默认的序列化方式，对Student对象的非transient的实例变量进行序列化。
ObjcetInputStream采用默认的反序列化方式，对对Student对象的非transient的实例变量进行反序列化。
方法二：若Student类仅仅实现了Serializable接口，并且还定义了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，则采用以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeObject(ObjectOutputStream out)的方法进行序列化。
ObjectInputStream会调用Student对象的readObject(ObjectInputStream in)的方法进行反序列化。

方法三：若Student类实现了Externalnalizable接口，且Student类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，则按照以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeExternal(ObjectOutput out))的方法进行序列化。
ObjectInputStream会调用Student对象的readExternal(ObjectInput in)的方法进行反序列化。

4、JDK类库中序列化的步骤

步骤一：创建一个对象输出流，它可以包装一个其它类型的目标输出流，如文件输出流：

ObjectOutputStream out = new ObjectOutputStream(new fileOutputStream(“D:\\\\objectfile.obj”));

步骤二：通过对象输出流的writeObject()方法写对象：

out.writeObject(“Hello”);
out.writeObject(new Date());

5、JDK类库中反序列化的步骤

步骤一：创建一个对象输入流，它可以包装一个其它类型输入流，如文件输入流：

ObjectInputStream in = new ObjectInputStream(new fileInputStream(“D:\\\\objectfile.obj”));

步骤二：通过对象输出流的readObject()方法读取对象：

String obj1 = (String)in.readObject();
Date obj2 = (Date)in.readObject();

说明：为了正确读取数据，完成反序列化，必须保证向对象输出流写对象的顺序与从对象输入流中读对象的顺序一致。

三、示例演示

首先定义一个Student类，该类必须实现Serializable接口，如下：

package com.kang;

import java.io.Serializable;

public class Student implements Serializable 

    private static final long serialVersionUID = 1L;
    private String name;
    private char sex;
    private int year;
    private double gpa;

    public Student() 

    

    public Student(String name, char sex, int year, double gpa) 
        this.name = name;
        this.sex = sex;
        this.year = year;
        this.gpa = gpa;
    

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

    public void setSex(char sex) 
        this.sex = sex;
    

    public void setYear(int year) 
        this.year = year;
    

    public void setGpa(double gpa) 
        this.gpa = gpa;
    

    public String getName() 
        return this.name;
    

    public char getSex() 
        return this.sex;
    

    public int getYear() 
        return this.year;
    

    public double getGpa() 
        return this.gpa;
    

    @Override
    public String toString() 
        return "Student [name=" + name + ", sex=" + sex + ", year=" + year + ", gpa=" + gpa + "]";
    

然后演示如何对Student类进行序列化和反序列化

package com.kang;

import java.io.*;

public class UseStudent 
    public static void main(String[] args) 
        Student st = new Student("Tom", 'M', 20, 3.6);
        System.out.println("序列化前的原对象"+st);
        File file = new File("E:\\\\student.txt");
        try 
            file.createNewFile();
         catch (IOException e) 
            e.printStackTrace();
        
        try 
            // Student对象序列化过程
            FileOutputStream fos = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(st);
            oos.flush();
            oos.close();
            fos.close();

            // Student对象反序列化过程
            FileInputStream fis = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(fis);
            Student st1 = (Student) ois.readObject();
            System.out.println("序列化得到的对象"+st1);
            ois.close();
            fis.close();
         catch (ClassNotFoundException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
        
    

结果显示

四、关于serialVersionUID

简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

serialVersionUID有两种显示的生成方式：
一个是默认的1L，比如：private static final long serialVersionUID = 1L;
一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如： private static final long serialVersionUID = xxxxL;

当你一个类实现了Serializable接口，如果没有显示的定义serialVersionUID，Eclipse会提供这个提示功能告诉你去定义 。
当实现java.io.Serializable接口的实体（类）没有显式地定义一个名为serialVersionUID，类型为long的变量时，Java序列化机制会根据编译的class(它通过类名，方法名等诸多因素经过计算而得，理论上是一一映射的关系，也就是唯一的)自动生成一个serialVersionUID作序列化版本比较用，这种情况下，如果class文件(类名,方法明等)没有发生变化(增加空格,换行,增加注释,等等),就算再编译多次,serialVersionUID也不会变化的。

如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，未作更改的类，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。
如果你没有考虑到兼容性问题时，就把它关掉，不过有这个功能是好的，只要任何类别实现了Serializable这个接口的话，如果没有加入 serialVersionUID，Eclipse都会给你warning提示，这个serialVersionUID为了让该类别 Serializable向后兼容。

在具体使用时可能出现如下情况：

问题一

假设有A端和B端,A端为原始定义端，B端为反序列化后的一端，如果两处的serialVersionUID不一致或者两者都没定义,会产生什么错误呢?
答：报错:

java.io.InvalidClassException

如果A端和B端都没显示的写serialVersionUID,实体类没有改动，如果class文件(类名,方法明等)没有发生变化(增加空格,换行,增加注释,等等).序列化,反序列化正常。

问题二

假设有A端和B端,A端为原始定义端，B端为反序列化后的一端。假设两处serialVersionUID一致,如果A端增加一个字段,B端不变,会是什么情况呢?
答：序列化,反序列化正常,但是A端增加的字段丢失（被B端忽略)，也就是通过B端反序列化得到的字段不包括新增的字段。

问题三、

假设有A端和B端,A端为原始定义端，B端为反序列化后的一端。假设两处serialVersionUID一致,如果B端减少一个字段,A端不变,会是什么情况呢?
答：与问题二类似,序列化,反序列化正常,B端字段少于A端,A端多的字段值丢失(被B端忽略)。

问题四

假设有A端和B端,A端为原始定义端，B端为反序列化后的一端。假设两处serialVersionUID一致,如果B段增加一个字段,A端不变,会是什么情况呢?
答：序列化,反序列化正常,但是B端新增加的字段被赋予相应类型的默认值。

问题五、

假设有A端和B端,A端为原始定义端，B端为反序列化后的一端。假设两处serialVersionUID一致,如果A端减少一个字段,B端不变,会是什么情况呢?
答：与问题四类似,序列化,反序列化正常,但是B端字段多于A端,B端多出的字段被赋予对应类型的默认值。

五、关于序列化的注意事项

1、在Java中，只要一个类实现了 java.io.Serializable 接口，那么它就可以被序列化。
2、通过 ObjectOutputStream 和 ObjectInputStream 对对象进行序列化及反序列化
3、虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID ）
4、序列化并不保存静态变量。因为序列化是针对对象而言的，而且静态变量的变化情况与对象是否存在没有关系。
5、要想将父类对象也序列化，就需要让父类也实现 Serializable 接口。反过来说，当一个父类实现序列化，子类将自动实现序列化，不需要显式实现Serializable接口。
6、Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为默认值，如 int 型的是 0，对象型的是 null。
7、服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串等，希望对该密码字段在序列化时，进行加密，而客户端如果拥有解密的密钥，只有在客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的数据安全。
8、当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化。
9、并非所有的对象都可以序列化，至于为什么不可以，有很多原因了,比如： 安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，对他们进行重新的资源分配，而且，也是没有必要这样实现。或者进行rmi传输等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法保证正确运作。