如何领略Java工具的序列化

副标题#e#

关于Java序列化的文章早已是汗牛充栋了，本文是对我小我私家过往进修，领略及应用Java序列化的一个总结。此文内容涉及Java序列化的根基道理，以及多种要领对序列化形式举办定制。在撰写本文时，既参考了Thinking in Java, Effective Java，JavaWorld，developerWorks中的相关文章和其它网络资料，也插手了本身的实践履历与领略，文、码并茂，但愿对各人有所辅佐。(2012.02.14最后更新)

一、什么是Java工具序列化

Java平台答允我们在内存中建设可复用的Java工具，但一般环境下，只有当JVM处于运行时，这些工具才大概存在，即，这些工具的生命周期不会比JVM的生命周期更长。但在现实应用中，就大概要求在JVM遏制运行之后可以或许生存(耐久化)指定的工具，并在未来从头读取被生存的工具。Java工具序列化就可以或许辅佐我们实现该成果。

利用Java工具序列化，在生存工具时，会把其状态生存为一组字节，在将来，再将这些字节组装成工具。必需留意地是，工具序列化生存的是工具的”状态”，即它的成员变量。由此可知，工具序列化不会存眷类中的静态变量。

除了在耐久化工具时会用到工具序列化之外，当利用RMI(长途要领挪用)，或在网络中通报工具时，城市用到工具序列化。Java序列化API为处理惩罚工具序列化提供了一个尺度机制，该API简朴易用，在本文的后续章节中将会连续讲到。

二、简朴示例

在Java中，只要一个类实现了java.io.Serializable接口，那么它就可以被序列化。此处将建设一个可序列化的类Person，本文中的所有示例将环绕着该类或其修改版。

Gender类，是一个列举范例，暗示性别

  Gender {
    MALE, FEMALE
}

假如熟悉Java列举范例的话，应该知道每个列举范例城市默认担任类java.lang.Enum，而该类实现了Serializable接口，所以列举范例工具都是默承认以被序列化的。

Person类，实现了Serializable接口，它包括三个字段：name，String范例；age，Integer范例；gender，Gender范例。别的，还重写该类的toString()要领，以利便打印Person实例中的内容。

     {

     String name = ;

     Integer age = ;

     Gender gender = ;

     () {
        System.out.println();
    }

     (String name, Integer age, Gender gender) {
        System.out.println();
        .name = name;
        .age = age;
        .gender = gender;
    }

     String () {
         name;
    }

      (String name) {
        .name = name;
    }

     Integer () {
         age;
    }

      (Integer age) {
        .age = age;
    }

     Gender () {
         gender;
    }

      (Gender gender) {
        .gender = gender;
    }

    
     String () {
          + name +  + age +  + gender + ;
    }
}

SimpleSerial，是一个简朴的序列化措施，它先将一个Person工具生存到文件person.out中，然后再从该文件中读出被存储的Person工具，并打印该工具。

  SimpleSerial {

       (String[] args) throws Exception {
        File file =  File();

        ObjectOutputStream oout =  ObjectOutputStream( FileOutputStream(file));
        Person person =  Person(, , Gender.MALE);
        oout.writeObject(person);
        oout.close();

        ObjectInputStream oin =  ObjectInputStream( FileInputStream(file));
        Object newPerson = oin.readObject(); 
        oin.close();
        System..println(newPerson);
    }
}

上述措施的输出的功效为：

arg 
[, 31, ]

此时必需留意的是，当从头读取被生存的Person工具时，并没有挪用Person的任何结构器，看起来就像是直接利用字节将Person工具还原出来的。

当Person工具被生存到person.out文件中之后，我们可以在其它处所去读取该文件以还原工具，但必需确保该读取措施CLASSPATH中包括有Person.class(哪怕在读取Person工具时并没有显示地利用Person类，如上例所示)，不然会抛出ClassNotFoundException。

三、Serializable的浸染

