深刻理解 Java 序列化

时间  2019-11-24
标签 深刻 理解 java 序列 栏目 Java 繁體版
原文   原文链接

:notebook: 本文已归档到：「blog」html

:keyboard: 本文中的示例代码已归档到：「javacore」java

简介



  • 序列化（serialize） - 序列化是将对象转换为字节流。
  • 反序列化（deserialize） - 反序列化是将字节流转换为对象。
  • 序列化用途
    • 序列化能够将对象的字节序列持久化——保存在内存、文件、数据库中。
    • 在网络上传送对象的字节序列。
    • RMI(远程方法调用)

:bell: 注意：使用 Java 对象序列化，在保存对象时，会把其状态保存为一组字节，在将来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的”状态”，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。git

序列化和反序列化

Java 经过对象输入输出流来实现序列化和反序列化：程序员

  • java.io.ObjectOutputStream 类的 writeObject() 方法能够实现序列化；
  • java.io.ObjectInputStream 类的 readObject() 方法用于实现反序列化。

序列化和反序列化示例：github

public class SerializeDemo01 {
    enum Sex {
        MALE,
        FEMALE
    }


    static class Person implements Serializable {
        private static final long serialVersionUID = 1L;
        private String name = null;
        private Integer age = null;
        private Sex sex;

        public Person() { }

        public Person(String name, Integer age, Sex sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }

        @Override
        public String toString() {
            return "Person{" + "name='" + name + '\'' + ", age=" + age + ", sex=" + sex + '}';
        }
    }

    /** * 序列化 */
    private static void serialize(String filename) throws IOException {
        File f = new File(filename); // 定义保存路径
        OutputStream out = new FileOutputStream(f); // 文件输出流
        ObjectOutputStream oos = new ObjectOutputStream(out); // 对象输出流
        oos.writeObject(new Person("Jack", 30, Sex.MALE)); // 保存对象
        oos.close();
        out.close();
    }

    /** * 反序列化 */
    private static void deserialize(String filename) throws IOException, ClassNotFoundException {
        File f = new File(filename); // 定义保存路径
        InputStream in = new FileInputStream(f); // 文件输入流
        ObjectInputStream ois = new ObjectInputStream(in); // 对象输入流
        Object obj = ois.readObject(); // 读取对象
        ois.close();
        in.close();
        System.out.println(obj);
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        final String filename = "d:/text.dat";
        serialize(filename);
        deserialize(filename);
    }
}
// Output:
// Person{name='Jack', age=30, sex=MALE}
复制代码

Serializable 接口

被序列化的类必须属于 Enum、Array 和 Serializable 类型其中的任何一种。数据库

若是不是 Enum、Array 的类，若是须要序列化，必须实现 java.io.Serializable 接口，不然将抛出 NotSerializableException 异常。这是由于：在序列化操做过程当中会对类型进行检查，若是不知足序列化类型要求，就会抛出异常。apache

咱们不妨作一个小尝试：将 SerializeDemo01 示例中 Person 类改成以下实现，而后看看运行结果。编程

public class UnSerializeDemo {
    static class Person { // 其余内容略 }
    // 其余内容略
}
复制代码

输出：结果就是出现以下异常信息。json

Exception in thread "main" java.io.NotSerializableException:
...
复制代码

serialVersionUID

请注意 serialVersionUID 字段，你能够在 Java 世界的无数类中看到这个字段。bash

serialVersionUID 有什么做用，如何使用 serialVersionUID？

serialVersionUID 是 Java 为每一个序列化类产生的版本标识。它能够用来保证在反序列时，发送方发送的和接受方接收的是可兼容的对象。若是接收方接收的类的 serialVersionUID 与发送方发送的 serialVersionUID 不一致，会抛出 InvalidClassException。

若是可序列化类没有显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值。尽管这样，仍是建议在每个序列化的类中显式指定 serialVersionUID 的值。由于不一样的 jdk 编译极可能会生成不一样的 serialVersionUID 默认值，从而致使在反序列化时抛出 InvalidClassExceptions 异常。

serialVersionUID 字段必须是 static final long 类型。

咱们来举个例子：

（1）有一个可序列化类 Person

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private Integer age;
    private String address;
    // 构造方法、get、set 方法略
}
复制代码

（2）开发过程当中，对 Person 作了修改，增长了一个字段 email，以下：

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private Integer age;
    private String address;
    private String email;
    // 构造方法、get、set 方法略
}
复制代码

