国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

JAVA 序列化

GeekQiaQia / 597人閱讀

摘要:靜態變量序列化情境查看清單的代碼。之所以打印的原因在于序列化時,并不保存靜態變量,這其實比較容易理解,序列化保存的是對象的狀態,靜態變量屬于類的狀態,因此序列化并不保存靜態變量。解決要想將父類對象也序列化,就需要讓父類也實現接口。

原文 https://www.ibm.com/developer...

 引言

將 Java 對象序列化為二進制文件的 Java 序列化技術是 Java 系列技術中一個較為重要的技術點,在大部分情況下,開發人員只需要了解被序列化的類需要實現 Serializable 接口,使用 ObjectInputStream 和 ObjectOutputStream 進行對象的讀寫。然而在有些情況下,光知道這些還遠遠不夠,文章列舉了筆者遇到的一些真實情境,它們與 Java 序列化相關,通過分析情境出現的原因,使讀者輕松牢記 Java 序列化中的一些高級認識。

序列化 ID 問題

情境:兩個客戶端 A 和 B 試圖通過網絡傳遞對象數據,A 端將對象 C 序列化為二進制數據再傳給 B,B 反序列化得到 C。
問題:C 對象的全類路徑假設為 com.inout.Test,在 A 和 B 端都有這么一個類文件,功能代碼完全一致。也都實現了 Serializable 接口,但是反序列化時總是提示不成功。
解決:虛擬機是否允許反序列化,不僅取決于類路徑和功能代碼是否一致,一個非常重要的一點是兩個類的序列化 ID 是否一致(就是 private static final long serialVersionUID = 1L)。清單 1 中,雖然兩個類的功能代碼完全一致,但是序列化 ID 不同,他們無法相互序列化和反序列化。

清單 1. 相同功能代碼不同序列化 ID 的類對比

package com.inout; 
import java.io.Serializable;
public class A implements Serializable { 
    private static final long serialVersionUID = 1L; 
    private String name; 
    
    public String getName() 
    { 
        return name; 
    }
    public void setName(String name) 
    { 
        this.name = name; 
    } 
} 
 
package com.inout; 
import java.io.Serializable; 
public class A implements Serializable { 
    private static final long serialVersionUID = 2L; 
    private String name; 
    
    public String getName() 
    { 
        return name; 
    } 
    public void setName(String name) 
    { 
        this.name = name; 
    } 
}

序列化 ID 在 Eclipse 下提供了兩種生成策略,一個是固定的 1L,一個是隨機生成一個不重復的 long 類型數據(實際上是使用 JDK 工具生成),在這里有一個建議,如果沒有特殊需求,就是用默認的 1L 就可以,這樣可以確保代碼一致時反序列化成功。那么隨機生成的序列化 ID 有什么作用呢,有些時候,通過改變序列化 ID 可以用來限制某些用戶的使用。

特性使用案例Fa?ade

讀者應該聽過 Fa?ade 模式,它是為應用程序提供統一的訪問接口,案例程序中的 Client 客戶端使用了該模式,案例程序結構圖如圖 1 所示。

Client 端通過 Fa?ade Object 才可以與業務邏輯對象進行交互。而客戶端的 Fa?ade Object 不能直接由 Client 生成,而是需要 Server 端生成,然后序列化后通過網絡將二進制對象數據傳給 Client,Client 負責反序列化得到 Fa?ade 對象。該模式可以使得 Client 端程序的使用需要服務器端的許可,同時 Client 端和服務器端的 Fa?ade Object 類需要保持一致。當服務器端想要進行版本更新時,只要將服務器端的 Fa?ade Object 類的序列化 ID 再次生成,當 Client 端反序列化 Fa?ade Object 就會失敗,也就是強制 Client 端從服務器端獲取最新程序。

靜態變量序列化

情境:查看清單 2 的代碼。
清單 2. 靜態變量序列化問題代碼

public class Test implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    public static int staticVar = 5;
 
    public static void main(String[] args) {
        try {
            //初始時staticVar為5
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("result.obj"));
            out.writeObject(new Test());
            out.close();
 
            //序列化后修改為10
            Test.staticVar = 10;
 
            ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
                    "result.obj"));
            Test t = (Test) oin.readObject();
            oin.close();
             
            //再讀取,通過t.staticVar打印新的值
            System.out.println(t.staticVar);
             
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

清單 2 中的 main 方法,將對象序列化后,修改靜態變量的數值,再將序列化對象讀取出來,然后通過讀取出來的對象獲得靜態變量的數值并打印出來。依照清單 2,這個 System.out.println(t.staticVar) 語句輸出的是 10 還是 5 呢?

最后的輸出是 10,對于無法理解的讀者認為,打印的 staticVar 是從讀取的對象里獲得的,應該是保存時的狀態才對。之所以打印 10 的原因在于序列化時,并不保存靜態變量,這其實比較容易理解,序列化保存的是對象的狀態,靜態變量屬于類的狀態,因此 序列化并不保存靜態變量。

