Java序列化與反序列化的實例分析講解

今天小編就爲大家分享一篇關於Java序列化與反序列化的實例分析講解，小編覺得內容挺不錯的，現在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧

序列化與反序列化

Java對象是有生命週期的，當生命週期結束它就會被回收，但是可以通過將其轉換爲字節序列永久保存下來或者通過網絡傳輸給另一方。

把對象轉換爲字節序列的過程稱爲對象的序列化；把字節序列恢復爲對象的過程稱爲對象的反序列化。

Serializable接口

一個類實現java.io.Serializable接口就可以被序列化或者反序列化。實際上，Serializable接口中沒有任何變量和方法，它只是一個標識。如果沒有實現這個接口，在序列化或者反序列化時會拋出NotSerializableException異常。

下面是一個實現了Serializable接口的類以及它的序列化與反序列化過程。

public class SerialTest {
  public static void main(String[] args) {
    Test test = new Test();
    test.setName("test");
    // 序列化，存儲對象到文本
    ObjectOutputStream oos = null;
    try {
      oos = new ObjectOutputStream(new FileOutputStream("test"));
      oos.writeObject(test);
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      try {
        if (oos != null) {
          oos.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    // 反序列化，從文本中取出對象
    ObjectInputStream ois = null;
    try {
      ois = new ObjectInputStream(new FileInputStream("test"));
      Test1 test1 = (Test1) ois.readObject();
    } catch (IOException e) {
      e.printStackTrace();
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    } finally {
      try {
        if (ois != null) {
          ois.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}
class Test implements Serializable {
  private String name;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "Test{" +
        "name='" + name + '\'' +
        '}';
  }
}

運行結果：

Test{name='test'}

serialVersionUID

private static final long serialVersionUID = -3297006450515623366L;

serialVersionUID是一個序列化版本號，實現Serializable接口的類都會有一個版本號。如果沒有自己定義，那麼程序會默認生成一個版本號，這個版本號是Java運行時環境根據類的內部細節自動生成的。最好我們自己定義該版本號，否則當類發生改變時，程序爲我們自動生成的序列化版本號也會發生改變，那麼再將原來的字節序列反序列化時就會發生錯誤。

下面是將Test1類加入一個變量age，此時再進行反序列化的結果。可以看出，序列化版本號已發生改變，程序認爲不是同一個類，不能進行反序列化。

java.io.InvalidClassException: test.Test1; local class incompatible: stream classdesc serialVersionUID = 9097989105451761251, local class serialVersionUID = -7756223913249050270
 at java.base/java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:689)
 at java.base/java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1903)
 at java.base/java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1772)
 at java.base/java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2060)
 at java.base/java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1594)
 at java.base/java.io.ObjectInputStream.readObject(ObjectInputStream.java:430)
 at test.SerialTest.main(SerialTest.java:11)

爲了提高serialVersionUID的獨立性和確定性，強烈建議在一個可序列化類中顯示地定義serialVersionUID，爲他賦予明確的值。

那麼在IDEA中，怎麼手動生成呢？

在settings->Editor->Inspections下，搜索serial，開啓Serializable class without 'serialVersionUID'的拼寫檢查，然後將光標放在實現Serializable的接口上，按住ALt+Enter鍵，選擇添加serialVersionUID即可。

Transient關鍵字

transient修飾類的變量，可以使變量不被序列化。反序列化時，被transient修飾的變量的值被設爲初始值，如int類型被設爲0，對象型被設爲null。

ObjectOutputStream類和ObjectInputStream類

ObjectOutputStream的writeObject方法可以序列化對象，ObjectInputStream的readObject可以反序列化對象。ObjectOutputStream實現了接口ObjectOutput，所以可以進行對象寫操作。ObjectInputStream實現了接口ObjectInput，所以可以對對象進行讀操作。

靜態變量序列化

給Test類中增加一個靜態變量，賦值爲12，然後在序列化之後修改其值爲10，反序列化之後打印它的值。發現打印的值爲10，之前的12並沒有被保存。

靜態變量是不參與序列化的，序列化只是用來保存對象的狀態，而靜態變量屬於類的狀態。

父類序列化

讓Test繼承一個沒有實現Serializable接口的類，設置父類中變量的值，對Test類的實例進行序列化與反序列化操作。

public class SerialTest {
  public static void main(String[] args) {
    Test test = new Test();
    test.setName("huihui");
    test.setSex(12);
    // 序列化，存儲對象到文本
    ObjectOutputStream oos = null;
    try {
      oos = new ObjectOutputStream(new FileOutputStream("test"));
      oos.writeObject(test);
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      try {
        if (oos != null) {
          oos.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    // 反序列化，從文本中取出對象
    ObjectInputStream ois = null;
    try {
      ois = new ObjectInputStream(new FileInputStream("test"));
      Test test1 = (Test) ois.readObject();
      System.out.println(test1);
    } catch (IOException | ClassNotFoundException e) {
      e.printStackTrace();
    } finally {
      try {
        if (ois != null) {
          ois.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}
class Test extends TestFather implements Serializable {
  private static final long serialVersionUID = 4335715933640891747L;
  private String name;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "Test{" +
        "name='" + name + '\'' +
        "sex='" + sex + '\'' +
        '}';
  }
}
class TestFather {
  protected Integer sex;
  public Integer getSex() {
    return sex;
  }
  public void setSex(Integer sex) {
    this.sex = sex;
  }
  @Override
  public String toString() {
    return "TestFather{" +
        "sex='" + sex + '\'' +
        '}';
  }
}

運行結果：

Test{name='huihui'sex='null'}

發現雖然對sex進行了複製，但是反序列化結果仍然爲null。

現在讓TestFather類實現Serializable接口，運行結果如下。所以當我們想要序列化父類的變量時，也需要讓父類實現Serializable接口。

Test{name='huihui'sex='12'}

同理，如果Test類中有任何變量是對象，那麼該對象的類也需要實現Serializable接口。查看String源代碼，確實實現了Serializable接口。大家可以測試一下字段的類不實現Serializable接口的情況，運行會直接報java.io.NotSerializableException異常。

敏感字段加密

如果對於某些字段我們並不想直接暴露出去，需要對其進行加密處理，那麼就需要我們自定義序列化和反序列化方法。使用Serializable接口進行序列化時，如果不自定義方法，則默認調用ObjectOutputStream的defaultWriteObject方法和ObjectInputStream的defaultReadObject方法。下面我們來嘗試一下自己實現序列化與反序列化過程。

class Test implements Serializable {
  private static final long serialVersionUID = 4335715933640891747L;
  private String name;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "Test{" +
        "name='" + name + '\'' +
        '}';
  }
  private void writeObject(ObjectOutputStream out) {
    try {
      ObjectOutputStream.PutField putField = out.putFields();
      System.out.println("原name：" + name);
      // 模擬加密
      name = "change";
      putField.put("name", name);
      System.out.println("加密後的name：" + name);
      out.writeFields();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  private void readObject(ObjectInputStream in) {
    try {
      ObjectInputStream.GetField getField = in.readFields();
      Object object = getField.get("name", "");
      System.out.println("要解密的name：" + object.toString());
      name = "huihui";
    } catch (IOException e) {
      e.printStackTrace();
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
  }
}

運行結果：

原name：huihui
加密後的name：change
要解密的name：change
解密後的name：huihui

這種寫法重寫了writeObject方法和readObject方法，下面一種接口也可以實現相同的功能。

Externalizable接口

除了Serializable接口，Java還提供了一個Externalizable接口，它繼承了Serializable接口，提供了writeExternal和readExternal兩個方法，實現該接口的類必須重寫這兩個方法。同時還發現，類還必須提供一個無參構造方法，否則會報java.io.InvalidClassException異常。

先不深究爲什麼要加一個無參構造方法，我們先試一下這個接口的序列化效果。將類Test改爲如下所示：

class Test implements Externalizable {
  private static final long serialVersionUID = 4335715933640891747L;
  private String name;
  public Test() {
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "Test{" +
        "name='" + name + '\'' +
        '}';
  }
  @Override
  public void writeExternal(ObjectOutput out) throws IOException {
  }
  @Override
  public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
  }
}

再次運行測試方法，發現輸出的name是null。在readObject處打斷點，發現會調用無參構造方法。

name其實並沒有被序列化與反序列化，writeExternal方法和readExternal方法中是需要我們自己來實現序列化與反序列化的細節的。在反序列化時，會首先調用類的無參考構造方法創建一個新對象，然後再填充每個字段。

我們對writeExternal方法和readExternal方法進行重寫：

@Override
public void writeExternal(ObjectOutput out) throws IOException {
  out.writeObject(name);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
  name = (String) in.readObject();
}

此時運行測試方法，發現Test類被正常序列化與反序列化。

序列化存儲規則

當多次序列化一個對象時，是會序列化多次還是會序列化一次呢？

public class SerialTest {
  public static void main(String[] args) {
    Test test = new Test();
    test.setName("huihui");
    // 序列化，存儲對象到文本
    ObjectOutputStream oos = null;
    try {
      oos = new ObjectOutputStream(new FileOutputStream("test"));
      // 兩次寫入文件
      oos.writeObject(test);
      oos.flush();
      System.out.println(new File("test").length());
      oos.writeObject(test);
      oos.flush();
      System.out.println(new File("test").length());
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      try {
        if (oos != null) {
          oos.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    // 反序列化，從文本中取出對象
    ObjectInputStream ois = null;
    try {
      ois = new ObjectInputStream(new FileInputStream("test"));
      // 讀取兩個對象
      Test test1 = (Test) ois.readObject();
      Test test2 = (Test) ois.readObject();
      System.out.println(test1 == test1);
    } catch (IOException | ClassNotFoundException e) {
      e.printStackTrace();
    } finally {
      try {
        if (ois != null) {
          ois.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}
class Test implements Serializable {
  private static final long serialVersionUID = 4335715933640891747L;
  private String name;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "Test{" +
        "name='" + name + '\'' +
        '}';
  }
}

運行結果：

73
78
true

可以發現，當第二次寫入對象時，文件的長度僅僅增加了5個字節，並且在判等時，兩個引用指向同一地址。

Java序列化機制爲了節省磁盤空間，具有特定的存儲規則，當寫入文件爲同一對象時，並不會再將對象的內容進行存儲，而只是再次存儲一份引用。

總結

以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，謝謝大家對神馬文庫的支持。如果你想了解更多相關內容請查看下面相關鏈接

Java序列化與反序列化的實例分析講解

Thread的幾種狀態以及sleep/yield/join/wait/notify/notifyAll方法的區別

AbstractStringBuilder源碼分析

Java 源碼--Integer

Java 源碼--LinkedList

Java 源碼--Object

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結