专栏首页老马说编程(62) 神奇的序列化 / 计算机程序的思维逻辑

(62) 神奇的序列化 / 计算机程序的思维逻辑

在前面几节,我们在将对象保存到文件时,使用的是DataOutputStream,从文件读入对象时,使用的是DataInputStream, 使用它们,需要逐个处理对象中的每个字段,我们提到,这种方式比较啰嗦,Java中有一种更为简单的机制,那就是序列化。

简单来说,序列化就是将对象转化为字节流,反序列化就是将字节流转化为对象。在Java中,具体如何来使用呢?它是如何实现的?有什么优缺点?本节就来探讨这些问题,我们先从它的基本用法谈起。

基本用法

Serializable

要让一个类支持序列化,只需要让这个类实现接口java.io.Serializable,Serializable没有定义任何方法,只是一个标记接口。比如,对于57节提到的Student类,为支持序列化,可改为:

public class Student implements Serializable {
    String name;
    int age;
    double score;
 
    public Student(String name, int age, double score) {
         ...
    }
    ...
}

声明实现了Serializable接口后,保存/读取Student对象就可以使用另两个流了ObjectOutputStream/ObjectInputStream。

ObjectOutputStream/ObjectInputStream

ObjectOutputStream是OutputStream的子类,但实现了ObjectOutput接口,ObjectOutput是DataOutput的子接口,增加了一个方法:

public void writeObject(Object obj) throws IOException

这个方法能够将对象obj转化为字节,写到流中。

ObjectInputStream是InputStream的子类,它实现了ObjectInput接口,ObjectInput是DataInput的子接口,增加了一个方法:

public Object readObject() throws ClassNotFoundException, IOException

这个方法能够从流中读取字节,转化为一个对象。

使用这两个流,57节介绍的保存学生列表的代码就可以变为:

public static void writeStudents(List<Student> students) throws IOException {
    ObjectOutputStream out = new ObjectOutputStream(
            new BufferedOutputStream(new FileOutputStream("students.dat")));
    try {
        out.writeInt(students.size());
        for (Student s : students) {
            out.writeObject(s);
        }
    } finally {
        out.close();
    }
}

而从文件中读入学生列表的代码可以变为:

public static List<Student> readStudents() throws IOException,
        ClassNotFoundException {
    ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(
            new FileInputStream("students.dat")));
    try {
        int size = in.readInt();
        List<Student> list = new ArrayList<>(size);
        for (int i = 0; i < size; i++) {
            list.add((Student) in.readObject());
        }
        return list;
    } finally {
        in.close();
    }
}

实际上,只要List对象也实现了Serializable (ArrayList/LinkedList都实现了),上面代码还可以进一步简化,读写只需要一行代码,如下所示:

public static void writeStudents(List<Student> students) throws IOException {
    ObjectOutputStream out = new ObjectOutputStream(
            new BufferedOutputStream(new FileOutputStream("students.dat")));
    try {
        out.writeObject(students);
    } finally {
        out.close();
    }
}

public static List<Student> readStudents() throws IOException,
        ClassNotFoundException {
    ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(
            new FileInputStream("students.dat")));
    try {
        return (List<Student>) in.readObject();
    } finally {
        in.close();
    }
}

是不是很神奇?只要将类声明实现Serializable接口,然后就可以使用ObjectOutputStream/ObjectInputStream直接读写对象了。我们之前介绍的各种类,如String, Date, Double, ArrayList, LinkedList, HashMap, TreeMap等,都实现了Serializable。

复杂对象

上面例子中的Student对象是非常简单的,如果对象比较复杂呢?比如:

  • 如果a, b两个对象都引用同一个对象c,序列化后c是保存两份还是一份?在反序列化后还能让a, b指向同一个对象吗?
  • 如果a, b两个对象有循环引用呢?即a引用了b,而b也引用了a。

我们分别来看下。

引用同一个对象

我们看个简单的例子,类A和类B都引用了同一个类Common,它们都实现了Serializable,这三个类的定义如下:

class Common implements Serializable {
    String c;

    public Common(String c) {
        this.c = c;
    }
}
class A implements Serializable {
    String a;
    Common common;
 
    public A(String a, Common common) {
        this.a = a;
        this.common = common;
    }

    public Common getCommon() {
        return common;
    }
}
class B implements Serializable {
    String b;
    Common common;
 
    public B(String b, Common common) {
        this.b = b;
        this.common = common;
    }

