serializable接口_Java Serializable:明明就一个空的接口嘛
01、先来点理论
对于 Java 的序列化,我一直停留在最浅显的认知上——把那个要序列化的类实现 Serializbale 接口就可以了。我不愿意做更深入的研究,因为会用就行了嘛。
但随着时间的推移,见到 Serializbale 的次数越来越多,我便对它产生了浓厚的兴趣。是时候花点时间研究研究了。
Java 序列化是 JDK 1.1 时引入的一组开创性的特性,用于将 Java 对象转换为字节数组,便于存储或传输。此后,仍然可以将字节数组转换回 Java 对象原有的状态。
序列化的思想是“冻结”对象状态,然后写到磁盘或者在网络中传输;反序列化的思想是“解冻”对象状态,重新获得可用的 Java 对象。
再来看看序列化 Serializbale 接口的定义:
public interface Serializable {}
明明就一个空的接口嘛,竟然能够保证实现了它的“类的对象”被序列化和反序列化?
02、再来点实战
在回答上述问题之前,我们先来创建一个类(只有两个字段,和对应的 getter/setter),用于序列化和反序列化。
class Wanger { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }}
再来创建一个测试类,通过 ObjectOutputStream 将“18 岁的王二”写入到文件当中,实际上就是一种序列化的过程;再通过 ObjectInputStream 将“18 岁的王二”从文件中读出来,实际上就是一种反序列化的过程。
public class Test { public static void main(String[] args) { // 初始化 Wanger wanger = new Wanger(); wanger.setName("王二"); wanger.setAge(18); System.out.println(wanger); // 把对象写到文件中 try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));){ oos.writeObject(wanger); } catch (IOException e) { e.printStackTrace(); } // 从文件中读出对象 try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));){ Wanger wanger1 = (Wanger) ois.readObject(); System.out.println(wanger1); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } }}
不过,由于 Wanger 没有实现 Serializbale 接口,所以在运行测试类的时候会抛出异常,堆栈信息如下:
java.io.NotSerializableException: com.cmower.java_demo.xuliehua.Wangerat java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)at com.cmower.java_demo.xuliehua.Test.main(Test.java:21)
顺着堆栈信息,我们来看一下 ObjectOutputStream 的 writeObject0() 方法。其部分源码如下:
if (obj instanceof String) { writeString((String) obj, unshared);} else if (cl.isArray()) { writeArray(obj, desc, unshared);} else if (obj instanceof Enum) { writeEnum((Enum>) obj, desc, unshared);} else if (obj instanceof Serializable) { writeOrdinaryObject(obj, desc, unshared);} else { if (extendedDebugInfo) { throw new NotSerializableException( cl.getName() + "" + debugInfoStack.toString()); } else { throw new NotSerializableException(cl.getName()); }}
也就是说,ObjectOutputStream 在序列化的时候,会判断被序列化的对象是哪一种类型,字符串?数组?枚举?还是 Serializable,如果全都不是的话,抛出 NotSerializableException。
假如 Wanger 实现了 Serializable 接口,就可以序列化和反序列化了。
class Wanger implements Serializable{ private static final long serialVersionUID = -2095916884810199532L; private String name; private int age;}
具体怎么序列化呢?
以 ObjectOutputStream 为例吧,它在序列化的时候会依次调用 writeObject()→writeObject0()→writeOrdinaryObject()→writeSerialData()→invokeWriteObject()→defaultWriteFields()。
private void defaultWriteFields(Object obj, ObjectStreamClass desc) throws IOException { Class> cl = desc.forClass(); desc.checkDefaultSerialize(); int primDataSize = desc.getPrimDataSize(); desc.getPrimFieldValues(obj, primVals); bout.write(primVals, 0, primDataSize, false); ObjectStreamField[] fields = desc.getFields(false); Object[] objVals = new Object[desc.getNumObjFields()]; int numPrimFields = fields.length - objVals.length; desc.getObjFieldValues(obj, objVals); for (int i = 0; i < objVals.length; i++) { try { writeObject0(objVals[i], fields[numPrimFields + i].isUnshared()); } } }
那怎么反序列化呢?
以 ObjectInputStream 为例,它在反序列化的时候会依次调用 readObject()→readObject0()→readOrdinaryObject()→readSerialData()→defaultReadFields()。
private void defaultWriteFields(Object obj, ObjectStreamClass desc) throws IOException { Class> cl = desc.forClass(); desc.checkDefaultSerialize(); int primDataSize = desc.getPrimDataSize(); desc.getPrimFieldValues(obj, primVals); bout.write(primVals, 0, primDataSize, false); ObjectStreamField[] fields = desc.getFields(false); Object[] objVals = new Object[desc.getNumObjFields()]; int numPrimFields = fields.length - objVals.length; desc.getObjFieldValues(obj, objVals); for (int i = 0; i < objVals.length; i++) { try { writeObject0(objVals[i], fields[numPrimFields + i].isUnshared()); } } }
我想看到这,你应该会恍然大悟的“哦”一声了。Serializable 接口之所以定义为空,是因为它只起到了一个标识的作用,告诉程序实现了它的对象是可以被序列化的,但真正序列化和反序列化的操作并不需要它来完成。
03、再来点注意事项
开门见山的说吧,static 和 transient 修饰的字段是不会被序列化的。
为什么呢?我们先来证明,再来解释原因。
首先,在 Wanger 类中增加两个字段。
class Wanger implements Serializable { private static final long serialVersionUID = -2095916884810199532L; private String name; private int age; public static String pre = "沉默"; transient String meizi = "王三"; @Override public String toString() { return "Wanger{" + "name=" + name + ",age=" + age + ",pre=" + pre + ",meizi=" + meizi + "}"; }}
其次,在测试类中打印序列化前和反序列化后的对象,并在序列化后和反序列化前改变 static 字段的值。具体代码如下:
// 初始化Wanger wanger = new Wanger();wanger.setName("王二");wanger.setAge(18);System.out.println(wanger);// 把对象写到文件中try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));){ oos.writeObject(wanger); } catch (IOException e) { e.printStackTrace(); } // 改变 static 字段的值Wanger.pre ="不沉默";// 从文件中读出对象try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));){ Wanger wanger1 = (Wanger) ois.readObject(); System.out.println(wanger1);} catch (IOException | ClassNotFoundException e) { e.printStackTrace();}// Wanger{name=王二,age=18,pre=沉默,meizi=王三}// Wanger{name=王二,age=18,pre=不沉默,meizi=null}
从结果的对比当中,我们可以发现:
1)序列化前,pre 的值为“沉默”,序列化后,pre 的值修改为“不沉默”,反序列化后,pre 的值为“不沉默”,而不是序列化前的状态“沉默”。
为什么呢?因为序列化保存的是对象的状态,而 static 修饰的字段属于类的状态,因此可以证明序列化并不保存 static 修饰的字段。
2)序列化前,meizi 的值为“王三”,反序列化后,meizi 的值为 null,而不是序列化前的状态“王三”。
为什么呢?transient 的中文字义为“临时的”(论英语的重要性),它可以阻止字段被序列化到文件中,在被反序列化后,transient 字段的值被设为初始值,比如 int 型的初始值为 0,对象型的初始值为 null。
如果想要深究源码的话,你可以在 ObjectStreamClass 中发现下面这样的代码:
private static ObjectStreamField[] getDefaultSerialFields(Class> cl) { Field[] clFields = cl.getDeclaredFields(); ArrayList list = new ArrayList<>(); int mask = Modifier.STATIC | Modifier.TRANSIENT; int size = list.size(); return (size == 0) ? NO_FIELDS : list.toArray(new ObjectStreamField[size]);}
看到 Modifier.STATIC | Modifier.TRANSIENT,是不是感觉更好了呢?
04、再来点干货
除了 Serializable 之外,Java 还提供了一个序列化接口 Externalizable(念起来有点拗口)。
两个接口有什么不一样的吗?试一试就知道了。
首先,把 Wanger 类实现的接口 Serializable 替换为 Externalizable。
class Wanger implements Externalizable {private String name;private int age;public Wanger() {}public String getName() {return name;}@Overridepublic String toString() {return "Wanger{" + "name=" + name + ",age=" + age + "}";}@Overridepublic void writeExternal(ObjectOutput out) throws IOException {}@Overridepublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {}}
实现 Externalizable 接口的 Wanger 类和实现 Serializable 接口的 Wanger 类有一些不同:
1)新增了一个无参的构造方法。
使用 Externalizable 进行反序列化的时候,会调用被序列化类的无参构造方法去创建一个新的对象,然后再将被保存对象的字段值复制过去。否则的话,会抛出以下异常:
java.io.InvalidClassException: com.cmower.java_demo.xuliehua1.Wanger; no valid constructorat java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:790)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1782)at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)
2)新增了两个方法 writeExternal() 和 readExternal(),实现 Externalizable 接口所必须的。
然后,我们再在测试类中打印序列化前和反序列化后的对象。
// 初始化Wanger wanger = new Wanger();wanger.setName("王二");wanger.setAge(18);System.out.println(wanger);// 把对象写到文件中try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));) {oos.writeObject(wanger);} catch (IOException e) {e.printStackTrace();}// 从文件中读出对象try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));) {Wanger wanger1 = (Wanger) ois.readObject();System.out.println(wanger1);} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}// Wanger{name=王二,age=18}// Wanger{name=null,age=0}
从输出的结果看,反序列化后得到的对象字段都变成了默认值,也就是说,序列化之前的对象状态没有被“冻结”下来。
为什么呢?因为我们没有为 Wanger 类重写具体的 writeExternal() 和 readExternal() 方法。那该怎么重写呢?
@Overridepublic void writeExternal(ObjectOutput out) throws IOException {out.writeObject(name);out.writeInt(age);}@Overridepublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {name = (String) in.readObject();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:
private static final long serialVersionUID = 1L。
2)添加一个随机生成的不重复的序列化 ID。
private static final long serialVersionUID = -2095916884810199532L;
3)添加 @SuppressWarnings 注解。
@SuppressWarnings("serial")
怎么选择呢?
首先,我们采用第二种办法,在被序列化类中添加一个随机生成的序列化 ID。
class Wanger implements Serializable {private static final long serialVersionUID = -2095916884810199532L;private String name;private int age;// 其他代码忽略}
然后,序列化一个 Wanger 对象到文件中。
// 初始化Wanger wanger = new Wanger();wanger.setName("王二");wanger.setAge(18);System.out.println(wanger);// 把对象写到文件中try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));) {oos.writeObject(wanger);} catch (IOException e) {e.printStackTrace();}
这时候,我们悄悄地把 Wanger 类的序列化 ID 偷梁换柱一下,嘿嘿。
// private static final long serialVersionUID = -2095916884810199532L;private static final long serialVersionUID = -2095916884810199533L;
好了,准备反序列化吧。
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));) {Wanger wanger = (Wanger) ois.readObject();System.out.println(wanger);} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}
哎呀,出错了。
java.io.InvalidClassException: local class incompatible: stream classdesc serialVersionUID = -2095916884810199532,local class serialVersionUID = -2095916884810199533at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)
异常堆栈信息里面告诉我们,从持久化文件里面读取到的序列化 ID 和本地的序列化 ID 不一致,无法反序列化。
那假如我们采用第三种方法,为 Wanger 类添加个 @SuppressWarnings("serial") 注解呢?
@SuppressWarnings("serial")class Wanger implements Serializable {// 省略其他代码}
好了,再来一次反序列化吧。可惜依然报错。
java.io.InvalidClassException: local class incompatible: stream classdesc serialVersionUID = -2095916884810199532, local class serialVersionUID = -3818877437117647968at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)
异常堆栈信息里面告诉我们,本地的序列化 ID 为 -3818877437117647968,和持久化文件里面读取到的序列化 ID 仍然不一致,无法反序列化。这说明什么呢?使用 @SuppressWarnings("serial") 注解时,该注解会为被序列化类自动生成一个随机的序列化 ID。
由此可以证明,Java 虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,还有一个非常重要的因素就是序列化 ID 是否一致。
也就是说,如果没有特殊需求,采用默认的序列化 ID(1L)就可以,这样可以确保代码一致时反序列化成功。
class Wanger implements Serializable {private static final long serialVersionUID = 1L;// 省略其他代码}
06、再来点总结
写这篇文章之前,我真没想到:“空空其身”的Serializable 竟然有这么多可以研究的内容!
serializable接口_Java Serializable:明明就一个空的接口嘛相关推荐
- Java Serializable:明明就一个空的接口嘛
对于 Java 的序列化,我一直停留在最浅显的认知上--把那个要序列化的类实现 Serializbale 接口就可以了.我不愿意做更深入的研究,因为会用就行了嘛. 但随着时间的推移,见到 Serial ...
- Serializable:明明就一个空接口!为什么还要实现它?
作者:沉默王二 微信公众号:Java极客技术(ID:Javageektech) 对于 Java 的序列化,我一直停留在最浅显的认知上--把那个要序列化的类实现 Serializbale 接口就可以了. ...
- java 实现类转接口_JAVA 基础 / 第二十九课:接口与继承 / JAVA中的对象转型
2018-03-19 一.明确引用类型与对象类型的概念 引用类型与对象类型的概念 在这个例子里,有一个对象 new ADHero(), 同时也有一个引用ad 对象是有类型的, 是ADHero 引用也是 ...
- java中常用的包 类和接口_java.util包常用的类和接口
标签:ash 可变 支持 set 组成 arraylist 层次结构 有序 结构 1. 常用接口 (1)Collection Collection 层次结构 中的根接口 ...
- java 如何只暴露接口_Java并发异步编程,原来十个接口的活现在只需要一个接口就搞定...
什么?对你没有听错,也没有看错 ..多线程并发执行任务,取结果归集~~ 不再忧愁-. 引言 先来看一些APP的获取数据,诸如此类,一个页面获取N多个,多达10个左右的一个用户行为数据,比如:点赞数,发 ...
- java中如何定义接口_java中如何定义一个接口
使用interface来定义一个接口.接口定义同类的定义类似,也是分为接口的声明和接口体,其中接口体由常量定义和方法定义两部分组成.定义接口的基本格式如下:[修饰符] interface 接口名 [e ...
- java泛型与接口_Java泛型用于方法,类和接口
什么是泛型? 型就是数据类型参数化.就是说原本定死的数据类型像方法中的形参一样,数据是不确定的,使用的时候由人传进去,泛型就是这样,数据类型不确定了.使用的时候再确定就可以了. 泛型的特点 是JDK1 ...
- java语言sql接口_java.sql包中的类和接口及其使用
java.sql包提供使用Java编程语言访问并处理存储在数据源中数据的API,可以动态地安装不同驱动程序来访问不同数据源. 下面,详解java.sql包中包含的常用的接口和类 1.DriverMan ...
- java服务端 json接口_java以json格式向后台服务器接口发送请求的实例
java以json格式向后台服务器接口发送请求的实例 发布于 2021-1-14| 复制链接 下面小妖就为大家分享一篇java以json格式向后台服务器接口发送请求的实例,具有很好的参考价值,希望对大 ...
最新文章
- CTFshow php特性 web90
- 手把手教你C语言静态库的开发
- Dubbo整合hystrix
- 函数式接口@FunctionalInterface使用示例
- pojo类不能有默认值怎么办_打印机不能打印是什么原因 打印机不能打印处理方法介绍【详解】...
- 神码与SUSE共促Unix向x86+Linux迁移
- 第一次JAVA课,第一次课堂考,课后感受
- git撤销单个文件的修改_程序员都要掌握的 Git 使用技巧【实践】
- 2021年4月-(计算机网络)小型校园网络模拟搭建,最全最准确版!!!!!
- android百度地图公交路线,android百度地图api实现查询经过某站点的所有公交路线...
- 新一代SSD接口来了 | M.2接口发福版?
- html按键精灵怎么设置,按键精灵如何设置循环?按键精灵设置循环的方法步骤...
- 法国优秀的五位数学家
- EasyNVR摄像头网页无插件直播H5、谷歌Chrome直播方案中如何降低播放延迟问题
- sweetjs 简介
- Linux启用显卡opengl,如何使你的Nvidia显卡支持OpenGL?
- 分享一款轻量简洁的全平台开源商城系统
- flashfxp支持sftp了
- 计算机网络vtp,简单理解 VTP 协议与实战单臂路由
- java静态函数_(基础)java中的静态变量与静态函数Static
热门文章
- Linux下打造仿Mac系统桌面
- 区分主机 cpu 计算机及计算机系统,小学计算机教案(二)
- vi 从第几行到第几行 替换_第三十三章:查找新函数:XLOOKUP,再也不用趴着电脑屏幕数第几列、第几行(二)...
- python读取pdf表格_【Python 库】解析PDF文本及表格——pdfminer、tabula、pdfplumber 的用法及对比...
- sql跨表查询_跨表查询经常有,何为跨表更新?
- MyBatis的架构和其运行流程
- 初学者学习Java的几大技巧
- 聊聊storm TridentBoltExecutor的finishBatch方法
- 使用pyspider爬取巨量淘宝MM图片
- flash加载flv,本地测试正常,上传至空间则失败解决办法