父類的序列化與 Transient 關鍵字

情境:一個子類實現了 Serializable 接口,它的父類都沒有實現 Serializable 接口,序列化該子類對象,然后反序列化后輸出父類定義的某變量的數值,該變量數值與序列化時的數值不同。

解決:要想將父類對象也序列化,就需要讓父類也實現Serializable 接口。如果父類不實現的話的,就 需要有默認的無參的構造函數。在父類沒有實現 Serializable 接口時,虛擬機是不會序列化父對象的,而一個 Java 對象的構造必須先有父對象,才有子對象,反序列化也不例外。所以反序列化時,為了構造父對象,只能調用父類的無參構造函數作為默認的父對象。因此當我們取父對象的變量值時,它的值是調用父類無參構造函數后的值。如果你考慮到這種序列化的情況,在父類無參構造函數中對變量進行初始化,否則的話,父類變量值都是默認聲明的值,如 int 型的默認是 0,string 型的默認是 null。

Transient 關鍵字的作用是控制變量的序列化,在變量聲明前加上該關鍵字,可以阻止該變量被序列化到文件中,在被反序列化后,transient 變量的值被設為初始值,如 int 型的是 0,對象型的是 null。

特性使用案例
我們熟悉使用 Transient 關鍵字可以使得字段不被序列化,那么還有別的方法嗎?根據父類對象序列化的規則,我們可以將不需要被序列化的字段抽取出來放到父類中,子類實現 Serializable 接口,父類不實現,根據父類序列化規則,父類的字段數據將不被序列化,形成類圖如圖 2 所示。
圖 2. 案例程序類圖
圖 2. 案例程序類圖
上圖中可以看出,attr1、attr2、attr3、attr5 都不會被序列化,放在父類中的好處在于當有另外一個 Child 類時,attr1、attr2、attr3 依然不會被序列化,不用重復抒寫 transient,代碼簡潔。

對敏感字段加密

情境:服務器端給客戶端發送序列化對象數據,對象中有一些數據是敏感的,比如密碼字符串等,希望對該密碼字段在序列化時,進行加密,而客戶端如果擁有解密的密鑰,只有在客戶端進行反序列化時,才可以對密碼進行讀取,這樣可以一定程度保證序列化對象的數據安全。
解決:在序列化過程中,虛擬機會試圖調用對象類里的 writeObject 和 readObject 方法,進行用戶自定義的序列化和反序列化,如果沒有這樣的方法,則默認調用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用戶自定義的 writeObject 和 readObject 方法可以允許用戶控制序列化的過程,比如可以在序列化的過程中動態改變序列化的數值。基于這個原理,可以在實際應用中得到使用,用于敏感字段的加密工作,清單 3 展示了這個過程。
清單 3. 靜態變量序列化問題代碼

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();
       }
   }

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

特性使用案例:密碼加密

RMI 技術是完全基于 Java 序列化技術的,服務器端接口調用所需要的參數對象來至于客戶端,它們通過網絡相互傳輸。這就涉及 RMI 的安全傳輸的問題。一些敏感的字段,如用戶名密碼(用戶登錄時需要對密碼進行傳輸),我們希望對其進行加密,這時,就可以采用本節介紹的方法在客戶端對密碼進行加密,服務器端進行解密,確保數據傳輸的安全性。

序列化存儲規則

情境:問題代碼如清單 4 所示。
清單 4. 存儲規則問題代碼

ObjectOutputStream out = new ObjectOutputStream(
                   new FileOutputStream("result.obj"));
   Test test = new Test();
   //試圖將對象兩次寫入文件
   out.writeObject(test);
   out.flush();
   System.out.println(new File("result.obj").length());
   out.writeObject(test);
   out.close();
   System.out.println(new File("result.obj").length());
 
   ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
           "result.obj"));
   //從文件依次讀出兩個文件
   Test t1 = (Test) oin.readObject();
   Test t2 = (Test) oin.readObject();
   oin.close();
            
   //判斷兩個引用是否指向同一個對象
   System.out.println(t1 == t2);

清單 3 中對同一對象兩次寫入文件,打印出寫入一次對象后的存儲大小和寫入兩次后的存儲大小,然后從文件中反序列化出兩個對象,比較這兩個對象是否為同一對象。一般的思維是,兩次寫入對象,文件大小會變為兩倍的大小,反序列化時,由于從文件讀取,生成了兩個對象,判斷相等時應該是輸入 false 才對,但是最后結果輸出如圖 4 所示。
圖 4. 示例程序輸出
圖 4. 示例程序輸出
我們看到,第二次寫入對象時文件只增加了 5 字節,并且兩個對象是相等的,這是為什么呢?
解答:Java 序列化機制為了節省磁盤空間,具有特定的存儲規則,當寫入文件的為同一對象時,并不會再將對象的內容進行存儲,而只是再次存儲一份引用,上面增加的 5 字節的存儲空間就是新增引用和一些控制信息的空間。反序列化時,恢復引用關系,使得清單 3 中的 t1 和 t2 指向唯一的對象,二者相等,輸出 true。該存儲規則極大的節省了存儲空間。