    public Common getCommon() {
        return common;
    }
}

有三个对象, a, b, c,如下所示:

Common c = new Common("common");
A a = new A("a", c);
B b = new B("b", c);

a和b引用同一个对象c,如果序列化这两个对象,反序列化后,它们还能指向同一个对象吗?答案是肯定的,我们看个实验。

ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bout);
out.writeObject(a);
out.writeObject(b);
out.close();

ObjectInputStream in = new ObjectInputStream(
        new ByteArrayInputStream(bout.toByteArray()));
A a2 = (A) in.readObject();
B b2 = (B) in.readObject();

if (a2.getCommon() == b2.getCommon()) {
    System.out.println("reference the same object");
} else {
    System.out.println("reference different objects");
}

输出为:

reference the same object

这也是Java序列化机制的神奇之处,它能自动处理这种引用同一个对象的情况。更神奇的是,它还能自动处理循环引用的情况,我们来看下。

循环引用

我们看个例子,有Parent和Child两个类,它们相互引用,类定义如下:

class Parent implements Serializable {
    String name;
    Child child;
 
    public Parent(String name) {
        this.name = name;
    }
    public Child getChild() {
        return child;
    }
    public void setChild(Child child) {
        this.child = child;
    }
}


class Child implements Serializable {
    String name;
    Parent parent;
 
    public Child(String name) {
        this.name = name;
    }
    public Parent getParent() {
        return parent;
    }
    public void setParent(Parent parent) {
        this.parent = parent;
    }    
}

定义两个对象:

Parent parent = new Parent("老马");
Child child = new Child("小马");
parent.setChild(child);
child.setParent(parent);

序列化parent, child两个对象,Java能正确序列化吗?反序列化后,还能保持原来的引用关系吗?答案是肯定的,我们看代码实验:

ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bout);
out.writeObject(parent);
out.writeObject(child);
out.close();

ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(
        bout.toByteArray()));
parent = (Parent) in.readObject();
child = (Child) in.readObject();

if (parent.getChild() == child && child.getParent() == parent
        && parent.getChild().getParent() == parent
        && child.getParent().getChild() == child) {
    System.out.println("reference OK");
} else {
    System.out.println("wrong reference");
}

输出为:

reference OK

神奇吧?

定制序列化

默认的序列化机制已经很强大了,它可以自动将对象中的所有字段自动保存和恢复,但这种默认行为有时候不是我们想要的。

比如,对于有些字段,它的值可能与内存位置有关,比如默认的hashCode()方法的返回值,当恢复对象后,内存位置肯定变了,基于原内存位置的值也就没有了意义。还有一些字段,可能与当前时间有关,比如表示对象创建时的时间,保存和恢复这个字段就是不正确的。

还有一些情况,如果类中的字段表示的是类的实现细节,而非逻辑信息,那默认序列化也是不适合的。为什么不适合呢?因为序列化格式表示一种契约,应该描述类的逻辑结构,而非与实现细节相绑定,绑定实现细节将使得难以修改,破坏封装。

比如,我们在容器类中介绍的LinkedList,它的默认序列化就是不适合的,为什么呢?因为LinkedList表示一个List,它的逻辑信息是列表的长度,以及列表中的每个对象,但LinkedList类中的字段表示的是链表的实现细节,如头尾节点指针,对每个节点,还有前驱和后继节点指针等。

那怎么办呢?Java提供了多种定制序列化的机制,主要的有两种,一种是transient关键字,另外一种是实现writeObject和readObject方法。

将字段声明为transient,默认序列化机制将忽略该字段,不会进行保存和恢复。比如,类LinkedList中,它的字段都声明为了transient,如下所示:

transient int size = 0;
transient Node<E> first;
transient Node<E> last;

声明为了transient,不是说就不保存该字段了,而是告诉Java默认序列化机制,不要自动保存该字段了,可以实现writeObject/readObject方法来自己保存该字段。

类可以实现writeObject方法,以自定义该类对象的序列化过程,其声明必须为:

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException

可以在这个方法中,调用ObjectOutputStream的方法向流中写入对象的数据。比如,LinkedList使用如下代码序列化列表的逻辑数据:

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    // Write out any hidden serialization magic
    s.defaultWriteObject();

    // Write out size
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (Node<E> x = first; x != null; x = x.next)
        s.writeObject(x.item);
}

需要注意的是第一行代码:

s.defaultWriteObject();