因为这个类和老版本不兼容，咱们须要修改版本号：

private static final long serialVersionUID = 2L;
复制代码

再次进行反序列化，则会抛出 InvalidClassException 异常。

综上所述，咱们大概能够清楚：serialVersionUID 用于控制序列化版本是否兼容。若咱们认为修改的可序列化类是向后兼容的，则不修改 serialVersionUID。

默认序列化机制

若是仅仅只是让某个类实现 Serializable 接口，而没有其它任何处理的话，那么就会使用默认序列化机制。

使用默认机制，在序列化对象时，不只会序列化当前对象自己，还会对其父类的字段以及该对象引用的其它对象也进行序列化。一样地，这些其它对象引用的另外对象也将被序列化，以此类推。因此，若是一个对象包含的成员变量是容器类对象，而这些容器所含有的元素也是容器类对象，那么这个序列化的过程就会较复杂，开销也较大。

注意：这里的父类和引用对象既然要进行序列化，那么它们固然也要知足序列化要求：被序列化的类必须属于 Enum、Array 和 Serializable 类型其中的任何一种。

非默认序列化机制

在现实应用中，有些时候不能使用默认序列化机制。好比，但愿在序列化过程当中忽略掉敏感数据，或者简化序列化过程。下面将介绍若干影响序列化的方法。

transient 关键字

当某个字段被声明为 transient 后，默认序列化机制就会忽略该字段。

咱们将 SerializeDemo01 示例中的内部类 Person 的 age 字段声明为 transient，以下所示：

public class SerializeDemo02 {
    static class Person implements Serializable {
        transient private Integer age = null;
        // 其余内容略
    }
    // 其余内容略
}
// Output:
// name: Jack, age: null, sex: MALE
复制代码

从输出结果能够看出，age 字段没有被序列化。

Externalizable 接口

不管是使用 transient 关键字，仍是使用 writeObject() 和 readObject() 方法，其实都是基于 Serializable 接口的序列化。

JDK 中提供了另外一个序列化接口--Externalizable。

可序列化类实现 Externalizable 接口以后，基于 Serializable 接口的默认序列化机制就会失效。

咱们来基于 SerializeDemo02 再次作一些改动，代码以下：

public class ExternalizeDemo01 {
    static class Person implements Externalizable {
        transient private Integer age = null;
        // 其余内容略

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }

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

        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { }
    }
     // 其余内容略
}
// Output:
// call Person()
// name: null, age: null, sex: null
复制代码

从该结果，一方面能够看出 Person 对象中任何一个字段都没有被序列化。另外一方面，若是细心的话，还能够发现这这次序列化过程调用了 Person 类的无参构造方法。

  • Externalizable 继承于 Serializable，它增添了两个方法：writeExternal() 与 readExternal()。这两个方法在序列化和反序列化过程当中会被自动调用，以便执行一些特殊操做。当使用该接口时，序列化的细节须要由程序员去完成。如上所示的代码，因为 writeExternal() 与 readExternal() 方法未做任何处理，那么该序列化行为将不会保存/读取任何一个字段。这也就是为何输出结果中全部字段的值均为空。
  • 另外，若使用 Externalizable 进行序列化，当读取对象时，会调用被序列化类的无参构造方法去建立一个新的对象；而后再将被保存对象的字段的值分别填充到新对象中。这就是为何在这次序列化过程当中 Person 类的无参构造方法会被调用。因为这个缘由，实现 Externalizable 接口的类必需要提供一个无参的构造方法，且它的访问权限为 public。

对上述 Person 类做进一步的修改，使其可以对 name 与 age 字段进行序列化，但要忽略掉 gender 字段，以下代码所示：

public class ExternalizeDemo02 {
    static class Person implements Externalizable {
        transient private Integer age = null;
        // 其余内容略

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }

        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            out.writeObject(name);
            out.writeInt(age);
        }

        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            name = (String) in.readObject();
            age = in.readInt();
        }
    }
     // 其余内容略
}
// Output:
// call Person()
// name: Jack, age: 30, sex: null
复制代码

Externalizable 接口的替代方法

实现 Externalizable 接口能够控制序列化和反序列化的细节。它有一个替代方法：实现 Serializable 接口，并添加 writeObject(ObjectOutputStream out) 与 readObject(ObjectInputStream in) 方法。序列化和反序列化过程当中会自动回调这两个方法。