特性案例分析

查看清單 5 的代碼。
清單 5. 案例代碼

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));
Test test = new Test();
test.i = 1;
out.writeObject(test);
out.flush();
test.i = 2;
out.writeObject(test);
out.close();
ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
                    "result.obj"));
Test t1 = (Test) oin.readObject();
Test t2 = (Test) oin.readObject();
System.out.println(t1.i);
System.out.println(t2.i);

清單 4 的目的是希望將 test 對象兩次保存到 result.obj 文件中,寫入一次以后修改對象屬性值再次保存第二次,然后從 result.obj 中再依次讀出兩個對象,輸出這兩個對象的 i 屬性值。案例代碼的目的原本是希望一次性傳輸對象修改前后的狀態。
結果兩個輸出的都是 1, 原因就是第一次寫入對象以后,第二次再試圖寫的時候,虛擬機根據引用關系知道已經有一個相同對象已經寫入文件,因此只保存第二次寫的引用,所以讀取時,都是第一次保存的對象。讀者在使用一個文件多次 writeObject 需要特別注意這個問題。

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/67875.html

相關文章

  • 小伙子,你真的搞懂 transient 關鍵字了嗎?

    摘要:由以上結果分析可知,靜態變量不能被序列化,示例讀取出來的是在內存中存儲的值。關鍵字總結修飾的變量不能被序列化只作用于實現接口只能用來修飾普通成員變量字段不管有沒有修飾,靜態變量都不能被序列化好了,棧長花了半天時間,終于整理完了。 先解釋下什么是序列化 我們的對象并不只是存在內存中,還需要傳輸網絡,或者保存起來下次再加載出來用,所以需要Java序列化技術。 Java序列化技術正是將對象轉...

    curlyCheng 評論0 收藏0
  • Java 對象列化

    摘要:對象序列化對象序列化機制允許把內存中的對象轉換成與平臺無關的二進制流,從而可以保存到磁盤或者進行網絡傳輸,其它程序獲得這個二進制流后可以將其恢復成原來的對象。 對象序列化 對象序列化機制允許把內存中的Java對象轉換成與平臺無關的二進制流,從而可以保存到磁盤或者進行網絡傳輸,其它程序獲得這個二進制流后可以將其恢復成原來的Java對象。 序列化機制可以使對象可以脫離程序的運行而對立存在 ...

    tianyu 評論0 收藏0
  • Java開發中對象的列化與反列化

    摘要:在中,對象的序列化與反序列化被廣泛應用到遠程方法調用及網絡傳輸中。相關接口及類為了方便開發人員將對象進行序列化及反序列化提供了一套方便的來支持。未實現此接口的類將無法使其任何狀態序列化或反序列化。 序列化與反序列化 序列化 (Serialization)是將對象的狀態信息轉換為可以存儲或傳輸的形式的過程。一般將一個對象存儲至一個儲存媒介,例如檔案或是記億體緩沖等。在網絡傳輸過程中,可以...

    fox_soyoung 評論0 收藏0
  • Java列化

    摘要:的序列化是將一個對象表示成字節序列,該字節序列包括了對象的數據,有關對象的類型信息和存儲在對象中的數據類型。任何實現了接口的類都可以被序列化。一旦對象被序列化或者重新裝配,就會分別調用那兩個方法。 Java序列化 1. 什么是序列化? 序列化是將一個對象的狀態,各屬性的值序列化保存起來,然后在合適的時候通過反序列化獲得。 Java的序列化是將一個對象表示成字節序列,該字節序列包括了對象...

    lbool 評論0 收藏0
  • 淺談Java列化

    摘要:的序列化是將一個對象表示成字節序列,該字節序列包括了對象的數據,有關對象的類型信息和存儲在對象中的數據類型。這個是根據類名接口名成員方法及屬性等來生成一個位的哈希字段,因為增加了字段,因此生成的不一樣了。 Java序列化 什么是序列化? 序列化是將一個對象的狀態,各屬性的值序列化保存起來,然后在合適的時候通過反序列化獲得。 Java的序列化是將一個對象表示成字節序列,該字節序列包括了對...

    winterdawn 評論0 收藏0
  • java列化和反列化說起

    摘要:從的序列化和反序列化說起序列化是將對象的狀態信息轉換為可以存儲或傳輸的形式的過程,而相反的過程就稱為反序列化。當使用接口來進行序列化與反序列化的時候需要開發人員重寫與方法。 從java的序列化和反序列化說起 序列化 (Serialization)是將對象的狀態信息轉換為可以存儲或傳輸的形式的過程,而相反的過程就稱為反序列化。 在java中允許我們創建可復用的對象,但是這些對象僅僅存在j...

    whlong 評論0 收藏0

發表評論

0條評論

GeekQiaQia

|高級講師

TA的文章

閱讀更多
最新活動
閱讀需要支付1元查看
<