序列化，反序列化和transient關鍵字

一、序列化和反序列化的概念

     序列化：指把java對象轉換為字節序列的過程。

     反序列化：指把字節序列恢復為java對象的過程。

     對象的序列化主要有兩種用途：
　　1） 把對象的字節序列保存到硬盤上，通常存放在一個文件中；
　　2） 在網絡上傳送對象的字節序列。

      1.當兩個進程在進行遠程通信時，彼此可以發送各種類型的數據。無論是何種類型的數據，都會以二進制序列的形式在網絡上傳送。發送方需要把這個Java對象轉換為字節序列，才能在網絡上傳送；接收方則需要把字節序列再恢復為Java對象。

      2.在很多應用中，需要對某些對象進行序列化，讓它們離開內存空間，入住物理硬盤，以便長期保存。比如最常見的是Web服務器中的Session對象，當有 10萬用戶並發訪問，就有可能出現10萬個Session對象，內存可能吃不消，於是Web容器就會把一些seesion先序列化到硬盤中，等要用了，再把保存在硬盤中的對象還原到內存中。

二、JDK類庫中的序列化API

      java.io.ObjectOutputStream代表對象輸出流，它的writeObject(Object obj)方法可對參數指定的obj對象進行序列化，把得到的字節序列寫到一個目標輸出流中。
　　java.io.ObjectInputStream代表對象輸入流，它的readObject()方法從一個源輸入流中讀取字節序列，再把它們反序列化為一個對象，並將其返回。

      只有實現了Serializable接口或Externalizable接口的類的對象才能被序列化。
　　對象序列化包括如下步驟：
　　1） 創建一個對象輸出流，它可以包裝一個其他類型的目標輸出流，如文件輸出流,字節數組輸出流；
　　2） 通過對象輸出流的writeObject()方法寫對象。

　　對象反序列化的步驟如下：
　　1） 創建一個對象輸入流，它可以包裝一個其他類型的源輸入流，如文件輸入流，字節數組輸入流；
　　2） 通過對象輸入流的readObject()方法讀取對象。

     

1、類未實現Serializable接口，進行序列化的范例：

定義一個未實現Serializable的類：User

package com.paic.egis.smts.activity;


public class User{
    private String userId;
    private String userName;
    public String getUserId() {
        return userId;
    }
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + "]";
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    
}

序列化：

package com.paic.egis.smts.activity;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    
    public static void main(String[] args) throws Exception{
        serialize();
        User o = (User) deSerialize();
        System.out.println(o.toString());
        
    }
    
    public static void serialize() throws IOException{
        User u = new User();
        u.setUserId("11");
        u.setUserName("df");
        FileOutputStream fo = new FileOutputStream(new File("d://a.txt"));
        ObjectOutputStream os = new ObjectOutputStream(fo);
        os.writeObject(u);
    }
    
    public static Object deSerialize() throws IOException, ClassNotFoundException {
        FileInputStream fi = new FileInputStream(new File("d://a.txt"));
        ObjectInputStream oi = new ObjectInputStream(fi);
        return oi.readObject();
    }

}

運行結果如下：

運行報錯！

2、類實現Serializable接口，進行序列化和反序列化的范例：

定義一個實現Serializable的類：UserSerialize

package com.paic.egis.smts.activity;

import java.io.Serializable;

public class UserSerialize implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String userId;
    private String userName;
    public String getUserId() {
        return userId;
    }
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + "]";
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    
}

序列化和反序列化：

package com.paic.egis.smts.activity;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    
    public static void main(String[] args) throws Exception{
        serialize();
        UserSerialize o = (UserSerialize) deSerialize();
        System.out.println(o.toString());
        
    }
    
    public static void serialize() throws IOException{
        UserSerialize u = new UserSerialize();
        u.setUserId("11");
        u.setUserName("df");
        FileOutputStream fo = new FileOutputStream(new File("d://a.txt"));
        ObjectOutputStream os = new ObjectOutputStream(fo);
        os.writeObject(u);
    }
    
    public static Object deSerialize() throws IOException, ClassNotFoundException {
        FileInputStream fi = new FileInputStream(new File("d://a.txt"));
        ObjectInputStream oi = new ObjectInputStream(fi);
        return oi.readObject();
    }

}

運行結果如下：

三、serialVersionUID的作用

      serialVersionUID作用：序列化時為了保持版本的兼容性，即在版本升級時反序列化仍保持對象的唯一性。

有兩種生成方式：

       一個是默認的1L，比如：private static final long serialVersionUID = 1L;

       一個是根據類名、接口名、成員方法及屬性等來生成一個64位的哈希字段，比如：private static final long  serialVersionUID = xxxxL;

下面舉例說明下：

還是上面說到的類：UserSerialize，把定義的serialVersionUID去掉。

