Serializable:明明就一个空接口!为什么还要实现它?

开发 后端
对于 Java 的序列化,我一直停留在最浅显的认知上——把那个要序列化的类实现 Serializbale 接口就可以了。我不愿意做更深入的研究,因为会用就行了嘛。

[[318236]]

对于 Java 的序列化,我一直停留在最浅显的认知上——把那个要序列化的类实现 Serializbale 接口就可以了。我不愿意做更深入的研究,因为会用就行了嘛。

但随着时间的推移,见到 Serializbale 的次数越来越多,我便对它产生了浓厚的兴趣。是时候花点时间研究研究了。

01、先来点理论

Java 序列化是 JDK 1.1 时引入的一组开创性的特性,用于将 Java 对象转换为字节数组,便于存储或传输。此后,仍然可以将字节数组转换回 Java 对象原有的状态。

序列化的思想是“冻结”对象状态,然后写到磁盘或者在网络中传输;反序列化的思想是“解冻”对象状态,重新获得可用的 Java 对象。

再来看看序列化 Serializbale 接口的定义: 

  1. public interface Serializable {  

明明就一个空的接口嘛,竟然能够保证实现了它的“类的对象”被序列化和反序列化?

02、再来点实战

在回答上述问题之前,我们先来创建一个类(只有两个字段,和对应的 getter/setter),用于序列化和反序列化。 

  1. class Wanger {  
  2.     private String name;  
  3.     private int age;  
  4.     public String getName() {  
  5.         return name;  
  6.     }  
  7.     public void setName(String name) {  
  8.         this.name = name;  
  9.     }  
  10.     public int getAge() {  
  11.         return age;  
  12.     }  
  13.     public void setAge(int age) {  
  14.         this.age = age;  
  15.     }  

再来创建一个测试类,通过 ObjectOutputStream 将“18 岁的王二”写入到文件当中,实际上就是一种序列化的过程;再通过 ObjectInputStream 将“18 岁的王二”从文件中读出来,实际上就是一种反序列化的过程。 

  1. public class Test {  
  2.     public static void main(String[] args) {  
  3.       // 初始化  
  4.         Wanger wanger = new Wanger();  
  5.         wanger.setName("王二");  
  6.         wanger.setAge(18);  
  7.         System.out.println(wanger);  
  8.         // 把对象写到文件中  
  9.         try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));){  
  10.             oos.writeObject(wanger);  
  11.         } catch (IOException e) {  
  12.             e.printStackTrace();  
  13.         }  
  14.         // 从文件中读出对象  
  15.         try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));){  
  16.             Wanger wanger1 = (Wanger) ois.readObject();  
  17.             System.out.println(wanger1);  
  18.         } catch (IOException | ClassNotFoundException e) {  
  19.             e.printStackTrace();  
  20.         }  
  21.     }  

不过,由于 Wanger 没有实现 Serializbale 接口,所以在运行测试类的时候会抛出异常,堆栈信息如下: 

  1. java.io.NotSerializableException: com.cmower.java_demo.xuliehua.Wanger  
  2.     at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)  
  3.     at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)  
  4.     at com.cmower.java_demo.xuliehua.Test.main(Test.java:21) 