为什么一个类实现了Serializable接口，它就可以被序列化呢？在上节的示例中，利用ObjectOutputStream来耐久化工具，在该类中有如下代码：

  (Object obj,  unshared)  IOException {

     (obj  String) {
        writeString((String) obj, unshared);
    }   (cl.isArray()) {
        writeArray(obj, desc, unshared);
    }   (obj  Enum) {
        writeEnum((Enum) obj, desc, unshared);
    }   (obj  Serializable) {
        writeOrdinaryObject(obj, desc, unshared);
    }  {
         (extendedDebugInfo) {
              NotSerializableException(cl.getName() + 
                    + debugInfoStack.toString());
        }  {
              NotSerializableException(cl.getName());
        }
    }

}

#p#分页标题#e#

从上述代码可知，假如被写工具的范例是String，或数组，或Enum，或Serializable，那么就可以对该工具举办序列化，不然将抛出NotSerializableException。

四、默认序列化机制

假如仅仅只是让某个类实现Serializable接口，而没有其它任那里理惩罚的话，则就是利用默认序列化机制。利用默认机制，在序列化工具时，不只会序列化当前工具自己，还会对该工具引用的其它工具也举办序列化，同样地，这些其它工具引用的别的工具也将被序列化，以此类推。所以，假如一个工具包括的成员变量是容器类工具，而这些容器所含有的元素也是容器类工具，那么这个序列化的进程就会较巨大，开销也较大。

五、影响序列化

在现实应用中，有些时候不能利用默认序列化机制。好比，但愿在序列化进程中忽略掉敏感数据，可能简化序列化进程。下面将先容若干影响序列化的要领。

#p#副标题#e#

1、transient要害字

当某个字段被声明为transient后，默认序列化机制就会忽略该字段。此处将Person类中的age字段声明为transient，如下所示，

     {

      Integer age = ;

}

再执行SimpleSerial应用措施，会有如下输出：

arg 
[, , ]

可见，age字段未被序列化。

2、writeObject()要领与readObject()要领

对付上述已被声明为transitive的字段age，除了将transitive要害字去掉之外，是否尚有其它要领能使它再次可被序列化？要领之一就是在Person类中添加两个要领：writeObject()与readObject()，如下所示：

     {

      Integer age = ;


      (ObjectOutputStream out)  IOException {
        out.defaultWriteObject();
        out.writeInt(age);
    }

      (ObjectInputStream in)  IOException, ClassNotFoundException {
        in.defaultReadObject();
        age = in.readInt();
    }
}

在writeObject()要领中会先挪用ObjectOutputStream中的defaultWriteObject()要领，该要了解执行默认的序列化机制，如5.1节所述，此时会忽略掉age字段。然后再挪用writeInt()要领显示地将age字段写入到ObjectOutputStream中。readObject()的浸染则是针对工具的读取，其道理与writeObject()要领沟通。

再次执行SimpleSerial应用措施，则又会有如下输出：

arg 
[, 31, ]

必需留意地是，writeObject()与readObject()都是private要领，那么它们是如何被挪用的呢？毫无疑问，是利用反射。详情可见ObjectOutputStream中的writeSerialData要领，以及ObjectInputStream中的readSerialData要领。

3、Externalizable接口

无论是利用transient要害字，照旧利用writeObject()和readObject()要领，其实都是基于Serializable接口的序列化。JDK中提供了另一个序列化接口–Externalizable，利用该接口之后，之前基于Serializable接口的序列化机制就将失效。此时将Person类修改成如下，

     {

     String name = ;

      Integer age = ;

     Gender gender = ;

     () {
        System.out.println();
    }

     (String name, Integer age, Gender gender) {
        System.out.println();
        .name = name;
        .age = age;
        .gender = gender;
    }

      (ObjectOutputStream out)  IOException {
        out.defaultWriteObject();
        out.writeInt(age);
    }

      (ObjectInputStream in)  IOException, ClassNotFoundException {
        in.defaultReadObject();
        age = in.readInt();
    }

    
      (ObjectOutput out)  IOException {

    }

    
      (ObjectInput in)  IOException, ClassNotFoundException {

    }

}

此时再执行SimpleSerial措施之后会获得如下功效：

arg 
- 
[, , ]

从该功效，一方面可以看出Person工具中任何一个字段都没有被序列化。另一方面，假如细心的话，还可以发明这此序次列化进程挪用了Person类的无参结构器。

