Java序列化總結

     前一段時間寫的關於集合類源碼分析的博客中其實一直沒有提到兩個方法，那就是writeObject和readObject方法。這兩個方法涉及到序列化的內容，這篇博文總結遇到過的和序列化相關的內容。

     什么是序列化？

     序列化是將對象的狀態信息轉化為可以存儲或傳輸的形式的過程。在序列化期間，對象將其當前狀態寫入到臨時或持久性存儲區。以后可以通過存儲區中讀取或反序列化對象的狀態重新創建對象。

     為什么要序列化？

     有兩個最重要的原因促使對序列化的使用：一個原因是將對象的狀態保持在存儲媒體中，以便可以在以后重新創建精確的副本；另一個原因是通過值將對象從一個應用程序域發送到另一個應用程序域中。例如，在網絡中傳輸的數據都必須要序列化。

     Java中的序列化

     Java中的序列化機制能夠將一個實例對象的狀態信息寫入到一個字節流中，使其可以通過socket進行傳輸或者持久化存儲到數據庫或文件系統中，然后再需要的時候可以讀取字節流中的信息重構一個相同的對象。序列化在Java中有着廣泛的應用，RMI、Hessian等技術都是以此為基礎的。

     下面是一些序列化涉及到的內容的例子。

     UserInfo類是下面序列化例子中都要用到的一個保存基本信息的類。

public class UserInfo implements Serializable {

    private static final long serialVersionUID = 1L;
    public static String defaultPostcode = "310000";
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static String getDefaultPostcode() {
        return defaultPostcode;
    }

    public static void setDefaultPostcode(String defaultPostcode) {
        UserInfo.defaultPostcode = defaultPostcode;
    }

    public void desSelf() {
        System.out.println("Default Postcode: " + getDefaultPostcode());
        System.out.println("Age: " + getAge());
        System.out.println("Name: " + getName());
    }
}

     結合UserInfo的內容，先看下面這個main方法。

public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileOutputStream fos = new FileOutputStream("temp.out");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        UserInfo user = new UserInfo();
        user.setAge(25);
        user.setName("Tom");
        System.out.println("Before Serialize");
        user.desSelf();
        // 保存對象后修改了DefaultPostcode
        UserInfo.setDefaultPostcode("110");
        oos.writeObject(user);
        oos.flush();
        FileInputStream fis = new FileInputStream("temp.out");
        ObjectInputStream ois = new ObjectInputStream(fis);
        user = (UserInfo)ois.readObject();
        System.out.println("After Deserialize");
        user.desSelf();
    }

     在5、6兩行設置了age為25，name為Tom，然后輸出了UserInfo自己的描述：

Before Serialize
Default Postcode: 310000
Age: 25
Name: Tom

     可以看到Age和Name分別是設置的值。defaultPostCode是UserInfo的一個靜態變量，它的值是類中指定的310000。然后將這個對象進行了序列化，保存在temp.out中。

     在第10行修改了defaultPostcode的值為110，然后反序列化並輸出user的描述信息，結果如下：

After Deserialize
Default Postcode: 110
Age: 25
Name: Tom

     為什么反序列化后defaultPostcode不是310000而是修改的110呢？因為序列化保存的是對象的狀態，而靜態變量屬於類的狀態，在序列化的時候不會被保存。

     注意，需要被序列化的對象必須實現Serializable接口，否則在序列化的時候會拋出java.io.NotSerializableException異常。

     實現Serializable接口總是會要求添加一個serialVersionUID屬性，有以下兩種形式：

　　private static final long serialVersionUID = 5511561554099546149L;
　　private static final long serialVersionUID = 1L;

     它們有什么區別呢？一個是固定的 1L，一個是隨機生成一個不重復的 long 類型數據（實際上是使用 JDK 工具生成），在這里有一個建議，如果沒有特殊需求，就是用默認的 1L 就可以，這樣可以確保代碼一致時反序列化成功。那么隨機生成的序列化 ID 有什么作用呢，有些時候，通過改變序列化 ID 可以用來限制某些用戶的使用。

     下面看一個和序列化相關的關鍵字Transient（在《ArrayList源碼分析》中提到過）。

      Java的serialization提供了一種持久化對象實例的機制。當持久化對象時，可能有一個特殊的對象數據成員，我們不想用serialization機制來保存它。為了在一個特定對象的一個域上關閉serialization，可以在這個域前加上關鍵字transient。

      transient是Java語言的關鍵字，用來表示一個域不是該對象串行化的一部分。當一個對象被串行化的時候，transient型變量的值不包括在串行化的表示中，然而非transient型的變量是被包括進去的。

    有點抽象，看個例子應該能明白。

