2. 程式人生 > >Java 序列化之transient關鍵字

Java 序列化之transient關鍵字

阿新 • • 發佈：2018-11-04

1. transient的作用及使用方法

我們都知道一個物件只要實現了Serilizable介面，這個物件就可以被序列化，java的這種序列化模式為開發者提供了很多便利，我們可以不必關係具體序列化的過程，只要這個類實現了Serilizable介面，這個類的所有屬性和方法都會自動序列化。

然而在實際開發過程中，我們常常會遇到這樣的問題，這個類的有些屬性需要序列化，而其他屬性不需要被序列化，打個比方，如果一個使用者有一些敏感資訊（如密碼，銀行卡號等），為了安全起見，不希望在網路操作（主要涉及到序列化操作，本地序列化快取也適用）中被傳輸，這些資訊對應的變數就可以加上transient關鍵字。換句話說，這個欄位的生命週期僅存於呼叫者的記憶體中而不會寫到磁盤裡持久化。

總之，java 的transient關鍵字為我們提供了便利，你只需要實現Serilizable介面，將不需要序列化的屬性前新增關鍵字transient，序列化物件的時候，這個屬性就不會序列化到指定的目的地中。

示例code如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import

 java.io.Serializable;

 

/**

 * @description 使用transient關鍵字不序列化某個變數

 *        注意讀取的時候，讀取資料的順序一定要和存放資料的順序保持一致

 *       

 * @author Alexia

 * @date  2013-10-15

 */

public class TransientTest {

 

    public static void main(String[] args) {

 

        User user = new User();

        user.setUsername("Alexia");

        user.setPasswd("123456");

 

        System.out.println("read before Serializable: ");

        System.out.println("username: " + user.getUsername());

        System.err.println("password: " + user.getPasswd());

 

        try {

            ObjectOutputStream os = new ObjectOutputStream(

                    new FileOutputStream("C:/user.txt"));

            os.writeObject(user); // 將User物件寫進檔案

            os.flush();

            os.close();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }

        try {

            ObjectInputStream is = new ObjectInputStream(new FileInputStream(

                    "C:/user.txt"));

            user = (User) is.readObject(); // 從流中讀取User的資料

            is.close();

 

            System.out.println("\nread after Serializable: ");

            System.out.println("username: " + user.getUsername());

            System.err.println("password: " + user.getPasswd());

 

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        }

    }

}

 

class User implements Serializable {

    private static final long serialVersionUID = 8294180014912103005L; 

 

    private String username;

    private transient String passwd;

 

    public String getUsername() {

        return username;

    }

 

    public void setUsername(String username) {

        this.username = username;

    }

 

    public String getPasswd() {

        return passwd;

    }

 

    public void setPasswd(String passwd) {

        this.passwd = passwd;

    }

 

}

輸出為：

1

2

3

4

5

6

7

read before Serializable:

username: Alexia

password: 123456

 

read after Serializable:

username: Alexia

password: null

密碼欄位為null，說明反序列化時根本沒有從檔案中獲取到資訊。

2. transient使用小結

1）一旦變數被transient修飾，變數將不再是物件持久化的一部分，該變數內容在序列化後無法獲得訪問。

2）transient關鍵字只能修飾變數，而不能修飾方法和類。注意，本地變數是不能被transient關鍵字修飾的。變數如果是使用者自定義類變數，則該類需要實現Serializable介面。

3）被transient關鍵字修飾的變數不再能被序列化，一個靜態變數不管是否被transient修飾，均不能被序列化。

第三點可能有些人很迷惑，因為發現在User類中的username欄位前加上static關鍵字後，程式執行結果依然不變，即static型別的username也讀出來為“Alexia”了，這不與第三點說的矛盾嗎？實際上是這樣的：第三點確實沒錯（一個靜態變數不管是否被transient修飾，均不能被序列化），反序列化後類中static型變數username的值為當前JVM中對應static變數的值，這個值是JVM中的不是反序列化得出的，不相信？好吧，下面我來證明：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

 

/**

 * @description 使用transient關鍵字不序列化某個變數

 *        注意讀取的時候，讀取資料的順序一定要和存放資料的順序保持一致

 *       

 * @author Alexia

 * @date  2013-10-15

 */

public class TransientTest {

 

    public static void main(String[] args) {

 

        User user = new User();

        user.setUsername("Alexia");

        user.setPasswd("123456");

 

        System.out.println("read before Serializable: ");

        System.out.println("username: " + user.getUsername());

        System.err.println("password: " + user.getPasswd());

 

        try {

            ObjectOutputStream os = new ObjectOutputStream(

                    new FileOutputStream("C:/user.txt"));

            os.writeObject(user); // 將User物件寫進檔案

            os.flush();

            os.close();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }

        try {

            // 在反序列化之前改變username的值

            User.username = "jmwang";

 

            ObjectInputStream is = new ObjectInputStream(new FileInputStream(

                    "C:/user.txt"));

            user = (User) is.readObject(); // 從流中讀取User的資料

            is.close();

 

            System.out.println("\nread after Serializable: ");

            System.out.println("username: " + user.getUsername());

            System.err.println("password: " + user.getPasswd());

 

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        }

    }

}

 