Externalizable担任于Serializable，当利用该接口时，序列化的细节需要由措施员去完成。如上所示的代码，由于writeExternal()与readExternal()要领未作任那里理惩罚，那么该序列化行为将不会生存/读取任何一个字段。这也就是为什么输出功效中所有字段的值均为空。

别的，若利用Externalizable举办序列化，当读取工具时，会挪用被序列化类的无参结构器去建设一个新的工具，然后再将被生存工具的字段的值别离填充到新工具中。这就是为什么在此序次列化进程中Person类的无参结构器会被挪用。由于这个原因，实现Externalizable接口的类必需要提供一个无参的结构器，且它的会见权限为public。

#p#分页标题#e#

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

     {

     String name = ;

      Integer age = ;

     Gender gender = ;

     () {
        System.out.println();
    }

     (String name, Integer age, Gender gender) {
        System.out.println();
        .name = name;
        .age = age;
        .gender = gender;
    }

      (ObjectOutputStream out)  IOException {
        out.defaultWriteObject();
        out.writeInt(age);
    }

      (ObjectInputStream in)  IOException, ClassNotFoundException {
        in.defaultReadObject();
        age = in.readInt();
    }

    
      (ObjectOutput out)  IOException {
        out.writeObject(name);
        out.writeInt(age);
    }

    
      (ObjectInput in)  IOException, ClassNotFoundException {
        name = (String) in.readObject();
        age = in.readInt();
    }

}

执行SimpleSerial之后会有如下功效：

arg 
- 
[, 31, ]

#p#副标题#e#

4、readResolve()要领

当我们利用Singleton模式时，应该是期望某个类的实例应该是独一的，但假如该类是可序列化的，那么环境大概会略有差异。此时对第2节利用的Person类举办修改，使其实现Singleton模式，如下所示：

     {

        {
           Person instatnce =  Person(, , Gender.MALE);
    }

      Person () {
         InstanceHolder.instatnce;
    }

     String name = ;

     Integer age = ;

     Gender gender = ;

     () {
        System.out.println();
    }

     (String name, Integer age, Gender gender) {
        System.out.println();
        .name = name;
        .age = age;
        .gender = gender;
    }

}

同时要修改SimpleSerial应用，使得可以或许生存/获取上述单例工具，并举办工具相等性较量，如下代码所示：

  SimpleSerial {

       (String[] args) throws Exception {
        File file =  File();
        ObjectOutputStream oout =  ObjectOutputStream( FileOutputStream(file));
		//URL：http://www.bianceng.cn/Programming/Java/201608/50354.htm
        oout.writeObject(Person.getInstance()); 
        oout.close();

        ObjectInputStream oin =  ObjectInputStream( FileInputStream(file));
        Object newPerson = oin.readObject();
        oin.close();
        System..println(newPerson);

        System..println(Person.getInstance() == newPerson); 
    }
}

执行上述应用措施后会获得如下功效：

arg 
[, 31, ]

值得留意的是，从文件person.out中获取的Person工具与Person类中的单例工具并不相等。为了能在序列化进程仍能保持单例的特性，可以在Person类中添加一个readResolve()要领，在该要领中直接返回Person的单例工具，如下所示：

     {

        {
           Person instatnce =  Person(, , Gender.MALE);
    }

      Person () {
         InstanceHolder.instatnce;
    }

     String name = ;

     Integer age = ;

     Gender gender = ;

     () {
        System.out.println();
    }

     (String name, Integer age, Gender gender) {
        System.out.println();
        .name = name;
        .age = age;
        .gender = gender;
    }

     Object ()  ObjectStreamException {
         InstanceHolder.instatnce;
    }

}

再次执行本节的SimpleSerial应用后将有如下输出：

arg 
[, 31, ]

无论是实现Serializable接口，或是Externalizable接口，当从I/O流中读取工具时，readResolve()要领城市被挪用到。实际上就是用readResolve()中返回的工具直接替换在反序列化进程中建设的工具，而被建设的工具则会被垃圾接纳掉。

戴德：

领略Java工具序列化：http://www.blogjava.net/jiangshachina/archive/2012/02/13/369898.html