客戶端訪問了某個能開啟會話功能的資源， web服務器就會創(chuàng)建一個與該客戶端對應的HttpSession對象，每個HttpSession對象都要站用一定的內存空間。如果在某一時間段內訪問站點的用戶很多，web服務器內存中就會積累大量的HttpSession對象，消耗大量的服務器內存，即使用戶已經(jīng)離開或者關閉了瀏覽器，web服務器仍要保留與之對應的HttpSession對象，在他們超時之前，一直占用web服務器內存資源。

        web服務器通常將那些暫時不活動但未超時的HttpSession對象轉移到文件系統(tǒng)或數(shù)據(jù)庫中保存，服務器要使用他們時再將他們從文件系統(tǒng)或數(shù)據(jù)庫中裝載入內存，這種技術稱為Session的持久化。

         將HttpSession對象保存到文件系統(tǒng)或數(shù)據(jù)庫中，需要采用序列化的方式將HttpSession對象中的每個屬性對象保存到文件系統(tǒng)或數(shù)據(jù)庫中；將HttpSession對象從文件系統(tǒng)或數(shù)據(jù)庫中裝載如內存時，需要采用反序列化的方式，恢復HttpSession對象中的每個屬性對象。所以存儲在HttpSession對象中的每個屬性對象必須實現(xiàn)Serializable接口。

serialVersionUID 的作用

serialVersionUID 用來表明類的不同版本間的兼容性

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

      當實現(xiàn)java.io.Serializable接口的實體（類）沒有顯式地定義一個名為serialVersionUID，類型為long的變量時，Java序列化機制會根據(jù)編譯的class自動生成一個serialVersionUID作序列化版本比較用，這種情況下，只有同一次編譯生成的class才會生成相同的serialVersionUID 。

       如果我們不希望通過編譯來強制劃分軟件版本，即實現(xiàn)序列化接口的實體能夠兼容先前版本，未作更改的類，就需要顯式地定義一個名為serialVersionUID，類型為long的變量，不修改這個變量值的序列化實體都可以相互進行串行化和反串行化。

      引起這個疑問，還是從Hibernate使用查詢緩存說起；對象實例除了存在于內存，二級緩存還會將對象寫進硬盤在需要的時候再讀取出來使用，此時就必須提到一個概念：序列化。

      程序在運行時實例化出對象，這些對象存在于內存中，隨著程序運行停止而消失，但如果我們想把某些對象（一般都是各不相同的屬性）保存下來或者傳輸給其他進程，在程序終止運行后這些對象仍然存在，可以在程序再次運行時讀取這些對象的信息，或者在其他程序中利用這些保存下來的對象信息恢復成實例對象。這種情況下就要用到對象的序列化和反序列化。

 其實很早就知道的，在Java中常見的幾個類，如：Interger/String等，都實現(xiàn)了java.io.Serializable接口。這個序列化接口沒有任何方法和域，僅用于標識序列化語意；實現(xiàn) Serializable 接口的類是可序列化的，沒有實現(xiàn)此接口的類將不能被序列化和反序列化。序列化類的所有子類本身都是可序列化的，不再需要顯式實現(xiàn) Serializable 接口。只有經(jīng)過序列化，才能兼容對象在磁盤文本以及在網(wǎng)絡中的傳輸，以及恢復對象的時候反序列化等操作。

問題一：為何要實現(xiàn)序列化？

答：序列化就是對實例對象的狀態(tài)(State 對象屬性而不包括對象方法)進行通用編碼（如格式化的字節(jié)碼）并保存，以保證對象的完整性和可傳遞性。

簡而言之：序列化，就是為了在不同時間或不同平臺的JVM之間共享實例對象

// 經(jīng)常使用如下：
public static void main(String[] args) throws Exception {
  File file = new File("user.ser");
 
  ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));
  User user = new User("zhang", 18, Gender.MALE);
  oout.writeObject(user);
  oout.close();
 
  ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
  Object newUser = oin.readObject();
  oin.close();
  System.out.println(newUser);
}

  如沒有 實現(xiàn)Serializable接口，在序列化時，使用ObjectOutputStream的write（object）方法將對象保存時將會出現(xiàn)異常。其實 java.io.Serializable 只是一個沒有屬性和方法的空接口，但是問題來了。。

