摘要：的序列化是將一個(gè)對象表示成字節(jié)序列，該字節(jié)序列包括了對象的數(shù)據(jù)，有關(guān)對象的類型信息和存儲在對象中的數(shù)據(jù)類型。這個(gè)是根據(jù)類名接口名成員方法及屬性等來生成一個(gè)位的哈希字段，因?yàn)樵黾恿俗侄危虼松傻牟灰粯恿恕?/p>

序列化是將一個(gè)對象的狀態(tài)，各屬性的值序列化保存起來，然后在合適的時(shí)候通過反序列化獲得。

Java的序列化是將一個(gè)對象表示成字節(jié)序列，該字節(jié)序列包括了對象的數(shù)據(jù)，有關(guān)對象的類型信息和存儲在對象中的數(shù)據(jù)類型。

說白了，就是將對象保存起來，就跟保存字符串?dāng)?shù)據(jù)一樣，用到的時(shí)候再取出來。任何實(shí)現(xiàn)了Serializable接口的類都可以被序列化。

package com.wangjun.othersOfJava;

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

public class SerializeDemo {

    public static void main(String[] args) {
        Employee em = new Employee();
        em.name = "wangjun";
        em.age = 24;
        em.ssh = 123456;
        // 將對象序列化后保存到文件
        try (
                FileOutputStream fo = new FileOutputStream("tem.ser");
                ObjectOutputStream oo = new ObjectOutputStream(fo))
        {
            oo.writeObject(em);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 反序列化取出對象
        try(
                FileInputStream fi = new FileInputStream("tem.ser");
                ObjectInputStream oi = new ObjectInputStream(fi)) 
        {
            Employee e2 = (Employee) oi.readObject();
            System.out.println(e2.name);
            System.out.println(e2.age);
            System.out.println(e2.ssh);
            System.out.println(Employee.local);
            e2.test();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static class Employee implements Serializable {
        String name;
        int age;
        static String local = "earth";
        transient int ssh;

        public void test() {
            System.out.println("this is test method!");
        }
    }

}

程序的運(yùn)行結(jié)果：

wangjun
24
0
earth
this is test method!

如果有一些字段不想被序列化怎么辦呢？這時(shí)候就可以用transient關(guān)鍵字修飾，就像上面代碼的ssh字段，關(guān)于transient關(guān)鍵字有以下幾個(gè)特點(diǎn)：

一旦被transient關(guān)鍵字修飾，那變量將不再是對象持久化的一部分，該變量內(nèi)容在序列化后無法獲得訪問；

transient只能修飾變量，不能修飾方法和類，本地變量（局部變量）也不能被transient修飾；

一個(gè)靜態(tài)變量不管是否被transient修飾，都不能被序列化。

從上面的例子看到好像與第三條不符，其實(shí)反序列化取出的local是JVM里面的值，而不是反序列化出來的?？梢约右恍写a驗(yàn)證一下，在反序列化之前更改一下local的值：

// 反序列化取出對象
Employee.local = "earth2";
try(
  ...

看一下打印結(jié)果

wangjun
24
0
earth2
this is test method!

這說明打印出來的是JVM中對應(yīng)的local的值earth2，而不是序列化的時(shí)候的值earth。

transient只有對實(shí)現(xiàn)了Serializable接口方式的序列化有效，還有一種序列化的方式是實(shí)現(xiàn)Externalizable接口，這種實(shí)現(xiàn)方式不像實(shí)現(xiàn)Serializable接口一樣可以幫你自動(dòng)序列化，它需要在writeExternal方法中手動(dòng)指定需要序列化的變量并且在readExternal手動(dòng)取出來，這與是否被transient修飾無關(guān)，下面更改一下上面的例子，將Employee類改成：

static class Employee implements Externalizable {
        String name;
        int age;
        static String local = "earth";
        transient int ssh;
        
        //實(shí)現(xiàn)Externalizable接口進(jìn)行序列化必須顯式聲明無參構(gòu)造器
        public Employee() {
        }

        public void test() {
            System.out.println("this is test method!");
        }

        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            out.writeObject(name);
            //out.writeObject(age);
            out.writeObject(ssh);
            out.writeObject(local);
        }

        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            name = (String) in.readObject();
            //age = (int) in.readObject();
            ssh = (int) in.readObject();
            local = (String) in.readObject();
        }
    }

重新運(yùn)行，結(jié)果（注意：上述主函數(shù)中還存在對local重新賦值的代碼Employee.local = "earth2";）：

wangjun
0
123456
earth
this is test method!

可以看到能否被序列化跟transient和static修飾都沒有關(guān)系，只跟writeExternal和readExternal有關(guān)系。

對Serializable對象反序列化時(shí)，由于Serializable對象完全以它存儲的二進(jìn)制位為基礎(chǔ)來構(gòu)造，因此并不會調(diào)用任何構(gòu)造函數(shù)，因此Serializable類無需默認(rèn)構(gòu)造函數(shù)，但是當(dāng)Serializable類的父類沒有實(shí)現(xiàn)Serializable接口時(shí)，反序列化過程會調(diào)用父類的默認(rèn)構(gòu)造函數(shù)，因此該父類必需有默認(rèn)構(gòu)造函數(shù)，否則會拋異常。

對Externalizable對象反序列化時(shí)，會先調(diào)用類的不帶參數(shù)的構(gòu)造方法，這是有別于默認(rèn)反序列方式的。如果把類的不帶參數(shù)的構(gòu)造方法刪除，或者把該構(gòu)造方法的訪問權(quán)限設(shè)置為private、默認(rèn)或protected級別，會拋出java.io.InvalidException: no valid constructor異常，因此Externalizable對象必須有默認(rèn)構(gòu)造函數(shù)，而且必需是public的。

如果不是特別堅(jiān)持實(shí)現(xiàn)Externalizable接口，那么還有另一種方法。我們可以實(shí)現(xiàn)Serializable接口，并添加writeObject()和readObject()的方法。一旦對象被序列化或者重新裝配，就會分別調(diào)用那兩個(gè)方法。也就是說，只要提供了這兩個(gè)方法，就會優(yōu)先使用它們，而不考慮默認(rèn)的序列化機(jī)制。

上述實(shí)現(xiàn)Serializable接口的Employee類中，會有一個(gè)警告：

The serializable class Employee does not declare a static final serialVersionUID field of type long

意思是Employee沒有聲明一個(gè)靜態(tài)final的常量serialVersionUID，那這個(gè)serialVersionUID的作用是什么呢？

serialVersionUID是對類進(jìn)行版本控制的，Java的序列化機(jī)制是通過判斷類的serialVersionUID來驗(yàn)證版本一致性的。在進(jìn)行反序列化時(shí)，JVM會把傳來的字節(jié)流中的serialVersionUID與本地相應(yīng)實(shí)體類的serialVersionUID進(jìn)行比較，如果相同就認(rèn)為是一致的，可以進(jìn)行反序列化，否則就會出現(xiàn)序列化版本不一致的異常，即是InvalidCastException。

serialVersionUID有兩種生成方式：

一是默認(rèn)的1L，比如：private static final long serialVersionUID = 1L；

二是根據(jù)類名、接口名、成員方法及屬性等來生成一個(gè)64位的哈希字段。

如果程序沒有顯式的聲明serialVersionUID，那么程序?qū)⒂玫诙N實(shí)現(xiàn)。我們可以做一個(gè)實(shí)現(xiàn)，還是用上述實(shí)現(xiàn)Serializable接口的例子。

我們先運(yùn)行一下程序，生成序列化文件tem.ser，在把“將對象序列化后保存到文件”這一段邏輯注釋掉，對Employee類增加一個(gè)test字段：

static class Employee implements Serializable {
  String name;
  int age;
  static String local = "earth";
  transient int ssh;
  String test;