这一行是必须的,它会调用默认的序列化机制,默认机制会保存所有没声明为transient的字段,即使类中的所有字段都是transient,也应该写这一行,因为Java的序列化机制不仅会保存纯粹的数据信息,还会保存一些元数据描述等隐藏信息,这些隐藏的信息是序列化之所以能够神奇的重要原因。

与writeObject对应的是readObject方法,通过它自定义反序列化过程,其声明必须为:

private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException 

在这个方法中,调用ObjectInputStream的方法从流中读入数据,然后初始化类中的成员变量。比如,LinkedList的反序列化代码为:

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // Read in any hidden serialization magic
    s.defaultReadObject();

    // Read in size
    int size = s.readInt();

    // Read in all elements in the proper order.
    for (int i = 0; i < size; i++)
        linkLast((E)s.readObject());
}

注意第一行代码:

s.defaultReadObject();

这一行代码也是必须的。

序列化的基本原理

稍微总结一下:

  • 如果类的字段表示的就是类的逻辑信息,如上面的Student类,那就可以使用默认序列化机制,只要声明实现Serializable接口即可。
  • 否则的话,如LinkedList,那就可以使用transient关键字,实现writeObject和readObject来自定义序列化过程。
  • Java的序列化机制可以自动处理如引用同一个对象、循环引用等情况。

但,序列化到底是如何发生的呢?关键在ObjectOutputStream的writeObject和ObjectInputStream的readObject方法内。它们的实现都非常复杂,正因为这些复杂的实现才使得序列化看上去很神奇,我们简单介绍下其基本逻辑。

writeObject的基本逻辑是:

  • 如果对象没有实现Serializable,抛出异常NotSerializableException。
  • 每个对象都有一个编号,如果之前已经写过该对象了,则本次只会写该对象的引用,这可以解决对象引用和循环引用的问题。
  • 如果对象实现了writeObject方法,调用它的自定义方法。
  • 默认是利用反射机制(反射我们留待后续文章介绍),遍历对象结构图,对每个没有标记为transient的字段,根据其类型,分别进行处理,写出到流,流中的信息包括字段的类型即完整类名、字段名、字段值等。

readObject的基本逻辑是:

  • 不调用任何构造方法。
  • 它自己就相当于是一个独立的构造方法,根据字节流初始化对象,利用的也是反射机制。
  • 在解析字节流时,对于引用到的类型信息,会动态加载,如果找不到类,会抛出ClassNotFoundException。

版本问题

上面的介绍,我们忽略了一个问题,那就是版本问题。我们知道,代码是在不断演化的,而序列化的对象可能是持久保存在文件上的,如果类的定义发生了变化,那持久化的对象还能反序列化吗?

默认情况下,Java会给类定义一个版本号,这个版本号是根据类中一系列的信息自动生成的。在反序列化时,如果类的定义发生了变化,版本号就会变化,与流中的版本号就会不匹配,反序列化就会抛出异常,类型为java.io.InvalidClassException。

通常情况下,我们希望自定义这个版本号,而非让Java自动生成,一方面是为了更好的控制,另一方面是为了性能,因为Java自动生成的性能比较低,怎么自定义呢?在类中定义如下变量:

private static final long serialVersionUID = 1L;

在Java IDE如Eclipse中,如果声明实现了Serializable而没有定义该变量,IDE会提示自动生成。这个变量的值可以是任意的,代表该类的版本号。在序列化时,会将该值写入流,在反序列化时,会将流中的值与类定义中的值进行比较,如果不匹配,会抛出InvalidClassException。

那如果版本号一样,但实际的字段不匹配呢?Java会分情况自动进行处理,以尽量保持兼容性,大概分为三种情况:

  • 字段删掉了:即流中有该字段,而类定义中没有,该字段会被忽略。
  • 新增了字段:即类定义中有,而流中没有,该字段会被设为默认值。
  • 字段类型变了:对于同名的字段,类型变了,会抛出InvalidClassException。

高级自定义

除了自定义writeObject/readObject方法,Java中还有如下自定义序列化过程的机制:

  • Externalizable接口
  • readResolve方法
  • writeReplace方法

这些机制实际用到的比较少,我们简要说明下。

Externalizable是Serializable的子接口,定义了如下方法:

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

与writeObject/readObject的区别是,如果对象实现了Externalizable接口,则序列化过程会由这两个方法控制,默认序列化机制中的反射等将不再起作用,不再有类似defaultWriteObject和defaultReadObject调用,另一个区别是,反序列化时,会先调用类的无参构造方法创建对象,然后才调用readExternal。默认的序列化机制由于需要分析对象结构,往往比较慢,通过实现Externalizable接口,可以提高性能。