問題二：為何一定要實現(xiàn) Serializable 才能進行序列化呢？

使用 ObjectOutputStream 來持久化對象， 對于此處拋出的異常，查看該類中實現(xiàn)如下：

private void writeObject0(Object obj, boolean unshared) throws IOException {
  // ...
      // remaining cases
      if (obj instanceof String) {
        writeString((String) obj, unshared);
      } else if (cl.isArray()) {
        writeArray(obj, desc, unshared);
      } else if (obj instanceof Enum) {
        writeEnum((Enum) obj, desc, unshared);
      } else if (obj instanceof Serializable) {
        writeOrdinaryObject(obj, desc, unshared);
      } else {
        if (extendedDebugInfo) {
          throw new NotSerializableException(
            cl.getName() + "\n" + debugInfoStack.toString());
        } else {
          throw new NotSerializableException(cl.getName());
        }
      }
  // ...
}

從此可知， 如果被寫對象類型是String、數(shù)組、Enum、Serializable，就可以進行序列化，否則將拋出NotSerializableException。

最后提點注意：

1、在序列化對象時，不僅會序列化當前對象本身，還會對該對象引用的其它對象也進行序列化，如此引用傳遞序列化。如果一個對象包含的成員變量是容器類等并深層引用，那么序列化過程開銷也較大。

2、當字段被聲明為 transient 后，默認序列化機制就會忽略該字段。（還有方法就是自定義writeObject方法，見下代碼示例）

3、在單例類中添加一個readResolve()方法（直接返回單例對象），以保證在序列化過程仍保持單例特性。

此外補充一下，

在路徑下jdk中還有另外一種形式的對象持久化，即：外部化（Externalization）。

public interface Externalizable extends java.io.Serializable {
 void writeExternal(ObjectOutput out) throws IOException;
 void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

外部化和序列化是實現(xiàn)同一目標的兩種不同方法。

通過 Serializable 接口對對象序列化的支持是jdk內支持的 API ，但是java.io.Externalizable的所有實現(xiàn)者必須提供讀入和寫出的具體實現(xiàn)，怎么實現(xiàn)完全由你自定義。序列化（Serializable ）會自動存儲所有必要的信息（如屬性以及屬性類型等），用以反序列化成原來一樣的實例，而外部化（Externalizable）則只保存被存儲實例中你需要的信息。

示例代碼如下：

public class User implements Externalizable {
  private String name;
  transient private Integer age; // 屏蔽字段
  private Gender gender;
 
  public User() {
    System.out.println("none constructor");
  }
 
  public User(String name, Integer age, Gender gender) {
    System.out.println("arg constructor");
    this.name = name;
    this.age = age;
    this.gender = gender;
  }
 
  // 實現(xiàn)讀寫
  private void writeObject(ObjectOutputStream out) throws IOException {
    out.defaultWriteObject();
    out.writeInt(age);
    // 屏蔽gender
  }
  private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    in.defaultReadObject();
    age = in.readInt();
  }
 
  // 具體重寫
  @Override
  public void writeExternal(ObjectOutput out) throws IOException {
    out.writeObject(name);
    out.writeInt(age);
    // 屏蔽gender
  }
  @Override
  public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    name = (String) in.readObject();
    age = in.readInt();
  } 
}

注意，用Externalizable進行序列化，當讀取對象時，會調用被序列化類的無參構造器創(chuàng)建一個新的對象，然后再將被保存對象的字段的值分別填充到新對象中。實現(xiàn)Externalizable接口的類必須要提供一個無參的構造器，且訪問權限為 public。

到此這篇關于Java中實體類為什么要實現(xiàn)Serializable序列化的作用的文章就介紹到這了,更多相關Java Serializable序列化內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論