class User implements Serializable {

    private static final long serialVersionUID = 8294180014912103005L; 

 

    public static String username;

    private transient String passwd;

 

    public String getUsername() {

        return username;

    }

 

    public void setUsername(String username) {

        this.username = username;

    }

 

    public String getPasswd() {

        return passwd;

    }

 

    public void setPasswd(String passwd) {

        this.passwd = passwd;

    }

 

}

執行結果為：

1

2

3

4

5

6

7

read before Serializable:

username: Alexia

password: 123456

 

read after Serializable:

username: jmwang

password: null

這說明反序列化後類中static型變數username的值為當前JVM中對應static變數的值，為修改後jmwang，而不是序列化時的值Alexia。

3. transient使用細節——被transient關鍵字修飾的變數真的不能被序列化嗎？

思考下面的例子：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

import java.io.Externalizable;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInput;

import java.io.ObjectInputStream;

import java.io.ObjectOutput;

import java.io.ObjectOutputStream;

 

/**

 * @descripiton Externalizable介面的使用

 *

 * @author Alexia

 * @date 2013-10-15

 *

 */

public class ExternalizableTest implements Externalizable {

 

    private transient String content = "是的，我將會被序列化，不管我是否被transient關鍵字修飾";

 

    @Override

    public void writeExternal(ObjectOutput out) throws IOException {

        out.writeObject(content);

    }

 

    @Override

    public void readExternal(ObjectInput in) throws IOException,

            ClassNotFoundException {

        content = (String) in.readObject();

    }

 

    public static void main(String[] args) throws Exception {

 

        ExternalizableTest et = new ExternalizableTest();

        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(

                new File("test")));

        out.writeObject(et);

 

        ObjectInput in = new ObjectInputStream(new FileInputStream(new File(

                "test")));

        et = (ExternalizableTest) in.readObject();

        System.out.println(et.content);

 

        out.close();

        in.close();

    }

}

content變數會被序列化嗎？好吧，我把答案都輸出來了，是的，執行結果就是：

1

是的，我將會被序列化，不管我是否被transient關鍵字修飾

這是為什麼呢，不是說類的變數被transient關鍵字修飾以後將不能序列化了嗎？

我們知道在Java中，物件的序列化可以通過實現兩種介面來實現，若實現的是Serializable介面，則所有的序列化將會自動進行，若實現的是Externalizable介面，則沒有任何東西可以自動序列化，需要在writeExternal方法中進行手工指定所要序列化的變數，這與是否被transient修飾無關。因此第二個例子輸出的是變數content初始化的內容，而不是null。

相關推薦

Java 序列化之transient關鍵字

1. transient的作用及使用方法 我們都知道一個物件只要實現了Serilizable介面，這個物件就可以被序列化，java的這種序列化模式為開發者提供了很多便利，我們可以不必關係具體序列化的過程，只要這個類實現了Serilizable介面，這個類的所有屬性和方法都會自動序列化。 然而

java基礎之序列化 Java物件表示方式1：序列化、反序列化和transient關鍵字的作用

轉載自https://www.cnblogs.com/szlbm/p/5504166.html     Java物件表示方式1：序列化、反序列化和transient關鍵字的作用   平時我們在Java記憶體中的物件，是無 法進行IO操作或者網路通訊的

Java Serializable 序列化和反序列化，transient關鍵字

遇到這個 Java Serializable 序列化這個介面，我們可能會有如下的問題a，什麼叫序列化和反序列化 b，作用。為啥要實現這個 Serializable 介面，也就是為啥要序列化 c，serialVersionUID 這個的值到底是在怎麼設

Java序列化之排除被序列化欄位(transient/靜態變數)

 我們都知道一個物件只要實現了Serilizable介面，這個物件就可以被序列化，java的這種序列化模式為開發者提供了很多便利，我們可以不必關係具體序列化的過程，只要這個類實現了Serilizable介面，這個類的所有屬性和方法都會自動序列化。       然而在實際

java中的序列化與transient關鍵字

    序列化和transient關鍵字應該屬於java中較高階的話題，筆者(ymh)今天花一點時間小結一些這部分知識，希望能給初學者一些幫助。若有錯誤希望指出，學無止境。轉載請註明出處！ 什麼是序列化?  

java中序列化和transient關鍵字使用小結

一、背景：Java中的物件序列化 1.物件序列化的類是有要求的，這個序列化的類必須實現一個介面Serializable，這個 介面沒有任何方法宣告，它是一個標識介面。 2.物件流可以將Java物件轉換成二進位制寫入磁碟，這個過程通常叫做序列化。 並且還可

