Java-理论知识之串行化

对对象进行串行化的方法有两种 ： 1 Serializable接口  2 Externalizable接口 （安卓的对象串行化还可以使用Parcelable接口，方法与Serializable接口类似）

1 Serializable接口 

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。

     只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。 

     简而言之就是可以通过ObjectOutputStream 把调用java.io.Serializable接口的类的对象写入流中，而在流的另一端取出这个对象来。也可以把对象写到文件里，以后再读出来。

 

 实现串行化需要注意的条件：

  1. 输入流写入的类的对象的方法与输出流的类的对象的方法必须名字、类型、修饰符完全一致，方法里面的内容可以不同。 （方法）（保证serialVersionUID一致）

  2. 输入流的对象与输出流的对象字段必须一致，包括修饰符。 （字段）

  3. 输入流的的对象的类与输出流对象的类必须一致，包括名字。 （类）

  4. 不需要写入流的字段用transient修饰。

  5. 串行化不会写入静态变量，成员方法不会被保存。

  总而言之，串行化就是按格式传数据/读数据或写数据/读数据的。

    

如果想自定义数据传输的顺序，在实现Serializable接口的类中重写下面2种方法：

 private void readObject(ObjectInputStream in)
 {

 }
 private void writeObject(ObjectOutputStream out)
 {

 }

上面一个是写的方法，一个是读的方法。

下面是从源码中截取的一段：

    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());
 }
    }

Enum 常量的序列化不同于普通的 serializable 或 externalizable 对象。enum 常量的序列化形式只包含其名称；常量的字段值不被传送。为了序列化 enum 常量，ObjectOutputStream 需要写入由常量的名称方法返回的字符串。与其他 serializable 或 externalizable 对象一样，enum 常量可以作为序列化流中后续出现的 back 引用的目标。用于序列化 enum 常量的进程不可定制；在序列化期间，由 enum 类型定义的所有类特定的 writeObject 和 writeReplace 方法都将被忽略。类似地，任何 serialPersistentFields 或 serialVersionUID 字段声明也将被忽略，所有 enum 类型都有一个 0L 的固定的 serialVersionUID。

2  Externalizable接口

被Serializable接口声明的类的对象的内容都将被序列化，如果现在用户希望自己指定序列化的内容，则可以让一个类实现Externalizable接口，此接口定义如下：

1. public interface Externalizable extends Serializable {  
2.     public void writeExternal(ObjectOutput  out) throws IOException ;  
3.     public void readExternal(ObjectInput in)  throws IOException,  
4. ClassNot FoundException ;  
5. } 

Externalizable接口是Serializable接口的子接口，在此接口中定义了两个方法，这两个方法的作用如下。

writeExternal(ObjectOutput out)：在此方法中指定要保存的属性信息，对象序列化时调用。

readExternal(ObjectInput in)：在此方法中读取被保存的信息，对象反序列化时调用。

这两个方法的参数类型是ObjectOutput和ObjectInput，两个接口的定义如下。

ObjectOutput接口定义：

1. public interface ObjectOutput extends DataOutput 

ObjectInput接口定义：

1. public interface ObjectInput extends DataInput 

可以发现以上两个接口分别继承DataOutput和DataInput，这样在这两个方法中就可以像DataOutputStream和DataInputStream那样直接输出和读取各种类型的数据。

如果一个类要使用Externalizable实现序列化时，在此类中必须存在一个无参构造方法，因为在反序列化时会默认调用无参构造实例化对象，如果没有此无参构造，则运行时将会出现异常，这一点的实现机制与Serializable接口是不同的。

范例：修改Person类并实现Externalizable接口

1. package org.lxh.demo12.serdemo;  
2. import java.io.Externalizable;  
3. import java.io.IOException;  
4. import java.io.ObjectInput;  
5. import java.io.ObjectOutput;  
6. public class Person implements Externalizable  {// 此类的对象可以被序列化  
7.     private String name;                       // 声明name属性  
8.     private int age;                           // 声明age属性  
9.     public Person(){}                         // 必须定义无参构造  
10.     public Person(String name, int age) {     // 通过构造方法设置属性内容  
11.         this.name = name;  
12.         this.age = age;  
13.     }  
14.     public String toString() {                  // 覆写toString()方法  
15.         return "姓名：" + this.name + "；年龄：" + this.age;  
16.     }  
17.     // 覆写此方法，根据需要读取内容，反序列化时使用  
18.     public void readExternal(ObjectInput in)  throws IOException,  
19.             ClassNotFoundException {  
20.         this.name = (String)in.readObject() ;   // 读取姓名属性  
21.         this.age = in.readInt() ;              // 读取年龄  
22.     }  
23.     // 覆写此方法，根据需要可以保存属性或具体内容， 序列化时使用  
24.     public void writeExternal(ObjectOutput out)  throws IOException {  
25.         out.writeObject(this.name) ;          // 保存姓名属性  
26.         out.writeInt(this.age) ;             // 保存年龄属性  
27.     }  
28. } 

以上程序中的Person类实现了Externalizable接口，这样用户就可以在类中有选择地保存需要的属性或者其他的具体数据。在本程序中，为了与之前的程序统一，将全部属性保存下来。

范例：序列化和反序列化Person对象

1. package org.lxh.demo12.serdemo;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.InputStream;  
6. import java.io.ObjectInputStream;  
7. import java.io.ObjectOutputStream;  
8. import java.io.OutputStream;  
9. public class SerDemo03 {  
10.     public static void main(String[] args)  throws Exception {  
11.         ser();                               // 序列化  
12.         dser();                                // 反序列化  
13.     }  
14.     public static void ser() throws Exception  {     // 序列化操作  
15.         File f = new File("D:" + File.separator + "test.txt");  
16.         ObjectOutputStream oos = null;  
17.         OutputStream out = new FileOutputStream(f);  // 文件输出流  
18.         oos = new ObjectOutputStream(out);        // 为对象输出流实例化  
19.         oos.writeObject(new Person("张三", 30));   // 保存对象到文件  
20.         oos.close();                             // 关闭输出  
21.     }  
22.     public static void dser() throws Exception  {        // 反序列化操作  
23.         File f = new File("D:" + File.separator + "test.txt");  
24.         ObjectInputStream ois = null;  
25.         InputStream input = new FileInputStream(f);  // 文件输出流  
26.         ois = new ObjectInputStream(input);          // 为对象输出流实例化  
27.         Object obj = ois.readObject();           // 读取对象  
28.         ois.close();                            // 关闭输出  
29.         System.out.println(obj);  
30.     }  
31. } 

从以上代码中可以发现，使用Externalizable接口实现序列化明显要比使用Serializable接口实现序列化麻烦得多，除此之外，两者的实现还有不同，如表12-27所示。

表12-27  Externalizable接口与Serializable接口实现序列化的区别

序    号	区    别	Serializable	Externalizable
1	实现复杂度	实现简单，Java对其 有内建支持	实现复杂， 由开发人员自己完成
2	执行效率	所有对象由Java统一保存， 性能较低	开发人员决定哪个对象保存， 可能造成速度提升
3	保存信息	保存时占用空间大	部分存储， 可能造成空间减少

在一般的开发中，因为Serializable接口的使用较为方便，所以出现较多