public class UserInfo implements Serializable {
     private static final long serialVersionUID = 996890129747019948L;
     private String name;
     private transient String psw;
 
     public UserInfo(String name, String psw) {
         this.name = name;
         this.psw = psw;
     }
 
     public String toString() {
         return "name=" + name + ", psw=" + psw;
     }
 }
 
public class TestTransient {
    public static void main(String[] args) {
        UserInfo userInfo = new UserInfo("張三", "123456");
        System.out.println(userInfo);
        try {
            // 序列化，被設置為transient的屬性沒有被序列化
            ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream(
                    "UserInfo.out"));
            o.writeObject(userInfo);
            o.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        try {
            // 重新讀取內容
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(
                    "UserInfo.out"));
            UserInfo readUserInfo = (UserInfo) in.readObject();
            //讀取后psw的內容為null
            System.out.println(readUserInfo.toString());
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
}

     下面說一下上文提到的ArrayList中的writeObject和readObject。先看這兩個方法在ArrayList中的具體內容。

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
    int expectedModCount = modCount;
    s.defaultWriteObject();
    s.writeInt(elementData.length);
    for (int i=0; i<size; i++)
        s.writeObject(elementData[i]);

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    s.defaultReadObject();
    int arrayLength = s.readInt();
    Object[] a = elementData = new Object[arrayLength];
    for (int i=0; i<size; i++)
        a[i] = s.readObject();
}

     這兩個方法都是private的且沒在ArrayList中被調用過，那為什么需要這兩個方法呢？

     writeObject和readObject並不是在每個類和接口中都會定義，而只是定義在哪些在序列化和反序列化過程中需要特殊處理的類中。

　　stackoverflow上的解答：http://stackoverflow.com/questions/7467313/why-are-readobject-and-writeobject-private-and-why-would-i-write-transient-vari

     也就是說通過這兩個方法可以自己去控制序列化和反序列化的過程。下面是這兩個方法的一個例子。

private static final long serialVersionUID = 1L;

    private String password = "pass";

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    private void writeObject(ObjectOutputStream out) {
        try {
            PutField putFields = out.putFields();
            System.out.println("原密碼:" + password);
            password = "encryption";//模擬加密
            putFields.put("password", password);
            System.out.println("加密后的密碼" + password);
            out.writeFields();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void readObject(ObjectInputStream in) {
        try {
            GetField readFields = in.readFields();
            Object object = readFields.get("password", "");
            System.out.println("要解密的字符串:" + object.toString());
            password = "pass";//模擬解密,需要獲得本地的密鑰
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        try {
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("result.obj"));
            out.writeObject(new Test());
            out.close();

            ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
                    "result.obj"));
            Test t = (Test) oin.readObject();
            System.out.println("解密后的字符串:" + t.getPassword());
            oin.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

     writeObject 方法中，對密碼進行了加密，在 readObject 中則對 password 進行解密，只有擁有密鑰的客戶端，才可以正確的解析出密碼，確保了數據的安全。

     最后說一下序列化的存儲規則。

public class Test {
    public static void main(String[] args) throws IOException,
            ClassNotFoundException {
        FileOutputStream fos = new FileOutputStream("temp.out");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        UserInfo user = new UserInfo();
        user.setAge(25);
        user.setName("Tom");
        oos.writeObject(user);
        oos.flush();
        System.out.println(new File("temp.out").length());
        oos.writeObject(user);
        oos.flush();
        oos.close();
        System.out.println(new File("temp.out").length());

        FileInputStream fis = new FileInputStream("temp.out");
        ObjectInputStream ois = new ObjectInputStream(fis);
        UserInfo user1 = (UserInfo) ois.readObject();
        UserInfo user2 = (UserInfo) ois.readObject();
        ois.close();
        System.out.println(user1 == user2);
    }
}

     為什么同一對象寫入兩次，文件的大小不是寫入一次的文件大小的兩倍呢？而第三次寫入和第二次寫入增加的長度是一樣的呢？為什么反序列化后的兩個對象比較結果是true呢？

     Java 序列化機制為了節省磁盤空間，具有特定的存儲規則，當寫入文件的為同一對象時，並不會再將對象的內容進行存儲，而只是再次存儲一份引用，上面增加的 5 字節的存儲空間就是新增引用和一些控制信息的空間。反序列化時，恢復引用關系，使得user1和user2二者相等，輸出 true。該存儲規則極大的節省了存儲空間。

     肯定還有我不知道的內容，望多交流討論。