java io系列06之 序列化總結(Serializable 和 Externalizable)

 

本章，我們對序列化進行深入的學習和探討。學習內容，包括序列化的作用、用途、用法，以及對實現序列化的2種方式Serializable和Externalizable的深入研究。

轉載請注明出處：http://www.cnblogs.com/skywang12345/p/io_06.html

1. 序列化是的作用和用途

序列化，就是為了保存對象的狀態；而與之對應的反序列化，則可以把保存的對象狀態再讀出來。
簡言之：序列化/反序列化，是Java提供一種專門用於的保存/恢復對象狀態的機制。

一般在以下幾種情況下，我們可能會用到序列化：
a）當你想把的內存中的對象狀態保存到一個文件中或者數據庫中時候；
b）當你想用套接字在網絡上傳送對象的時候；
c）當你想通過RMI傳輸對象的時候。

2. 演示程序1

下面，我們先通過一則簡單示例來查看序列化的用法。

源碼如下(SerialTest1.java)： 

/**
 * 序列化的演示測試程序
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.Serializable;   
  
public class SerialTest1 { 
    private static final String TMP_FILE = ".serialtest1.txt";
  
    public static void main(String[] args) {   
        // 將“對象”通過序列化保存
        testWrite();
        // 將序列化的“對象”讀出來
        testRead();
    }
  

    /**
     * 將Box對象通過序列化，保存到文件中
     */
    private static void testWrite() {   
        try {
            // 獲取文件TMP_FILE對應的對象輸出流。
            // ObjectOutputStream中，只能寫入“基本數據”或“支持序列化的對象”
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            // 創建Box對象，Box實現了Serializable序列化接口
            Box box = new Box("desk", 80, 48);
            // 將box對象寫入到對象輸出流out中，即相當於將對象保存到文件TMP_FILE中
            out.writeObject(box);
            // 打印“Box對象”
            System.out.println("testWrite box: " + box);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * 從文件中讀取出“序列化的Box對象”
     */
    private static void testRead() {
        try {
            // 獲取文件TMP_FILE對應的對象輸入流。
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            // 從對象輸入流中，讀取先前保存的box對象。
            Box box = (Box) in.readObject();
            // 打印“Box對象”
            System.out.println("testRead  box: " + box);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * Box類“支持序列化”。因為Box實現了Serializable接口。
 *
 * 實際上，一個類只需要實現Serializable即可實現序列化，而不需要實現任何函數。
 */
class Box implements Serializable {
    private int width;   
    private int height; 
    private String name;   

    public Box(String name, int width, int height) {
        this.name = name;
        this.width = width;
        this.height = height;
    }

    @Override
    public String toString() {
        return "["+name+": ("+width+", "+height+") ]";
    }
}

運行結果：

testWrite box: [desk: (80, 48) ]
testRead box: [desk: (80, 48) ]

源碼說明：

(01) 程序的作用很簡單，就是演示：先將Box對象，通過對象輸出流保存到文件中；之后，再通過對象輸入流，將文件中保存的Box對象讀取出來。

(02) Box類說明。Box是我們自定義的演示類，它被用於序列化的讀寫。Box實現了Serialable接口，因此它支持序列化操作；即，Box支持通過ObjectOutputStream去寫入到輸出流中，並且支持通過ObjectInputStream從輸入流中讀取出來。

(03) testWrite()函數說明。testWrite()的作用就是，新建一個Box對象，然后將該Box對象寫入到文件中。
       首先，新建文件TMP_FILE的文件輸出流對象(即FileOutputStream對象)，再創建該文件輸出流的對象輸出流(即ObjectOutputStream對象)。
       a) 關於FileInputStream和FileOutputStream的內容，可以參考“java io系列07之 FileInputStream和FileOutputStream”。
       b) 關於ObjectInputStream和ObjectOutputStream的的更多知識，可以參考“java io系列05之 ObjectInputStream 和 ObjectOutputStream”
       然后，新建Box對象。
       最后，通過out.writeObject(box) 將box寫入到對象輸出流中。實際上，相當於將box寫入到文件TMP_FILE中。

(04) testRead()函數說明。testRead()的作用就是，從文件中讀出Box對象。
       首先，新建文件TMP_FILE的文件輸入流對象(即FileInputStream對象)，再創建該文件輸入流的對象輸入流(即ObjectInputStream對象)。
       然后，通過in.readObject() 從對象輸入流中讀取出Box對象。實際上，相當於從文件TMP_FILE中讀取Box對象。

通過上面的示例，我們知道：我們可以自定義類，讓它支持序列化(即實現Serializable接口)，從而能支持對象的保存/恢復。
若要支持序列化，除了“自定義實現Serializable接口的類”之外；java的“基本類型”和“java自帶的實現了Serializable接口的類”，都支持序列化。我們通過下面的示例去查看一下。

3. 演示程序2

源碼如下(SerialTest2.java)：

/**
 * “基本類型” 和 “java自帶的實現Serializable接口的類” 對序列化的支持
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.Serializable;   
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
  
public class SerialTest2 { 
    private static final String TMP_FILE = ".serialabletest2.txt";
  
    public static void main(String[] args) {   
        testWrite();
        testRead();
    }
  
    /**
     * ObjectOutputStream 測試函數
     */
    private static void testWrite() {   
        try {
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            out.writeBoolean(true);    // 寫入Boolean值
            out.writeByte((byte)65);// 寫入Byte值
            out.writeChar('a');     // 寫入Char值
            out.writeInt(20131015); // 寫入Int值
            out.writeFloat(3.14F);  // 寫入Float值
            out.writeDouble(1.414D);// 寫入Double值
            // 寫入HashMap對象
            HashMap map = new HashMap();
            map.put("one", "red");
            map.put("two", "green");
            map.put("three", "blue");
            out.writeObject(map);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * ObjectInputStream 測試函數
     */
    private static void testRead() {
        try {
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            System.out.printf("boolean:%b\n" , in.readBoolean());
            System.out.printf("byte:%d\n" , (in.readByte()&0xff));
            System.out.printf("char:%c\n" , in.readChar());
            System.out.printf("int:%d\n" , in.readInt());
            System.out.printf("float:%f\n" , in.readFloat());
            System.out.printf("double:%f\n" , in.readDouble());
            // 讀取HashMap對象
            HashMap map = (HashMap) in.readObject();
            Iterator iter = map.entrySet().iterator();
            while (iter.hasNext()) {
                Map.Entry entry = (Map.Entry)iter.next();
                System.out.printf("%-6s -- %s\n" , entry.getKey(), entry.getValue());
            }

            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

運行結果：

boolean:true
byte:65
char:a
int:20131015
float:3.140000
double:1.414000
two    -- green
one    -- red
three  -- blue

源碼說明：

(01) 程序的作用很簡單，就是演示：先將“基本類型數據”和“HashMap對象”，通過對象輸出流保存到文件中；之后，再通過對象輸入流，將這些保存的數據讀取出來。

(02) testWrite()函數說明。testWrite()的作用就是，先將“基本類型數據”和“HashMap對象”，通過對象輸出流保存到文件中。
       首先，新建文件TMP_FILE的文件輸出流對象(即FileOutputStream對象)，再創建該文件輸出流的對象輸出流(即ObjectOutputStream對象)。
       然后，通過 writeBoolean(), writeByte(), ... , writeDouble() 等一系列函數將“Boolean, byte, char, ... , double等基本數據類型”寫入到對象輸出流中。實際上，相當於將這些內容寫入到文件TMP_FILE中。
      最后，新建HashMap對象map，並通過out.writeObject(map) 將map寫入到對象輸出流中。實際上，相當於map寫入到文件TMP_FILE中。
關於HashMap的更多知識，可以參考“Java 集合系列10之 HashMap詳細介紹(源碼解析)和使用示例”。

(03) testRead()函數說明。testRead()的作用就是，從文件中讀出testWrite()寫入的對象。
       首先，新建文件TMP_FILE的文件輸入流對象(即FileInputStream對象)，再創建該文件輸入流的對象輸入流(即ObjectInputStream對象)。
       然后，通過in.readObject() 從對象輸入流中讀取出testWrite()對象。實際上，相當於從文件TMP_FILE中讀取出這些對象。

在前面，我們提到過：若要支持序列化，除了“自定義實現Serializable接口的類”之外；java的“基本類型”和“java自帶的實現了Serializable接口的類”，都支持序列化。為了驗證這句話，我們看看HashMap是否實現了Serializable接口。
HashMap是java.util包中定義的類，它的接口聲明如下：

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {} 

至此，我們對序列化的認識已經比較深入了：即知道了“序列化的作用和用法”，也知道了“基本類型”、“java自帶的支持Serializable接口的類”和“自定義實現Serializable接口的類”都能支持序列化。
應付序列化的簡單使用應該足夠了。但是，我們的目的是對序列化有更深層次的了解！更何況，寫此文的作者(也就是區區在下)，應該比各位看官要累(既要寫代碼，又要總結，還得注意排版和用詞，講的通俗易懂，讓各位看得輕松自在)；我這個菜鳥都能做到這些，何況對知識極其渴望的您呢？所以，請深吸一口氣，然后繼續……

我們在介紹序列化定義時，說過“序列化/反序列化，是專門用於的保存/恢復對象狀態的機制”。
從中，我們知道：序列化/反序列化，只支持保存/恢復對象狀態，即僅支持保存/恢復類的成員變量，但不支持保存類的成員方法！
但是，序列化是不是對類的所有的成員變量的狀態都能保存呢？
答案當然是否定的！
(01) 序列化對static和transient變量，是不會自動進行狀態保存的。
        transient的作用就是，用transient聲明的變量，不會被自動序列化。
(02) 對於Socket, Thread類，不支持序列化。若實現序列化的接口中，有Thread成員；在對該類進行序列化操作時，編譯會出錯！
        這主要是基於資源分配方面的原因。如果Socket，Thread類可以被序列化，但是被反序列化之后也無法對他們進行重新的資源分配；再者，也是沒有必要這樣實現。

下面，我們還是通過示例來查看“序列化對static和transient的處理”。

4. 演示程序3

我們對前面的SerialTest1.java進行簡單修改，得到源文件(SerialTest3.java)如下：

/**
 * 序列化的演示測試程序
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.Serializable;   
  
public class SerialTest3 { 
    private static final String TMP_FILE = ".serialtest3.txt";
  
    public static void main(String[] args) {   
        // 將“對象”通過序列化保存
        testWrite();
        // 將序列化的“對象”讀出來
        testRead();
    }
  

    /**
     * 將Box對象通過序列化，保存到文件中
     */
    private static void testWrite() {   
        try {
            // 獲取文件TMP_FILE對應的對象輸出流。
            // ObjectOutputStream中，只能寫入“基本數據”或“支持序列化的對象”
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            // 創建Box對象，Box實現了Serializable序列化接口
            Box box = new Box("desk", 80, 48);
            // 將box對象寫入到對象輸出流out中，即相當於將對象保存到文件TMP_FILE中
            out.writeObject(box);
            // 打印“Box對象”
            System.out.println("testWrite box: " + box);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * 從文件中讀取出“序列化的Box對象”
     */
    private static void testRead() {
        try {
            // 獲取文件TMP_FILE對應的對象輸入流。
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            // 從對象輸入流中，讀取先前保存的box對象。
            Box box = (Box) in.readObject();
            // 打印“Box對象”
            System.out.println("testRead  box: " + box);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * Box類“支持序列化”。因為Box實現了Serializable接口。
 *
 * 實際上，一個類只需要實現Serializable即可實現序列化，而不需要實現任何函數。
 */
class Box implements Serializable {
    private static int width;   
    private transient int height; 
    private String name;   

    public Box(String name, int width, int height) {
        this.name = name;
        this.width = width;
        this.height = height;
    }

    @Override
    public String toString() {
        return "["+name+": ("+width+", "+height+") ]";
    }
}

SerialTest3.java 相比於 SerialTest1.java。僅僅對Box類中的 width 和 height 變量的定義進行了修改。
SerialTest1.java 中width和height定義

private int width;   
private int height; 

SerialTest3.java 中width和height定義

private static int width; 
private transient int height; 

在看后面的結果之前，我們建議大家對程序進行分析，先自己得出一個結論。

運行結果：

testWrite box: [desk: (80, 48) ]
testRead  box: [desk: (80, 0) ] 

結果分析：

我們前面說過，“序列化不對static和transient變量進行狀態保存”。因此，testWrite()中保存Box對象時，不會保存width和height的值。這點是毋庸置疑的！但是，為什么testRead()中讀取出來的Box對象的width=80，而height=0呢？
先說，為什么height=0。因為Box對象中height是int類型，而int類型的默認值是0。
再說，為什么width=80。這是因為height是static類型，而static類型就意味着所有的Box對象都共用一個height值；而在testWrite()中，我們已經將height初始化為80了。因此，我們通過序列化讀取出來的Box對象的height值，也被就是80。

理解上面的內容之后，我們應該可以推斷出下面的代碼的運行結果。

源碼如下(SerialTest4.java)： 

/**
 * 序列化的演示測試程序
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.Serializable;   
  
public class SerialTest4 { 
    private static final String TMP_FILE = ".serialtest4.txt";
  
    public static void main(String[] args) {   
        // 將“對象”通過序列化保存
        testWrite();
        // 將序列化的“對象”讀出來
        testRead();
    }
  

    /**
     * 將Box對象通過序列化，保存到文件中
     */
    private static void testWrite() {   
        try {
            // 獲取文件TMP_FILE對應的對象輸出流。
            // ObjectOutputStream中，只能寫入“基本數據”或“支持序列化的對象”
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            // 創建Box對象，Box實現了Serializable序列化接口
            Box box = new Box("desk", 80, 48);
            // 將box對象寫入到對象輸出流out中，即相當於將對象保存到文件TMP_FILE中
            out.writeObject(box);
            // 打印“Box對象”
            System.out.println("testWrite box: " + box);
            // 修改box的值
            box = new Box("room", 100, 50);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * 從文件中讀取出“序列化的Box對象”
     */
    private static void testRead() {
        try {
            // 獲取文件TMP_FILE對應的對象輸入流。
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            // 從對象輸入流中，讀取先前保存的box對象。
            Box box = (Box) in.readObject();
            // 打印“Box對象”
            System.out.println("testRead  box: " + box);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * Box類“支持序列化”。因為Box實現了Serializable接口。
 *
 * 實際上，一個類只需要實現Serializable即可實現序列化，而不需要實現任何函數。
 */
class Box implements Serializable {
    private static int width;   
    private transient int height; 
    private String name;   

    public Box(String name, int width, int height) {
        this.name = name;
        this.width = width;
        this.height = height;
    }

    @Override
    public String toString() {
        return "["+name+": ("+width+", "+height+") ]";
    }
}

SerialTest4.java 相比於 SerialTest3.java，在testWrite()中添加了一行代碼box = new Box("room", 100, 50);

運行結果：

testWrite box: [desk: (80, 48) ]
testRead  box: [desk: (100, 0) ]

現在，我們更加確認“序列化不對static和transient變量進行狀態保存”。但是，若我們想要保存static或transient變量，能不能辦到呢？
當然可以！我們在類中重寫兩個方法writeObject()和readObject()即可。下面程序演示了如何手動保存static和transient變量。

5. 演示程序4

我們對前面的SerialTest4.java進行簡單修改，以達到：序列化存儲static和transient變量的目的。

源碼如下(SerialTest5.java)： 

/**
 * 序列化的演示測試程序
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.Serializable;   
import java.io.IOException;   
import java.lang.ClassNotFoundException;   
  
public class SerialTest5 { 
    private static final String TMP_FILE = ".serialtest5.txt";
  
    public static void main(String[] args) {   
        // 將“對象”通過序列化保存
        testWrite();
        // 將序列化的“對象”讀出來
        testRead();
    }
  

    /**
     * 將Box對象通過序列化，保存到文件中
     */
    private static void testWrite() {   
        try {
            // 獲取文件TMP_FILE對應的對象輸出流。
            // ObjectOutputStream中，只能寫入“基本數據”或“支持序列化的對象”
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            // 創建Box對象，Box實現了Serializable序列化接口
            Box box = new Box("desk", 80, 48);
            // 將box對象寫入到對象輸出流out中，即相當於將對象保存到文件TMP_FILE中
            out.writeObject(box);
            // 打印“Box對象”
            System.out.println("testWrite box: " + box);
            // 修改box的值
            box = new Box("room", 100, 50);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * 從文件中讀取出“序列化的Box對象”
     */
    private static void testRead() {
        try {
            // 獲取文件TMP_FILE對應的對象輸入流。
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            // 從對象輸入流中，讀取先前保存的box對象。
            Box box = (Box) in.readObject();
            // 打印“Box對象”
            System.out.println("testRead  box: " + box);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * Box類“支持序列化”。因為Box實現了Serializable接口。
 *
 * 實際上，一個類只需要實現Serializable即可實現序列化，而不需要實現任何函數。
 */
class Box implements Serializable {
    private static int width;   
    private transient int height; 
    private String name;   

    public Box(String name, int width, int height) {
        this.name = name;
        this.width = width;
        this.height = height;
    }

    private void writeObject(ObjectOutputStream out) throws IOException{ 
        out.defaultWriteObject();//使定制的writeObject()方法可以利用自動序列化中內置的邏輯。 
        out.writeInt(height); 
        out.writeInt(width); 
        //System.out.println("Box--writeObject width="+width+", height="+height);
    }

    private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{ 
        in.defaultReadObject();//defaultReadObject()補充自動序列化 
        height = in.readInt(); 
        width = in.readInt(); 
        //System.out.println("Box---readObject width="+width+", height="+height);
    }

    @Override
    public String toString() {
        return "["+name+": ("+width+", "+height+") ]";
    }
}

運行結果：

testWrite box: [desk: (80, 48) ]
testRead  box: [desk: (80, 48) ]

程序說明：

“序列化不會自動保存static和transient變量”，因此我們若要保存它們，則需要通過writeObject()和readObject()去手動讀寫。
(01) 通過writeObject()方法，寫入要保存的變量。writeObject的原始定義是在ObjectOutputStream.java中，我們按照如下示例覆蓋即可：

private void writeObject(ObjectOutputStream out) throws IOException{ 
    out.defaultWriteObject();// 使定制的writeObject()方法可以利用自動序列化中內置的邏輯。 
    out.writeInt(ival);      // 若要保存“int類型的值”，則使用writeInt()
    out.writeObject(obj);    // 若要保存“Object對象”，則使用writeObject()
}

(02) 通過readObject()方法，讀取之前保存的變量。readObject的原始定義是在ObjectInputStream.java中，我們按照如下示例覆蓋即可：

private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{ 
    in.defaultReadObject();       // 使定制的readObject()方法可以利用自動序列化中內置的邏輯。 
    int ival = in.readInt();      // 若要讀取“int類型的值”，則使用readInt()
    Object obj = in.readObject(); // 若要讀取“Object對象”，則使用readObject()
}

至此，我們就介紹完了“序列化對static和transient變量的處理”。
接下來，我們來研究“對於Socket, Thread類，不支持序列化”。還是通過示例來查看。

6. 演示程序5

我們修改SerialTest5.java的源碼，在Box類中添加一個Thread成員。

源碼如下(SerialTest6.java)：

/**
 * 序列化的演示測試程序
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.Serializable;   
import java.lang.Thread;
import java.io.IOException;   
import java.lang.ClassNotFoundException;   
  
public class SerialTest6 { 
    private static final String TMP_FILE = ".serialtest6.txt";
  
    public static void main(String[] args) {   
        // 將“對象”通過序列化保存
        testWrite();
        // 將序列化的“對象”讀出來
        testRead();
    }
  

    /**
     * 將Box對象通過序列化，保存到文件中
     */
    private static void testWrite() {   
        try {
            // 獲取文件TMP_FILE對應的對象輸出流。
            // ObjectOutputStream中，只能寫入“基本數據”或“支持序列化的對象”
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            // 創建Box對象，Box實現了Serializable序列化接口
            Box box = new Box("desk", 80, 48);
            // 將box對象寫入到對象輸出流out中，即相當於將對象保存到文件TMP_FILE中
            out.writeObject(box);
            // 打印“Box對象”
            System.out.println("testWrite box: " + box);
            // 修改box的值
            box = new Box("room", 100, 50);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * 從文件中讀取出“序列化的Box對象”
     */
    private static void testRead() {
        try {
            // 獲取文件TMP_FILE對應的對象輸入流。
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            // 從對象輸入流中，讀取先前保存的box對象。
            Box box = (Box) in.readObject();
            // 打印“Box對象”
            System.out.println("testRead  box: " + box);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * Box類“支持序列化”。因為Box實現了Serializable接口。
 *
 * 實際上，一個類只需要實現Serializable即可實現序列化，而不需要實現任何函數。
 */
class Box implements Serializable {
    private static int width;   
    private transient int height; 
    private String name;   
    private Thread thread = new Thread() {
        @Override
        public void run() {
            System.out.println("Serializable thread");
        }
    };

    public Box(String name, int width, int height) {
        this.name = name;
        this.width = width;
        this.height = height;
    }

    private void writeObject(ObjectOutputStream out) throws IOException{ 
        out.defaultWriteObject();//使定制的writeObject()方法可以利用自動序列化中內置的邏輯。 
        out.writeInt(height); 
        out.writeInt(width); 
        //System.out.println("Box--writeObject width="+width+", height="+height);
    }

    private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{ 
        in.defaultReadObject();//defaultReadObject()補充自動序列化 
        height = in.readInt(); 
        width = in.readInt(); 
        //System.out.println("Box---readObject width="+width+", height="+height);
    }

    @Override
    public String toString() {
        return "["+name+": ("+width+", "+height+") ]";
    }
}

結果是，編譯出錯！
事實證明，不能對Thread進行序列化。若希望程序能編譯通過，我們對Thread變量添加static或transient修飾即可！如下，是對Thread添加transient修飾的源碼(SerialTest7.java)：

/**
 * 序列化的演示測試程序
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.Serializable;   
import java.lang.Thread;
import java.io.IOException;   
import java.lang.ClassNotFoundException;   
  
public class SerialTest7 { 
    private static final String TMP_FILE = ".serialtest7.txt";
  
    public static void main(String[] args) {   
        // 將“對象”通過序列化保存
        testWrite();
        // 將序列化的“對象”讀出來
        testRead();
    }
  

    /**
     * 將Box對象通過序列化，保存到文件中
     */
    private static void testWrite() {   
        try {
            // 獲取文件TMP_FILE對應的對象輸出流。
            // ObjectOutputStream中，只能寫入“基本數據”或“支持序列化的對象”
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            // 創建Box對象，Box實現了Serializable序列化接口
            Box box = new Box("desk", 80, 48);
            // 將box對象寫入到對象輸出流out中，即相當於將對象保存到文件TMP_FILE中
            out.writeObject(box);
            // 打印“Box對象”
            System.out.println("testWrite box: " + box);
            // 修改box的值
            box = new Box("room", 100, 50);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * 從文件中讀取出“序列化的Box對象”
     */
    private static void testRead() {
        try {
            // 獲取文件TMP_FILE對應的對象輸入流。
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            // 從對象輸入流中，讀取先前保存的box對象。
            Box box = (Box) in.readObject();
            // 打印“Box對象”
            System.out.println("testRead  box: " + box);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * Box類“支持序列化”。因為Box實現了Serializable接口。
 *
 * 實際上，一個類只需要實現Serializable即可實現序列化，而不需要實現任何函數。
 */
class Box implements Serializable {
    private static int width;   
    private transient int height; 
    private String name;   
    private transient Thread thread = new Thread() {
        @Override
        public void run() {
            System.out.println("Serializable thread");
        }
    };

    public Box(String name, int width, int height) {
        this.name = name;
        this.width = width;
        this.height = height;
    }

    private void writeObject(ObjectOutputStream out) throws IOException{ 
        out.defaultWriteObject();//使定制的writeObject()方法可以利用自動序列化中內置的邏輯。 
        out.writeInt(height); 
        out.writeInt(width); 
        //System.out.println("Box--writeObject width="+width+", height="+height);
    }

    private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{ 
        in.defaultReadObject();//defaultReadObject()補充自動序列化 
        height = in.readInt(); 
        width = in.readInt(); 
        //System.out.println("Box---readObject width="+width+", height="+height);
    }

    @Override
    public String toString() {
        return "["+name+": ("+width+", "+height+") ]";
    }
}

至此，關於“Serializable接口”來實現序列化的內容，都說完了。為什么這么說？因為，實現序列化，除了Serializable之外，還有其它的方式，就是通過實現Externalizable來實現序列化。整理下心情，下面繼續對Externalizable進行了解。

7. Externalizable和完全定制序列化過程

如果一個類要完全負責自己的序列化，則實現Externalizable接口，而不是Serializable接口。

Externalizable接口定義包括兩個方法writeExternal()與readExternal()。需要注意的是：聲明類實現Externalizable接口會有重大的安全風險。writeExternal()與readExternal()方法聲明為public，惡意類可以用這些方法讀取和寫入對象數據。如果對象包含敏感信息，則要格外小心。

下面，我們修改之前的SerialTest1.java測試程序；將其中的Box由“實現Serializable接口” 改為 “實現Externalizable接口”。
修改后的源碼如下( ExternalizableTest1.java)：

/**
 * 序列化的演示測試程序
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.ObjectOutput;   
import java.io.ObjectInput;   
import java.io.Serializable;   
import java.io.Externalizable;   
import java.io.IOException;   
import java.lang.ClassNotFoundException;   
  
public class ExternalizableTest1 { 
    private static final String TMP_FILE = ".externalizabletest1.txt";
  
    public static void main(String[] args) {   
        // 將“對象”通過序列化保存
        testWrite();
        // 將序列化的“對象”讀出來
        testRead();
    }
  

    /**
     * 將Box對象通過序列化，保存到文件中
     */
    private static void testWrite() {   
        try {
            // 獲取文件TMP_FILE對應的對象輸出流。
            // ObjectOutputStream中，只能寫入“基本數據”或“支持序列化的對象”
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            // 創建Box對象
            Box box = new Box("desk", 80, 48);
            // 將box對象寫入到對象輸出流out中，即相當於將對象保存到文件TMP_FILE中
            out.writeObject(box);
            // 打印“Box對象”
            System.out.println("testWrite box: " + box);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * 從文件中讀取出“序列化的Box對象”
     */
    private static void testRead() {
        try {
            // 獲取文件TMP_FILE對應的對象輸入流。
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            // 從對象輸入流中，讀取先前保存的box對象。
            Box box = (Box) in.readObject();
            // 打印“Box對象”
            System.out.println("testRead  box: " + box);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * Box類實現Externalizable接口
 */
class Box implements Externalizable {
    private int width;   
    private int height; 
    private String name;   

    public Box() {
    }

    public Box(String name, int width, int height) {
        this.name = name;
        this.width = width;
        this.height = height;
    }

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

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    }

    @Override
    public String toString() {
        return "["+name+": ("+width+", "+height+") ]";
    }
}

運行結果：

testWrite box: [desk: (80, 48) ]
testRead  box: [null: (0, 0) ]

說明：

(01) 實現Externalizable接口的類，不會像實現Serializable接口那樣，會自動將數據保存。
(02) 實現Externalizable接口的類，必須實現writeExternal()和readExternal()接口！
否則，程序無法正常編譯！
(03) 實現Externalizable接口的類，必須定義不帶參數的構造函數！
否則，程序無法正常編譯！
(04) writeExternal() 和 readExternal() 的方法都是public的，不是非常安全！

接着，我們修改上面的ExternalizableTest1.java測試程序；實現Box類中的writeExternal()和readExternal()接口！
修改后的源碼如下( ExternalizableTest2.java)：

/**
 * 序列化的演示測試程序
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.ObjectOutput;   
import java.io.ObjectInput;   
import java.io.Serializable;   
import java.io.Externalizable;   
import java.io.IOException;   
import java.lang.ClassNotFoundException;   
  
public class ExternalizableTest2 { 
    private static final String TMP_FILE = ".externalizabletest2.txt";
  
    public static void main(String[] args) {   
        // 將“對象”通過序列化保存
        testWrite();
        // 將序列化的“對象”讀出來
        testRead();
    }
  

    /**
     * 將Box對象通過序列化，保存到文件中
     */
    private static void testWrite() {   
        try {
            // 獲取文件TMP_FILE對應的對象輸出流。
            // ObjectOutputStream中，只能寫入“基本數據”或“支持序列化的對象”
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            // 創建Box對象
            Box box = new Box("desk", 80, 48);
            // 將box對象寫入到對象輸出流out中，即相當於將對象保存到文件TMP_FILE中
            out.writeObject(box);
            // 打印“Box對象”
            System.out.println("testWrite box: " + box);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * 從文件中讀取出“序列化的Box對象”
     */
    private static void testRead() {
        try {
            // 獲取文件TMP_FILE對應的對象輸入流。
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            // 從對象輸入流中，讀取先前保存的box對象。
            Box box = (Box) in.readObject();
            // 打印“Box對象”
            System.out.println("testRead  box: " + box);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * Box類實現Externalizable接口
 */
class Box implements Externalizable {
    private int width;   
    private int height; 
    private String name;   

    public Box() {
    }

    public Box(String name, int width, int height) {
        this.name = name;
        this.width = width;
        this.height = height;
    }

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

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String) in.readObject();
        width = in.readInt();
        height = in.readInt();
    }

    @Override
    public String toString() {
        return "["+name+": ("+width+", "+height+") ]";
    }
}

運行結果：

testWrite box: [desk: (80, 48) ]
testRead  box: [desk: (80, 48) ]

至此，序列化的內容就全部講完了。更多相關的內容，請參考：

1. java 集合系列目錄(Category)

2. java io系列01之 IO框架

3. java io系列02之 ByteArrayInputStream的簡介,源碼分析和示例(包括InputStream)

4. java io系列03之 ByteArrayOutputStream的簡介,源碼分析和示例(包括OutputStream)

5. java io系列04之 管道(PipedOutputStream和PipedInputStream)的簡介,源碼分析和示例

6. java io系列05之 ObjectInputStream 和 ObjectOutputStream