Java Serializable:明明就一个空的接口嘛



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

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

01、先来点理论

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.Wanger    at 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)

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

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() + "\n" + 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、再来点注意事项

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

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

首先,在 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<ObjectStreamField> 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;    }

    @Override    public String toString() {        return "Wanger{" + "name=" + name + ",age=" + age + "}";    }

    @Override    public void writeExternal(ObjectOutput out) throws IOException {

    }

    @Override    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

    }

}

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

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

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

java.io.InvalidClassException: com.cmower.java_demo.xuliehua1.Wanger; no valid constructor    at 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)调用 ObjectOutputwriteObject() 方法将字符串类型的 name 写入到输出流中;

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

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

4)调用 ObjectInputreadInt() 方法将字符串类型的 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 = -2095916884810199533    at 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 = -3818877437117647968    at 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 竟然有这么多可以研究的内容!

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

原文地址:https://www.cnblogs.com/qing-gee/p/11063603.html

时间: 2024-10-01 05:14:27

Java Serializable:明明就一个空的接口嘛的相关文章

Java语言程序设计 上机实验4 掌握声明接口、一个类实现接口的声明和使用方法

Java语言程序设计 上机实验4 实验目的: 理解接口的作用,理解接口和实现接口的类的关系,掌握声明接口.一个类实现接口的声明和使用方法:熟悉Java语言包和实用包中的常用类. 实验内容:(*)为选做 声明圆柱体类Cylinder,继承椭圆类Ellipse(实现周长Perimeter接口和面积Area接口),为圆柱体类设计较为全面的构造方法,并实现体积Volume接口,计算表面积和体积. 将Java的若干关键字(15个以上)保存在一个字符串数组中,对其按升序排列,再采用顺序查找和二分法查找,判断

Java回顾:用一个Demo来说明继承抽象类和实现接口的简单框架模型

大家都知道,在java应用开发中,要"面向接口编程". 那么什么是接口?接口有什么作用?接口如何使用?我们一起来回顾一下. [声明]欢迎转载,但请保留文章原始出处:http://blog.csdn.net/yelangjueqi/article/details/44701369 1,接口回顾: 1.1,Java中接口的概念 在Java中接口是一种特殊的抽象类,跟一般的抽象类相比,接口里面的所有方法都是抽象方法,接口里面的所有属性都是常量.也就是说,接口里面只有方法定义而没有任何方法实现

java swing最简单实例(1) 一个空的JFrame

我准备写一个系列的java图形化界面的教程.每个程序都尽量只写维持运行所需的最简化程度的代码,好让大家都看懂. 使用java图形界面只需要jdk,eclipse即可.如果布局抽象能力不够强大,建议装jigloo先用它布局然后再抄代码.(jigloo自动生成的代码冗余量太大,放的位置也不合理,只是为了看效果,之后还是需要ctrl+C,ctrl+V的) 要想放置一切东西,我们需要先有一个JFrame.所以就先讲一讲怎样创建一个空的JFrame. 下面是一个最简单的例子,首先我们需要extends J

ZeroMQ接口函数之 :zmq_msg_init - 初始化一个空的ZMQ消息结构

ZeroMQ 官方地址 :http://api.zeromq.org/4-1:zmq_msg_init zmq_msg_init(3) ØMQ Manual - ØMQ/3.2.5 Name zmq_msg_init - 初始化一个空的ZMQ消息结构 Synopsis int zmq_msg_init (zmq_msg_t *msg); Description zmq_msg_init()函数会将msg参数引用的ZMQ消息对象进行初始化,使其成为一个空消息.在使用zmq_recv()函数接收消息

Java集合类:&quot;随机访问&quot; 的RandomAccess接口

引出RandomAccess接口 如果我们用Java做开发的话,最常用的容器之一就是List集合了,而List集合中用的较多的就是ArrayList 和 LinkedList 两个类,这两者也常被用来做比较.因为最近在学习Java的集合类源码,对于这两个类自然是不能放过,于是乎,翻看他们的源码,我发现,ArrayList实现了一个叫做 RandomAccess 的接口,而 LinkedList 是没有的, public class ArrayList<E> extends AbstractLi

对Java Serializable(序列化)的理解和总结(转)

转自:https://www.cnblogs.com/qq3111901846/p/7894532.html 1.序列化是干什么的?       简单说就是为了保存在内存中的各种对象的状态(也就是实例变量,不是方法),并且可以把保存的对象状态再读出来.虽然你可以用你自己的各种各样的方法来保存object states,但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化. 2.什么情况下需要序列化       a)当你想把的内存中的对象状态保存到一个文件中或者数据库中时候: 

黑马程序员——Java基础——面向对象——继承、抽象类、接口、多态、包、内部类、异常等

第一讲 继承 1.继承: 当多个类拥有相同的功能时,那么这些类不需要每个都写这些相同的功能,只需要把相同功能抽到 一个单独的类中,继承这个类就能获得这些相同的功能: (1)继承的体系结构:就是对要描述的事物进行不断的向上抽取,就出现了体系结构. 要了解这个体系结构中最共性的内容,就看最顶层的类. 要使用这个体系的功能,就用最底层的类创建对象 (2)好处: A.提高代码复用性: B.继承的出现,让类与类之间产生关系,为多态的前提 (3)特点: A.只能单继承(准确的说是java对多继承进行优化,避

每天进步一点点-Java Serializable(对象序列化)的理解和总结

往硬盘文件里写数据 序列化:序列化是将对象转换为容易传输的格式的过程.例如,可以序列化一个对象,然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象.在另一端,反序列化将从该流重新构造对象. 是对象永久化的一种机制. 确切的说应该是对象的序列化,一般程序在运行时,产生对象,这些对象随着程序的停止运行而消失,但如果我们想把某些对象(因为是对象,所以有各自不同的特性)保存下来,在程序终止运行后,这些对象仍然存在,可以在程序再次运行时读取这些对象的值,或者在其他程序中利用这些保存

Java学习关于集合框架的基础接口--Collection接口

 集合框架(Collection  Framework)是Java最强大的子系统之一,位于java.util 包中.集合框架是一个复杂的接口与和类层次,提供了管理对象组的最新技术.Java集合框架标准化了程序处理对象组的方式. 集合框架在设计上需要满足几个目标.首先,框架必须是高性能的.基本集合(动态数组.链表.树以及哈希表)的实现是高效率的.很少需要手动编写这些数据引擎中的某一个.其次,框架必须允许不同类型的集合以类似的方式进行工作,并且具有高度的互操作性.再次,扩展或改造必须易于实现.为了满