示例以下所示：

public class SerializeDemo03 {
    static class Person implements Serializable {
        transient private Integer age = null;
        // 其余内容略

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }
        // 其余内容略
    }
    // 其余内容略
}
// Output:
// name: Jack, age: 30, sex: MALE
复制代码

在 writeObject() 方法中会先调用 ObjectOutputStream 中的 defaultWriteObject() 方法，该方法会执行默认的序列化机制，如上节所述，此时会忽略掉 age 字段。而后再调用 writeInt() 方法显示地将 age 字段写入到 ObjectOutputStream 中。readObject() 的做用则是针对对象的读取，其原理与 writeObject() 方法相同。

注意：writeObject() 与 readObject() 都是 private 方法，那么它们是如何被调用的呢？毫无疑问，是使用反射。详情可见 ObjectOutputStream 中的 writeSerialData 方法，以及 ObjectInputStream 中的 readSerialData 方法。

readResolve() 方法

当咱们使用 Singleton 模式时，应该是指望某个类的实例应该是惟一的，但若是该类是可序列化的，那么状况可能会略有不一样。此时对第 2 节使用的 Person 类进行修改，使其实现 Singleton 模式，以下所示：

public class SerializeDemo04 {

    enum Sex {
        MALE, FEMALE
    }

    static class Person implements Serializable {
        private static final long serialVersionUID = 1L;
        private String name = null;
        transient private Integer age = null;
        private Sex sex;
        static final Person instatnce = new Person("Tom", 31, Sex.MALE);

        private Person() {
            System.out.println("call Person()");
        }

        private Person(String name, Integer age, Sex sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }

        public static Person getInstance() {
            return instatnce;
        }

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }

        public String toString() {
            return "name: " + this.name + ", age: " + this.age + ", sex: " + this.sex;
        }
    }

    /** * 序列化 */
    private static void serialize(String filename) throws IOException {
        File f = new File(filename); // 定义保存路径
        OutputStream out = new FileOutputStream(f); // 文件输出流
        ObjectOutputStream oos = new ObjectOutputStream(out); // 对象输出流
        oos.writeObject(new Person("Jack", 30, Sex.MALE)); // 保存对象
        oos.close();
        out.close();
    }

    /** * 反序列化 */
    private static void deserialize(String filename) throws IOException, ClassNotFoundException {
        File f = new File(filename); // 定义保存路径
        InputStream in = new FileInputStream(f); // 文件输入流
        ObjectInputStream ois = new ObjectInputStream(in); // 对象输入流
        Object obj = ois.readObject(); // 读取对象
        ois.close();
        in.close();
        System.out.println(obj);
        System.out.println(obj == Person.getInstance());
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        final String filename = "d:/text.dat";
        serialize(filename);
        deserialize(filename);
    }
}
// Output:
// name: Jack, age: null, sex: MALE
// false
复制代码

值得注意的是，从文件中获取的 Person 对象与 Person 类中的单例对象并不相等。为了能在单例类中仍然保持序列的特性，可使用 readResolve() 方法。在该方法中直接返回 Person 的单例对象。咱们在 SerializeDemo04 示例的基础上添加一个 readObject 方法， 以下所示：

public class SerializeDemo05 {
    // 其余内容略

    static class Person implements Serializable {

        // 添加此方法
        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }
        // 其余内容略
    }

    // 其余内容略
}
// Output:
// name: Tom, age: 31, sex: MALE
// true
复制代码

序列化工具

Java 官方的序列化存在许多问题，所以，不少人更愿意使用优秀的第三方序列化工具来替代 Java 自身的序列化机制。

Java 官方的序列化主要体如今如下方面：

  • Java 官方的序列化性能不高，序列化后的数据相对于一些优秀的序列化的工具，仍是要大很多，这大大影响存储和传输的效率。
  • Java 官方的序列化必定须要实现 Serializable 接口。
  • Java 官方的序列化须要关注 serialVersionUID。
  • Java 官方的序列没法跨语言使用。

固然咱们还有更加优秀的一些序列化和反序列化的工具，根据不一样的使用场景能够自行选择！

  • thrift、protobuf - 适用于对性能敏感，对开发体验要求不高的内部系统。
  • hessian - 适用于对开发体验敏感，性能有要求的内外部系统。
  • jackson、gson、fastjson - 适用于对序列化后的数据要求有良好的可读性（转为 json 、xml 形式）。

小结



参考资料

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程