顺着堆栈信息,我们来看一下 ObjectOutputStream 的 writeObject0() 方法。其部分源码如下: 

  1. if (obj instanceof String) {  
  2.     writeString((String) obj, unshared);  
  3. } else if (cl.isArray()) {  
  4.     writeArray(obj, desc, unshared);  
  5. } else if (obj instanceof Enum) {  
  6.     writeEnum((Enum<?>) obj, desc, unshared);  
  7. } else if (obj instanceof Serializable) {  
  8.     writeOrdinaryObject(obj, desc, unshared);  
  9. } else {  
  10.     if (extendedDebugInfo) {  
  11.         throw new NotSerializableException(  
  12.             cl.getName() + "\n" + debugInfoStack.toString());  
  13.     } else {  
  14.         throw new NotSerializableException(cl.getName());  
  15.     }  

也就是说,ObjectOutputStream 在序列化的时候,会判断被序列化的对象是哪一种类型,字符串?数组?枚举?还是 Serializable,如果全都不是的话,抛出 NotSerializableException。

假如 Wanger 实现了 Serializable 接口,就可以序列化和反序列化了。 

  1. class Wanger implements Serializable{ 
  2.      private static final long serialVersionUID = -2095916884810199532L;  
  3.     private String name;  
  4.     private int age; 
  5.  

具体怎么序列化呢?

以 ObjectOutputStream 为例吧,它在序列化的时候会依次调用 writeObject()→writeObject0()→writeOrdinaryObject()→writeSerialData()→invokeWriteObject()→defaultWriteFields()。 

  1. private void defaultWriteFields(Object obj, ObjectStreamClass desc)  
  2.         throws IOException  
  3.     {  
  4.         Class<?> cl = desc.forClass();  
  5.         desc.checkDefaultSerialize();  
  6.         int primDataSize = desc.getPrimDataSize();  
  7.         desc.getPrimFieldValues(obj, primVals);  
  8.         bout.write(primVals, 0, primDataSize, false);  
  9.         ObjectStreamField[] fields = desc.getFields(false);  
  10.         Object[] objVals = new Object[desc.getNumObjFields()];  
  11.         int numPrimFields = fields.length - objVals.length;  
  12.         desc.getObjFieldValues(obj, objVals);  
  13.         for (int i = 0; i < objVals.length; i++) {  
  14.             try {  
  15.                 writeObject0(objVals[i],  
  16.                              fields[numPrimFields + i].isUnshared());  
  17.             }  
  18.         }  
  19.     } 

那怎么反序列化呢?

以 ObjectInputStream 为例,它在反序列化的时候会依次调用 readObject()→readObject0()→readOrdinaryObject()→readSerialData()→defaultReadFields()。 

  1. private void defaultWriteFields(Object obj, ObjectStreamClass desc)  
  2.         throws IOException  
  3.     {  
  4.         Class<?> cl = desc.forClass();  
  5.         desc.checkDefaultSerialize();  
  6.         int primDataSize = desc.getPrimDataSize();  
  7.         desc.getPrimFieldValues(obj, primVals);  
  8.         bout.write(primVals, 0, primDataSize, false);  
  9.         ObjectStreamField[] fields = desc.getFields(false);  
  10.         Object[] objVals = new Object[desc.getNumObjFields()];  
  11.         int numPrimFields = fields.length - objVals.length;  
  12.         desc.getObjFieldValues(obj, objVals);  
  13.         for (int i = 0; i < objVals.length; i++) {  
  14.             try {  
  15.                 writeObject0(objVals[i],  
  16.                              fields[numPrimFields + i].isUnshared());  
  17.             }  
  18.         }  
  19.     } 

我想看到这,你应该会恍然大悟的“哦”一声了。Serializable 接口之所以定义为空,是因为它只起到了一个标识的作用,告诉程序实现了它的对象是可以被序列化的,但真正序列化和反序列化的操作并不需要它来完成。

03、再来点注意事项

开门见山的说吧,static 和 transient 修饰的字段是不会被序列化的。

为什么呢?我们先来证明,再来解释原因。

首先,在 Wanger 类中增加两个字段。 

  1. class Wanger implements Serializable {  
  2.     private static final long serialVersionUID = -2095916884810199532L;  
  3.     private String name;  
  4.     private int age;  
  5.     public static String pre = "沉默" 
  6.     transient String meizi = "王三" 
  7.     @Override  
  8.     public String toString() {  
  9.         return "Wanger{" + "name=" + name + ",age=" + age + ",pre=" + pre + ",meizi=" + meizi + "}";  
  10.     }  

其次,在测试类中打印序列化前和反序列化后的对象,并在序列化后和反序列化前改变 static 字段的值。具体代码如下: 

  1. class Wanger implements Serializable {  
  2.     private static final long serialVersionUID = -2095916884810199532L;  
  3.     private String name;  
  4.     private int age;  
  5.     public static String pre = "沉默" 
  6.     transient String meizi = "王三" 
  7.     @Override  
  8.     public String toString() {  
  9.         return "Wanger{" + "name=" + name + ",age=" + age + ",pre=" + pre + ",meizi=" + meizi + "}";  
  10.     }  

从结果的对比当中,我们可以发现:

1)序列化前,pre 的值为“沉默”,序列化后,pre 的值修改为“不沉默”,反序列化后,pre 的值为“不沉默”,而不是序列化前的状态“沉默”。

为什么呢?因为序列化保存的是对象的状态,而 static 修饰的字段属于类的状态,因此可以证明序列化并不保存 static 修饰的字段。

2)序列化前,meizi 的值为“王三”,反序列化后,meizi 的值为 null,而不是序列化前的状态“王三”。

为什么呢?transient 的中文字义为“临时的”(论英语的重要性),它可以阻止字段被序列化到文件中,在被反序列化后,transient 字段的值被设为初始值,比如 int 型的初始值为 0,对象型的初始值为 null。

如果想要深究源码的话,你可以在 ObjectStreamClass 中发现下面这样的代码: 

  1. private static ObjectStreamField[] getDefaultSerialFields(Class<?> cl) {  
  2.     Field[] clclFields = cl.getDeclaredFields();  
  3.     ArrayList<ObjectStreamField> list = new ArrayList<>();  
  4.     int mask = Modifier.STATIC | Modifier.TRANSIENT;  
  5.     int size = list.size();  
  6.     return (size == 0) ? NO_FIELDS :  
  7.         list.toArray(new ObjectStreamField[size]);  

看到 Modifier.STATIC | Modifier.TRANSIENT,是不是感觉更好了呢?

04、再来点干货

除了 Serializable 之外,Java 还提供了一个序列化接口 Externalizable(念起来有点拗口)。

两个接口有什么不一样的吗?试一试就知道了。

首先,把 Wanger 类实现的接口  Serializable 替换为 Externalizable。 

  1. class Wanger implements Externalizable {  
  2.     private String name;  
  3.     private int age;  
  4.     public Wanger() {  
  5.     }  
  6.     public String getName() {  
  7.         return name;  
  8.     }  
  9.     @Override  
  10.     public String toString() {  
  11.         return "Wanger{" + "name=" + name + ",age=" + age + "}";  
  12.     }  
  13.     @Override  
  14.     public void writeExternal(ObjectOutput out) throws IOException {  
  15.     }  
  16.     @Override  
  17.     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {  
  18.     }  

实现 Externalizable 接口的 Wanger 类和实现 Serializable 接口的 Wanger 类有一些不同:

1)新增了一个无参的构造方法。

使用 Externalizable 进行反序列化的时候,会调用被序列化类的无参构造方法去创建一个新的对象,然后再将被保存对象的字段值复制过去。否则的话,会抛出以下异常: 

  1. java.io.InvalidClassException: com.cmower.java_demo.xuliehua1.Wanger; no valid constructor  
  2.     at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)  
  3.     at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:790)  
  4.     at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1782)  
  5.     at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)  
  6.     at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)  
  7.     at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27) 