package com.paic.egis.smts.activity;

import java.io.Serializable;

public class UserSerialize implements Serializable{
//    /**
//     * 
//     */
//    private static final long serialVersionUID = 1L;
    private String userId;
    private String userName;
    public String getUserId() {
        return userId;
    }
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + "]";
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    
}

序列化和反序列化：

package com.paic.egis.smts.activity;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    
    public static void main(String[] args) throws Exception{
        serialize();
        UserSerialize o = (UserSerialize) deSerialize();
        System.out.println(o.toString());
        
    }
    
    public static void serialize() throws IOException{
        UserSerialize u = new UserSerialize();
        u.setUserId("11");
        u.setUserName("df");
        FileOutputStream fo = new FileOutputStream(new File("d://a.txt"));
        ObjectOutputStream os = new ObjectOutputStream(fo);
        os.writeObject(u);
    }
    
    public static Object deSerialize() throws IOException, ClassNotFoundException {
        FileInputStream fi = new FileInputStream(new File("d://a.txt"));
        ObjectInputStream oi = new ObjectInputStream(fi);
        return oi.readObject();
    }

}

運行結果：

是成功的。

下面我們修改下UserSerialize類：添加一個熟悉sex

package com.paic.egis.smts.activity;

import java.io.Serializable;

public class UserSerialize implements Serializable{
//    /**
//     * 
//     */
//    private static final long serialVersionUID = 1L;
    private String userId;
    private String userName;
    
    private String sex;
    
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getUserId() {
        return userId;
    }
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + "]";
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    
}

這時執行反序列化操作：

package com.paic.egis.smts.activity;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    
    public static void main(String[] args) throws Exception{
//        serialize();
        UserSerialize o = (UserSerialize) deSerialize();
        System.out.println(o.toString());
        
    }
    
    public static void serialize() throws IOException{
        UserSerialize u = new UserSerialize();
        u.setUserId("11");
        u.setUserName("df");
        FileOutputStream fo = new FileOutputStream(new File("d://a.txt"));
        ObjectOutputStream os = new ObjectOutputStream(fo);
        os.writeObject(u);
    }
    
    public static Object deSerialize() throws IOException, ClassNotFoundException {
        FileInputStream fi = new FileInputStream(new File("d://a.txt"));
        ObjectInputStream oi = new ObjectInputStream(fi);
        return oi.readObject();
    }

}

運行結果：

Exception in thread "main" java.io.InvalidClassException: com.paic.egis.smts.activity.UserSerialize; local class incompatible: stream classdesc serialVersionUID = -3074015237131537750, local class serialVersionUID = -126714174808369076
at java.io.ObjectStreamClass.initNonProxy(Unknown Source)
at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source)
at java.io.ObjectInputStream.readClassDesc(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.readObject(Unknown Source)
at com.paic.egis.smts.activity.Test.deSerialize(Test.java:31)
at com.paic.egis.smts.activity.Test.main(Test.java:14)

      意思就是說，文件流中的class和classpath中的class，也就是修改過后的class，不兼容了，處於安全機制考慮，程序拋出了錯誤，並且拒絕載入。那么如果我們真的有需求要在序列化后添加一個字段或者方法呢？應該怎么辦？那就是自己去指定serialVersionUID

      因此強烈建議在一個可序列化類中顯示的定義serialVersionUID，為它賦予明確的值。

四、transient關鍵字的作用

        在實際開發過程中，我們常常會遇到這樣的問題，這個類的有些屬性需要序列化，而其他屬性不需要被序列化，打個比方，如果一個用戶有一些敏感信息（如密碼，銀行卡號等），為了安全起見，不希望在網絡操作（主要涉及到序列化操作，本地序列化緩存也適用）中被傳輸，這些信息對應的變量就可以加上transient關鍵字。換句話說，這個字段的生命周期僅存於調用者的內存中而不會寫到磁盤里持久化。

       java 的transient關鍵字為我們提供了便利，你只需要實現Serilizable接口，將不需要序列化的屬性前添加關鍵字transient，序列化對象的時候，這個屬性就不會序列化到指定的目的地中。

范例如下：

UserSerialize類：

package com.paic.egis.smts.activity;

import java.io.Serializable;

public class UserSerialize implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String userId;
    private String userName;
    
    private transient String sex;
    
    
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    @Override
    public String toString() {
        return "UserSerialize [userId=" + userId + ", userName=" + userName
                + ", sex=" + sex + "]";
    }
    
}

執行序列化和反序列化