Serializable序列化與transient關鍵字

閱讀 Shape 和 Circle 兩個類的定義。在序列化一個 Circle 的物件 circle 到 檔案時，下面哪個欄位會被儲存到檔案中? class Shape { public String name; } class Circle extends Shape implements

[Java] 序列化之基本認識

一、簡介 Java 序列化即將 Java 物件轉換為二進位制序列的過程，主要用於網路通訊、持久化儲存。 二、實現方式 Serializable Java 中實現 Serializable 介面即可實現序列化。 Externalizable Serializabl

Java學習筆記之transient關鍵字

看LinkedList原始碼看到transient關鍵字，於是乎很好奇，從來沒見過哦 首先transient關鍵字的作用：當類使用Serializable序列化的時候，使用transient修飾的變數將只會放在記憶體裡，而不會寫在磁碟上，下面做一個測試： 被序列化的類： public

JAVA序列化之RMI遠端呼叫

RMI（Remote Method Invocation）是Java中的遠端過程呼叫（Remote Procedure Call，RPC）實現，是一種分散式Java應用的實現方式。它的目的在於對開發人員遮蔽橫跨不同JVM和網路連線等細節，使得分佈在不同JVM上的

Java序列化之readObjectNoData、readResolve方法

資料地址：http://docs.oracle.com/javase/1.5.0/docs/guide/serialization/spec/input.html#5903、 ①： private void readObjectNoData() throws ObjectS

java序列化（transient和static修飾的變數的序列化實現）

序列化 (程式碼摘抄自Java程式設計思想) 平常序列化知識不做介紹 把書裡的有意思東西摘抄下來 用transient修飾是變數是否可以序列化？ 靜態變數是否可以初始化？ 1.用 Externalizable 介面實現序列化（在重寫的writeExterna

Java Serialization/序列化/反序列化 及 transient Java關鍵字詳解

以前只知道序列化和反序列化的意思及怎麼去使用，沒有更深入的去了解，在學習之中遇到了這個transient關鍵字，以前並不知道在Java中 還有 transient 關鍵字，既然遇到了就花點時間把整理一下，查閱了一些資料看了一下，自己整理一份讓方便更多的人去學習。

序列化之Java默認序列化技術(ObjectOutputStream與ObjectInputStream)

object java outputstream Java默認序列化技術 主要是通過對象輸出流java.io.ObjectOutputStream對象輸入流java.io.ObjectInputStream來實現的 package com.xingej.ser; public

java 序列化關鍵字 serialversionuid 的作用 （附帶程式碼距離）

serialVersionUID適用於Java的序列化機制。簡單來說，Java的序列化機制是通過判斷類的serialVersionUID來驗證版本一致性的。在進行反序列化時，JVM會把傳來的位元組流中的serialVersionUID與本地相應實體類的serialVe

JAVA小白的進擊之路！！！2018.11.05日 關於java序列化的那些事

2018.11.05 序列化：把物件轉換為位元組序列 反序列換：把在位元組序列轉換為物件 用途：1、把物件的位元組序列永久的儲存在硬碟中，通常存放在一個檔案中。           2、在網路上傳送物件的位元組序列 案例：web伺服器中的session物件，當有10萬用戶併發

Java反序列化之Jackson-databind

這個洞的cve編號：CVE-2017-17485，漏洞環境就如第一個連結那樣，jdk需要在jdk 1.8以上。 先看一下Jackson-databind的用法，說白了就是將json轉換成物件。 test-legit.json程式碼如下 {"id":123} 執行結果如圖： 如果注入的json程式碼如下程

java序列化與反序列化中transient和static成員剖析

在我的上一篇博文中講解了一些基本的關於java序列化與反序列化的問題，現在我們一起來對物件中宣告為transient和static的變數進行解析。 1：類中宣告為transient變數 一旦類中某個變數宣告為transient，則會告訴JVM，你不用幫我序列化該變數，我自己

java基礎序列化、反序列化和transient的作用

一、概念為什麼會有序列化？平時我們所說的java記憶體中的物件是無法進行網路通訊和IO操作的，物件將以序列化的儲存狀態（表現形式）被它們所識別。序列化：將一個物件轉換成一串二進位制表示的位元組陣列，通過儲存或轉移這些位元組陣列達到持久化的目的。反序列化：將位元組陣列重組成物件

Java序列化與ProtocalBuffer序列化之深入分析（轉）

今天看了《Java序列化與ProtocalBuffer序列化之深入分析》，感覺有所收穫。原文中對ObjectStreamField中關於屬性型別與字元表示的對映沒有指出來，在原帖中回覆了作者，這裡稍作修改並轉發。 從一個簡單物件的序列化內容來看java序列化與ProtocalBuffer序列化機制的