2)新增了两个方法 writeExternal() 和 readExternal(),实现 Externalizable 接口所必须的。

然后,我们再在测试类中打印序列化前和反序列化后的对象。 

  1. // 初始化  
  2. Wanger wanger = new Wanger();  
  3. wanger.setName("王二");  
  4. wanger.setAge(18);  
  5. System.out.println(wanger);  
  6. // 把对象写到文件中  
  7. try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));) {  
  8.     oos.writeObject(wanger);  
  9. } catch (IOException e) {  
  10.     e.printStackTrace();  
  11.  
  12. // 从文件中读出对象  
  13. try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));) {  
  14.     Wanger wanger1 = (Wanger) ois.readObject();  
  15.     System.out.println(wanger1);  
  16. } catch (IOException | ClassNotFoundException e) {  
  17.     e.printStackTrace();  
  18.  
  19. // Wanger{name=王二,age=18 
  20. // Wanger{name=null,age=0

从输出的结果看,反序列化后得到的对象字段都变成了默认值,也就是说,序列化之前的对象状态没有被“冻结”下来。

为什么呢?因为我们没有为 Wanger 类重写具体的 writeExternal() 和 readExternal() 方法。那该怎么重写呢? 

  1. @Override  
  2. public void writeExternal(ObjectOutput out) throws IOException {  
  3.     out.writeObject(name);  
  4.     out.writeInt(age);  
  5.  
  6. @Override  
  7. public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {  
  8.     name = (String) in.readObject();  
  9.     age = in.readInt();  

1)调用 ObjectOutput 的 writeObject() 方法将字符串类型的 name 写入到输出流中;

2)调用 ObjectOutput 的 writeInt() 方法将整型的 age 写入到输出流中;

3)调用 ObjectInput 的 readObject() 方法将字符串类型的 name 读入到输入流中;

4)调用 ObjectInput 的 readInt() 方法将字符串类型的 age 读入到输入流中;

再运行一次测试了类,你会发现对象可以正常地序列化和反序列化了。

序列化前:Wanger{name=王二,age=18}

序列化后:Wanger{name=王二,age=18}

05、再来点甜点

让我先问问你吧,你知道 private static final long serialVersionUID = -2095916884810199532L; 这段代码的作用吗?

嗯……

serialVersionUID 被称为序列化 ID,它是决定 Java 对象能否反序列化成功的重要因子。在反序列化时,Java 虚拟机会把字节流中的 serialVersionUID 与被序列化类中的 serialVersionUID 进行比较,如果相同则可以进行反序列化,否则就会抛出序列化版本不一致的异常。

当一个类实现了 Serializable 接口后,IDE 就会提醒该类最好产生一个序列化 ID,就像下面这样:

1)添加一个默认版本的序列化 ID: 

  1. private static final long serialVersionUID = 1L。 

2)添加一个随机生成的不重复的序列化 ID。 

  1. private static final long serialVersionUID = -2095916884810199532L; 

3)添加 @SuppressWarnings 注解。 

  1. @SuppressWarnings("serial") 

怎么选择呢?

首先,我们采用第二种办法,在被序列化类中添加一个随机生成的序列化 ID。 

  1. class Wanger implements Serializable {  
  2.     private static final long serialVersionUID = -2095916884810199532L;  
  3.     private String name;  
  4.     private int age;  
  5.     // 其他代码忽略  

然后,序列化一个 Wanger 对象到文件中。 

  1. // 初始化  
  2. Wanger wanger = new Wanger();  
  3. wanger.setName("王二");  
  4. wanger.setAge(18);  
  5. System.out.println(wanger);  
  6. // 把对象写到文件中  
  7. try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));) {  
  8.     oos.writeObject(wanger);  
  9. } catch (IOException e) {  
  10.     e.printStackTrace();  

这时候,我们悄悄地把 Wanger 类的序列化 ID 偷梁换柱一下,嘿嘿。 

  1. // private static final long serialVersionUID = -2095916884810199532L;  
  2. private static final long serialVersionUID = -2095916884810199533L; 

好了,准备反序列化吧。 

  1. try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));) {  
  2.     Wanger wanger = (Wanger) ois.readObject();  
  3.     System.out.println(wanger);  
  4. } catch (IOException | ClassNotFoundException e) {  
  5.     e.printStackTrace();  

哎呀,出错了。 

  1. java.io.InvalidClassException:  local class incompatible: stream classdesc   
  2. serialVersionUID = -2095916884810199532,  
  3. local class serialVersionUID = -2095916884810199533  
  4.     at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)  
  5.     at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27) 

异常堆栈信息里面告诉我们,从持久化文件里面读取到的序列化 ID 和本地的序列化 ID 不一致,无法反序列化。

那假如我们采用第三种方法,为 Wanger 类添加个 @SuppressWarnings("serial") 注解呢? 

  1. @SuppressWarnings("serial")  
  2. class Wanger3 implements Serializable {  
  3. // 省略其他代码  

好了,再来一次反序列化吧。可惜依然报错。 

  1. java.io.InvalidClassException:  local class incompatible: stream classdesc   
  2. serialVersionUID = -2095916884810199532,   
  3. local class serialVersionUID = -3818877437117647968  
  4.     at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)  
  5.     at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27) 

异常堆栈信息里面告诉我们,本地的序列化 ID 为 -3818877437117647968,和持久化文件里面读取到的序列化 ID 仍然不一致,无法反序列化。这说明什么呢?使用 @SuppressWarnings("serial") 注解时,该注解会为被序列化类自动生成一个随机的序列化 ID。

由此可以证明,Java 虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,还有一个非常重要的因素就是序列化 ID 是否一致。

也就是说,如果没有特殊需求,采用默认的序列化 ID(1L)就可以,这样可以确保代码一致时反序列化成功。 

  1. class Wanger implements Serializable {  
  2.     private static final long serialVersionUID = 1L 
  3. // 省略其他代码  

06、再来点总结

写这篇文章之前,我真没想到:“空空其身”的Serializable 竟然有这么多可以研究的内容!

写完这篇文章之后,我不由得想起理科状元曹林菁说说过的一句话:“在学习中再小的问题也不放过,每个知识点都要总结”——说得真真真真的对啊! 

责任编辑:庞桂玉 来源: Java后端技术
相关推荐

2021-07-19 09:00:24

微软Windows 11Windows

2011-06-01 15:18:43

Serializabl

2019-05-14 09:05:16

SerializablJava对象

2014-08-21 10:05:14

ZMapTCPIP

2021-11-17 08:26:22

空类EBO技术

2022-04-29 08:00:06

Linux目录网络

2023-03-26 00:04:14

2021-12-24 10:04:57

漏洞阿里云Log4Shell

2020-10-29 09:19:11

索引查询存储

2022-06-10 13:03:44

接口重试while

2021-03-02 22:10:10

Java互联网语言

2021-04-16 23:28:11

Java语言IT

2022-06-07 08:39:35

RPCHTTP

2016-10-27 11:11:12

头条

2022-08-04 08:22:49

MySQL索引

2020-11-25 09:36:17

HTTPRPC远程

2012-09-03 09:52:39

虚拟化

2022-06-21 14:44:38

接口数据脱敏

2023-11-07 08:00:00

Kubernetes

2018-03-22 14:47:13

容器开发人员笔记本
点赞
收藏

51CTO技术栈公众号