Serializable接口和transient关键字

1. 什么是Serializable接口？

当一个类实现了Serializable接口（该接口仅为标记接口，不包含任何方法），表示该类可以被序列化。

序列化的目的是将一个实现了Serializable接口的对象转换成一个字节序列， 可以将该字节序列保存起来（如：保存在一个文件中），以后可以随时将该字节序列恢复为原来的对象。甚至可以将该字节序列放到其他计算机上或者通过网络传输到其他计算机上恢复，只要该计算机平台存在相应的类。

2. 如何实现？

首先创建一个OutputStream对象，然后将其封装在一个ObjectOutputStream对象内，再调用writeObject()方法即可序列化一个对象。反序列化也类似。

 import java.io.*; 

 public class Person implements Serializable {
     private String userName;
     private String password; 

     public Person(String userName, String password) {
         this.userName = userName;
         this.password = password;
     } 

     public String toString() {
         return "userName:" + userName + "  password:" + password;
     } 

     public static void main(String[] args)
         throws FileNotFoundException, IOException,    ClassNotFoundException { 

     //序列化一个对象(存储到一个文件)
     ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.out"));
     oos.writeObject("Save a object:\n");
     oos.writeObject(new Person("Bruce", "123456"));
     oos.close(); 

     //反序列化,将该对象恢复(存储到一个文件)
     ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.out"));
     String s = (String)ois.readObject();
     Person p = (Person)ois.readObject();
     System.out.println(s + p); 

     //序列化一个对象(存储到字节数组)
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
     ObjectOutputStream oos2 = new ObjectOutputStream(baos);
     oos2.writeObject("Save another object:\n");
     oos2.writeObject(new Person("Phil", "654321"));
     oos2.close(); 

     //反序列化,将该对象恢复(存储到字节数组)
     ObjectInputStream ois2 = new ObjectInputStream(new     ByteArrayInputStream(baos.toByteArray()));
     s = (String)ois2.readObject();
     p = (Person)ois2.readObject();
     System.out.println(s + p);
     }
 }
             

输出信息：

Save a object:
userName:Bruce  password:123456
Save another object:
userName:Phil  password:654321 

3. transient关键字：

1）引入原因：自动序列化将对象所有的字段都持久化了，有的时候需要对某些字段不进行持久化（例如：密码，因为序列化后会暴露密码），所以我们使用transient关键字让Serializable对象某些字段不被序列化。

2）操作：

public class Person implements Serializable{
    private String userName;

    // 不序列化password——因为序列化后会暴露密码
    private transient String password;
}

加入transient关键字后，上面程序的运行结果：

Save a object:
userName:Bruce  password:null
Save another object:
userName:Phil  password:null 

3）如果想要控制序列化字段，使得被transient修饰的字段也能被序列化：有两种方法

1. 手动序列化，添加两个私有的方法：writeObject()，readObject()

 import java.io.*; 

 public class Person implements Serializable {
     private String userName;
     private transient String password; 

     public Person(String userName, String password) {
         this.userName = userName;
         this.password = password;
     } 

     public String toString() {
         return "userName:" + userName + "  password:" + password;
     } 

     private void writeObject(ObjectOutputStream out) throws IOException {
     //序列化所有非transient字段,必须是该方法的第一个操作
     out.defaultWriteObject();  

     //序列化transient字段
     out.writeObject(password);
     } 

     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
      //反序列化所有非transient字段,必须是该方法的第一个操作
     in.defaultReadObject();

      //反序列化transient字段
     password = (String)in.readObject();
     } 

     public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
     //序列化一个对象(存储到一个文件)
     ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.out"));
     oos.writeObject("Save a object:\n");
     oos.writeObject(new Person("Bruce", "123456"));
     oos.close(); 

     //反序列化,将该对象恢复(存储到一个文件)
     ObjectInputStream ois = new ObjectInputStream(new         FileInputStream("person.out"));
     String s = (String)ois.readObject();
     Person p = (Person)ois.readObject();
     System.out.println(s + p);
     }
 } 

输出结果：

Save a object:
userName:David  password:13579 

2. 使用Externalizable接口替代Serializable接口。

• 此时需要定义一个默认的构造器，否则将会得到一个异常：(java.io.InvalidClassException: Person; Person; no valid constructor)；
• 还需要定义两个方法(writeExternal()和readExternal())来控制要序列化的字段

 import java.io.*; 

 //使用Externalizable接口代替Serializable接口
 public class Person implements Externalizable {
     private String userName;
     private String password; 

     // 需要一个默认的构造器，否则得到一个异常
     public Person() {
         System.out.println("default constructor invoked!");
     } 

     public Person(String userName, String password) {
         this.userName = userName;
         this.password = password;
     } 

     public String toString() {
         return "userName:" + userName + "  password:" + password;
     } 

     public void writeExternal(ObjectOutput out) throws IOException {
     //序列化字段
     out.writeObject(userName);
     out.writeObject(password);
     } 

     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
     //反序列化字段
     userName = (String)in.readObject();
     password = (String)in.readObject();
     } 

     public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
 /    /序列化一个对象(存储到一个文件)
     ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.out"));
     oos.writeObject("Save a object:\n");
     oos.writeObject(new Person("Leo", "1984"));
     oos.close(); 

     //反序列化,将该对象恢复(存储到一个文件)
     ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.out"));
     String s = (String)ois.readObject();
     Person p = (Person)ois.readObject();
     System.out.println(s + p);
     }
 }
     

得到结果如下：

default constructor invoked!
Save a object:
userName:Leo  password:1984 

注意：

以上方式只能恢复成Java对象，如果想要恢复成其他对象(如C++对象)，那就要将Java对象转换为XML格式，这样可以使其被各种平台和各种语言使用。可以使用随JDK一起发布的javax.xam.*类库，或者使用开源XOM类库(可以从www.xom.nu下载并获得文档)。