readResolve方法返回一个对象,声明为:

Object readResolve()  

如果定义了该方法,在反序列化之后,会额外调用该方法,该方法的返回值才会被当做真正的反序列化的结果。这个方法通常用于反序列化单例对象的场景。

writeReplace也是返回一个对象,声明为:

Object writeReplace()

如果定义了该方法,在序列化时,会先调用该方法,该方法的返回值才会被当做真正的对象进行序列化。

writeReplace和readResolve可以构成一种所谓的序列化代理模式,这个模式描述在<Effective Java> 第二版78条中,Java容器类中的EnumSet使用了该模式,我们一般用的比较少,就不详细介绍了。

序列化特点分析

序列化的主要用途有两个,一个是对象持久化,另一个是跨网络的数据交换、远程过程调用。

Java标准的序列化机制有很多优点,使用简单,可自动处理对象引用和循环引用,也可以方便的进行定制,处理版本问题等,但它也有一些重要的局限性:

  • Java序列化格式是一种私有格式,是一种Java语言特有的技术,不能被其他语言识别,不能实现跨语言的数据交换。
  • Java在序列化字节中保存了很多描述信息,使得序列化格式比较大。
  • Java的默认序列化使用反射分析遍历对象结构,性能比较低。
  • Java的序列化格式是二进制的,不方便查看和修改。

由于这些局限性,实践中往往会使用一些替代方案。在跨语言的数据交换格式中,XML/JSON是被广泛采用的文本格式,各种语言都有对它们的支持,文件格式清晰易读,有很多查看和编辑工具,它们的不足之处是性能和序列化大小,在性能和大小敏感的领域,往往会采用更为精简高效的二进制方式如ProtoBuf, Thrift, MessagePack等。

小结

本节介绍了Java的标准序列化机制,我们介绍了它的用法和基本原理,最后分析了它的特点,它是一种神奇的机制,通过简单的Serializable接口就能自动处理很多复杂的事情,但它也有一些重要的限制,最重要的是不能跨语言。

在接来下的几节中,我们来看一些替代方案,包括XML/JSON和MessagePack。

本文分享自微信公众号 - 老马说编程(laoma_shuo),作者:老马

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2016-12-20

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • (44) 剖析TreeSet / 计算机程序的思维逻辑

    41节介绍了HashSet,我们提到,HashSet有一个重要局限,元素之间没有特定的顺序,我们还提到,Set接口还有另一个重要的实现类TreeSet,它是有序...

    swiftma
  • 计算机程序的思维逻辑 (11) - 初识函数

    查看上节内容,请点击上方链接关注公众号,查看所有文章。 函数 前面几节我们介绍了数据的基本类型、基本操作和流程控制,使用这些已经可以写不少程序了。 但是如果需...

    swiftma
  • (28) 剖析包装类 (下) / 计算机程序的思维逻辑

    本节探讨Character类,它的基本用法我们在包装类第一节已经介绍了,本节不再赘述。Character类除了封装了一个char外,还有什么可介绍的呢?它有很多...

    swiftma
  • spring-boot-starter-grpc 不同序列化方式性能测试及选型

    Github 地址:https://github.com/alipay/sofa-hessian

    码农小胖哥
  • spring-boot-starter-grpc 不同序列化方式性能测试及选型

    Github 地址:https://github.com/alipay/sofa-hessian

    轻量级微服务
  • java 的序列化和反序列化的问题

    引言 将 Java 对象序列化为二进制文件的 Java 序列化技术是 Java 系列技术中一个较为重要的技术点,在大部分情况下,开发人员只需要了解被序列化的...

    xiangzhihong
  • 【通知】+ java基础提升篇:Java 序列化的高级认识

    好好学java
  • Android序列化总结

    公园里,一位仙风鹤骨的老者在打太极,一招一式都仙气十足,一个年轻人走过去:“大爷,太极这玩意儿花拳绣腿,你练它干啥?”老者淡淡一笑:“年轻人,你还没有领悟到太极...

    大公爵
  • JDK1.9-序列化

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。

    cwl_java
  • 理解Java集合框架里面的的transient关键字

    我是攻城师

扫码关注云+社区

领取腾讯云代金券

玩转腾讯云 有奖征文活动