  public void test() {
    System.out.println("this is test method!");
  }
}

這時(shí)候運(yùn)行的時(shí)候會報(bào)錯(cuò)：

java.io.InvalidClassException: com.wangjun.othersOfJava.SerializeDemo$Employee; local class incompatible: stream classdesc serialVersionUID = 4506166831890198488, local class serialVersionUID = 785960679919880606
    at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)
    at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1843)
    at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1713)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2000)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1535)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:422)
    at com.wangjun.othersOfJava.SerializeDemo.main(SerializeDemo.java:32)

因?yàn)槌绦虬l(fā)現(xiàn)取到的序列化文件的serialVersionUID和當(dāng)前的serialVersionUID不一樣。這個(gè)serialVersionUID是根據(jù)類名、接口名、成員方法及屬性等來生成一個(gè)64位的哈希字段，因?yàn)樵黾恿藅est字段，因此生成的serialVersionUID不一樣了。

接著，我們顯式的聲明serialVersionUID

static class Employee implements Serializable {
  private static final long serialVersionUID = 1L;
  String name;
  int age;
  static String local = "earth";
  transient int ssh;

  public void test() {
    System.out.println("this is test method!");
  }
}

將剛才注釋的代碼取消注釋，運(yùn)行一遍再注釋掉，并且新增字段test：

static class Employee implements Serializable {
  private static final long serialVersionUID = 1L;
  String name;
  int age;
  static String local = "earth";
  transient int ssh;
  String test;

  public void test() {
    System.out.println("this is test method!");
  }
}

再次運(yùn)行發(fā)現(xiàn)沒有報(bào)錯(cuò)，運(yùn)行OK。這是因?yàn)槟泔@式聲明了serialVersionUID，序列化的serialVersionUID和目前的serialVersionUID一樣，因此會認(rèn)為是同一個(gè)版本的類。

你也可以將serialVersionUID改成2L，這個(gè)時(shí)候又會報(bào)錯(cuò)了。

參考：
https://www.cnblogs.com/duanx...
https://blog.csdn.net/fjndwy/...
https://blog.csdn.net/bigtree...