package com.paic.egis.smts.activity;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    
    public static void main(String[] args) throws Exception{
        serialize();
        UserSerialize o = (UserSerialize) deSerialize();
        System.out.println(o.toString());
        
    }
    
    public static void serialize() throws IOException{
        UserSerialize u = new UserSerialize();
        u.setUserId("111");
        u.setUserName("df");
        u.setSex("y");
        FileOutputStream fo = new FileOutputStream(new File("d://a.txt"));
        ObjectOutputStream os = new ObjectOutputStream(fo);
        os.writeObject(u);
    }
    
    public static Object deSerialize() throws IOException, ClassNotFoundException {
        FileInputStream fi = new FileInputStream(new File("d://a.txt"));
        ObjectInputStream oi = new ObjectInputStream(fi);
        return oi.readObject();
    }

}

結果如下：

set字段為null，說明反序列化時根本沒有從文件中獲取到信息

另靜態變量不管是否被transient修飾，均不能被序列化

范例：

UserSerialize類：

package com.paic.egis.smts.activity;

import java.io.Serializable;

public class UserSerialize implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String userId;
    private String userName;
    
    private static String sex;
    
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    @Override
    public String toString() {
        return "UserSerialize [userId=" + userId + ", userName=" + userName
                + ", sex=" + sex + "]";
    }
    
}

反序列化:

package com.paic.egis.smts.activity;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import com.paic.pafa.exceptions.BusinessException;

public class Test {
    
    public static void main(String[] args) throws Exception{
//        serialize();
        UserSerialize o = (UserSerialize) deSerialize();
        System.out.println(o.toString());
    }
    
    public static void serialize() throws IOException{
        UserSerialize u = new UserSerialize();
        u.setUserId("111");
        u.setUserName("df");
        u.setSex("yy");
        FileOutputStream fo = new FileOutputStream(new File("d://a.txt"));
        ObjectOutputStream os = new ObjectOutputStream(fo);
        os.writeObject(u);
    }
    
    public static Object deSerialize() throws IOException, ClassNotFoundException {
        FileInputStream fi = new FileInputStream(new File("d://a.txt"));
        ObjectInputStream oi = new ObjectInputStream(fi);
        return oi.readObject();
    }

}

執行反序列化之前已執行過serialize()序列化操作。

執行結果如下：

若同時執行序列化和反序列化，代碼如下：

package com.paic.egis.smts.activity;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    
    public static void main(String[] args) throws Exception{
        serialize();
        UserSerialize o = (UserSerialize) deSerialize();
        System.out.println(o.toString());
    }
    
    public static void serialize() throws IOException{
        UserSerialize u = new UserSerialize();
        u.setUserId("111");
        u.setUserName("df");
        u.setSex("yy");
        FileOutputStream fo = new FileOutputStream(new File("d://a.txt"));
        ObjectOutputStream os = new ObjectOutputStream(fo);
        os.writeObject(u);
    }
    
    public static Object deSerialize() throws IOException, ClassNotFoundException {
        FileInputStream fi = new FileInputStream(new File("d://a.txt"));
        ObjectInputStream oi = new ObjectInputStream(fi);
        return oi.readObject();
    }

}

執行結果如下：

可能會比較奇怪為什么sex有值，這時因為這個值並不是從文件中反序列化讀出來的，是從當前JVM中對應static變量的值。

五、Externalizable接口的作用

      它是Serializable接口的子類，有時我們不希望序列化那么多，可以使用這個接口，這個接口的writeExternal()和readExternal()方法可以指定序列化哪些屬性;

范例如下：

UserSerialize類：

package com.paic.egis.smts.activity;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class UserSerialize implements Externalizable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String userId;
    private String userName;
    
    private String sex;
    
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    @Override
    public String toString() {
        return "UserSerialize [userId=" + userId + ", userName=" + userName
                + ", sex=" + sex + "]";
    }
    @Override
    public void writeExternal(ObjectOutput objectoutput) throws IOException {
        objectoutput.writeObject(userId);
        
    }
    @Override
    public void readExternal(ObjectInput objectinput) throws IOException,
            ClassNotFoundException {
        userId = (String) objectinput.readObject();
        
    }
    
}

序列化和反序列化：

package com.paic.egis.smts.activity;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    
    public static void main(String[] args) throws Exception{
        serialize();
        UserSerialize o = (UserSerialize) deSerialize();
        System.out.println(o.toString());
    }
    
    public static void serialize() throws IOException{
        UserSerialize u = new UserSerialize();
        u.setUserId("111");
        u.setUserName("df");
        u.setSex("yy");
        FileOutputStream fo = new FileOutputStream(new File("d://a.txt"));
        ObjectOutputStream os = new ObjectOutputStream(fo);
        os.writeObject(u);
    }
    
    public static Object deSerialize() throws IOException, ClassNotFoundException {
        FileInputStream fi = new FileInputStream(new File("d://a.txt"));
        ObjectInputStream oi = new ObjectInputStream(fi);
        return oi.readObject();
    }

}

執行結果如下：