java中的transient關(guān)鍵字解讀
1、何謂序列化？
說起序列化，隨之而來的另一個概念就是反序列化，小白童鞋不要慌，記住了序列化就相當(dāng)于記住了反序列化，因為反序列化就是序列化反過來，所以博主建議只記住序列化概念即可，省的搞暈自己。
專業(yè)術(shù)語定義的序列化：
Java提供了一種對象序列化的機(jī)制。用一個字節(jié)序列可以表示一個對象，該字節(jié)序列包含該對象的數(shù)據(jù)、對象的類型和對象中存儲的屬性等信息。字節(jié)序列寫出到文件之后，相當(dāng)于文件中持久保存了一個對象的信息。反之，該字節(jié)序列還可以從文件中讀取回來，重構(gòu)對象，對它進(jìn)行反序列化。對象的數(shù)據(jù)、對象的類型和對象中存儲的數(shù)據(jù)信息，都可以用來在內(nèi)存中創(chuàng)建對象。
宜春的術(shù)語定義序列化：
序列化： 字節(jié) ——> 對象
其實，我總結(jié)的就是上面的結(jié)論，如果不理解，直接參照專業(yè)術(shù)語的定義，理解之后就記住我的話就行了，記不住，請打死我（我踢m簡直就是個天才）
圖理解序列化：
啥？你不懂啥是字節(jié)？其實，我在一篇IO流的文章里就已經(jīng)介紹了序列化，放心，絕對特別詳細(xì)光看文章名字就知道了
史上最騷最全最詳細(xì)的IO流教程，小白都能看懂！
2、為何要序列化？
從上一節(jié)提到序列化的概念，知道概念之后，我們就必須要知道 為何要序列化了。
講為何要序列化原因之前，博主我舉個栗子：
就像你去街上買菜，一般操作都是用塑料袋給包裝起來，直到回家要做菜的時候就把菜給拿出來。而這一系列操作就像極了序列化和反序列化！
Java中對象的序列化指的是將對象轉(zhuǎn)換成以字節(jié)序列的形式來表示，這些字節(jié)序列包含了對象的數(shù)據(jù)和信息，一個序列化后的對象 可以被寫到數(shù)據(jù)庫或文件中，也可用于 網(wǎng)絡(luò)傳輸，一般當(dāng)我們使用 緩存cache（內(nèi)存空間不夠有可能會本地存儲到硬盤）或 遠(yuǎn)程調(diào)用rpc（網(wǎng)絡(luò)傳輸）的時候，經(jīng)常需要讓我們的實體類實現(xiàn) Serializable 接口，目的就是為了讓其可序列化。
在開發(fā)過程中要使用transient關(guān)鍵字修飾的栗子：
如果一個用戶有一些密碼等信息，為了安全起見，不希望在網(wǎng)絡(luò)操作中被傳輸，這些信息對應(yīng)的變量就可以加上transient關(guān)鍵字。換句話說，這個字段的生命周期僅存于調(diào)用者的內(nèi)存中而不會寫到磁盤里持久化。
在開發(fā)過程中不需要transient關(guān)鍵字修飾的栗子：
1、類中的字段值可以根據(jù)其它字段推導(dǎo)出來。
2、看具體業(yè)務(wù)需求，哪些字段不想被序列化；
不知道各位有木有想過為什么要不被序列化呢？其實主要是為了節(jié)省存儲空間。優(yōu)化程序！
PS：記得之前看 HashMap 源碼的時候，發(fā)現(xiàn)有個字段是用 transient 修飾的，我覺得還是有道理的，確實沒必要對這個modCount字段進(jìn)行序列化，因為沒有意義，modCount主要用于判斷HashMap是否被修改（像put、remove操作的時候， modCount 都會自增），對于這種變量，一開始可以為任何值，0當(dāng)然也是可以（new出來、反序列化出來、或者克隆clone出來的時候都是為0的），沒必要持久化其值。
當(dāng)然，序列化后的最終目的是為了反序列化，恢復(fù)成原先的Java對象，要不然序列化后干嘛呢，就像買菜一樣，用塑料袋包裹最后還是為了方便安全到家再去掉塑料袋，所以序列化后的字節(jié)序列都是可以恢復(fù)成Java對象的，這個過程就是反序列化。
3、序列化與transient的使用
1、需要做序列化的對象的類，必須實現(xiàn)序列化接口：Java.lang.Serializable 接口（一個標(biāo)志接口，沒有任何抽象方法），Java 中大多數(shù)類都實現(xiàn)了該接口，比如： String ， Integer 類等，不實現(xiàn)此接口的類將不會使任何狀態(tài)序列化或反序列化，會拋 NotSerializableException 異常 。
2、底層會判斷，如果當(dāng)前對象是 Serializable 的實例，才允許做序列化，Java對象 instanceof Serializable 來判斷。
3、在 Java 中使用對象流 ObjectOutputStream 來完成序列化以及 ObjectInputStream 流反序列化
ObjectOutputStream:通過 writeObject()方法做序列化操作
ObjectInputStream:通過 readObject() 方法做反序列化操作
4、該類的所有屬性必須是可序列化的。如果有一個屬性不需要可序列化的，則該屬性必須注明是瞬態(tài)的，使用 transient 關(guān)鍵字修飾。
由于字節(jié)嘛所以肯定要涉及流的操作，也就是對象流也叫序列化流ObjectOutputstream，下面進(jìn)行多種情況分析序列化的操作代碼！
在這里，我真的強(qiáng)烈建議看宜春博客的讀者朋友，請試著去敲，切記一眼帶過或者復(fù)制過去運(yùn)行就完事了，特別是小白童鞋，相信我！你一定會有不一樣的收獲。千萬不要覺得浪費時間，有時候慢就是快，宜春親身體會！
3.1、沒有實現(xiàn)Serializable接口進(jìn)行序列化情況
package TransientTest;
import java.io.*;
class UserInfo { //================================注意這里沒有實現(xiàn)Serializable接口
private String name;
private transient String password;
public UserInfo(String name,String psw) {
this.name = name;
this.password=psw;
}
@Override
public String toString() {
return "UserInfo{" +
"name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
}
public class TransientDemo {
public static void main(String[] args) {
UserInfo userInfo=new UserInfo("老王","123");
System.out.println("序列化之前信息："+userInfo);
try {
ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt"));
output.writeObject(new UserInfo("老王","123"));
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}運(yùn)行結(jié)果
3.2、實現(xiàn)Serializable接口序列化情況
當(dāng)我們加上實現(xiàn)Serializable接口再運(yùn)行會發(fā)現(xiàn)，項目中出現(xiàn)的 userinfo.txt 文件內(nèi)容是這樣的:
其實這都不是重點，重點是序列化操作成功了！
3.3、普通序列化情況
package TransientTest;
import java.io.*;
class UserInfo implements Serializable{ //第一步實現(xiàn)Serializable接口
private String name;
private String password;//都是普通屬性==============================
public UserInfo(String name,String psw) {
this.name = name;
this.password=psw;
}
@Override
public String toString() {
return "UserInfo{" +
"name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
}
public class TransientDemo {
public static void main(String[] args) throws ClassNotFoundException {
UserInfo userInfo=new UserInfo("程序員老王","123");
System.out.println("序列化之前信息："+userInfo);
try {
ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt")); //第二步開始序列化操作
output.writeObject(new UserInfo("程序員老王","123"));
output.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
ObjectInputStream input=new ObjectInputStream(new FileInputStream("userinfo.txt"));//第三步開始反序列化操作
Object o = input.readObject();//ObjectInputStream的readObject方法會拋出ClassNotFoundException
System.out.println("序列化之后信息："+o);
} catch (IOException e) {
e.printStackTrace();
}
}
}運(yùn)行結(jié)果：
序列化之前信息：UserInfo{name='程序員老王', password='123'}
序列化之后信息：UserInfo{name='程序員老王', password='123'}
3.4、transient序列化情況
package TransientTest;
import java.io.*;
class UserInfo implements Serializable{ //第一步實現(xiàn)Serializable接口
private String name;
private transient String password; //特別注意：屬性由transient關(guān)鍵字修飾===========
public UserInfo(String name,String psw) {
this.name = name;
this.password=psw;
}
@Override
public String toString() {
return "UserInfo{" +
"name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
}
public class TransientDemo {
public static void main(String[] args) throws ClassNotFoundException {
UserInfo userInfo=new UserInfo("程序員老王","123");
System.out.println("序列化之前信息："+userInfo);
try {
ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt")); //第二步開始序列化操作
output.writeObject(new UserInfo("程序員老王","123"));
output.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
ObjectInputStream input=new ObjectInputStream(new FileInputStream("userinfo.txt"));//第三步開始反序列化操作
Object o = input.readObject();//ObjectInputStream的readObject方法會拋出ClassNotFoundException
System.out.println("序列化之后信息："+o);
} catch (IOException e) {
e.printStackTrace();
}
}
}運(yùn)行結(jié)果：
序列化之前信息：UserInfo{name='程序員老王', password='123'}
序列化之后信息：UserInfo{name='程序員老王', password='null'}
特別注意結(jié)果，添加transient修飾的屬性值為默認(rèn)值 null ！如果被transient修飾的屬性為int類型，那它被序列化之后值一定是0，當(dāng)然各位可以去試試，這能說明什么呢？說明被標(biāo)記為 transient 的屬性在對象被序列化的時候不會被保存(或者說變量不會持久化)
3.5、static序列化情況
package TransientTest;
import java.io.*;
class UserInfo implements Serializable{ //第一步實現(xiàn)Serializable接口
private String name;
private static String password; //特別注意：屬性由static關(guān)鍵字修飾==============
public UserInfo(String name, String psw) {
this.name = name;
this.password=psw;
}
@Override
public String toString() {
return "UserInfo{" +
"name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
}
public class TransientDemo {
public static void main(String[] args) throws ClassNotFoundException {
UserInfo userInfo=new UserInfo("程序員老王","123");
System.out.println("序列化之前信息："+userInfo);
try {
ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt")); //第二步開始序列化操作
output.writeObject(new UserInfo("程序員老王","123"));
output.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
ObjectInputStream input=new ObjectInputStream(new FileInputStream("userinfo.txt"));//第三步開始反序列化操作
Object o = input.readObject();//ObjectInputStream的readObject方法會拋出ClassNotFoundException
System.out.println("序列化之后信息："+o);
} catch (IOException e) {
e.printStackTrace();
}
}
}運(yùn)行結(jié)果：
序列化之前信息：UserInfo{name='程序員老王', password='123'}
序列化之后信息：UserInfo{name='程序員老王', password='123'}
這個時候，你就會錯誤的認(rèn)為static修飾的也被序列化了，其實不然，實際上這里很容易被搞暈！明明取出 null （默認(rèn)值）就可以說明不會被序列化，這里明明沒有變成默認(rèn)值，為何還要說 static 不會被序列化呢？
實際上，反序列化后類中static型變量name的值實際上是當(dāng)前JVM中對應(yīng)static變量的值，這個值是JVM中的并不是反序列化得出的。也就是說被static修飾的變量并沒有參與序列化！但是咱也不能口說無憑啊，是的，那我們就來看兩個程序?qū)Ρ纫幌戮兔靼琢耍?/p>
第一個程序：這是一個沒有被static修飾的name屬性程序：
package Thread;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class UserInfo implements Serializable {
private String name;
private transient String psw;
public UserInfo(String name, String psw) {
this.name = name;
this.psw = psw;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPsw() {
return psw;
}
public void setPsw(String psw) {
this.psw = psw;
}
public String toString() {
return "name=" + name + ", psw=" + psw;
}
}
public class TestTransient {
public static void main(String[] args) {
UserInfo userInfo = new UserInfo("程序員老過", "456");
System.out.println(userInfo);
try {
// 序列化，被設(shè)置為transient的屬性沒有被序列化
ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("UserInfo.txt"));
o.writeObject(userInfo);
o.close();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
try {
//在反序列化之前改變name的值 =================================注意這里的代碼
userInfo.setName("程序員老改");
// 重新讀取內(nèi)容
ObjectInputStream in = new ObjectInputStream(new FileInputStream("UserInfo.txt"));
UserInfo readUserInfo = (UserInfo) in.readObject();
//讀取后psw的內(nèi)容為null
System.out.println(readUserInfo.toString());
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}運(yùn)行結(jié)果：
name=程序員老過, psw=456
name=程序員老過, psw=null
從程序運(yùn)行結(jié)果中可以看出，在反序列化之前試著改變name的值為程序員老改，結(jié)果是沒有成功的！
第二個程序：這是一個被static修飾的name屬性程序：
package Thread;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class UserInfo implements Serializable {
private static final long serialVersionUID = 996890129747019948L;
private static String name;
private transient String psw;
public UserInfo(String name, String psw) {
this.name = name;
this.psw = psw;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPsw() {
return psw;
}
public void setPsw(String psw) {
this.psw = psw;
}
public String toString() {
return "name=" + name + ", psw=" + psw;
}
}
public class TestTransient {
public static void main(String[] args) {
UserInfo userInfo = new UserInfo("程序員老過", "456");
System.out.println(userInfo);
try {
// 序列化，被設(shè)置為transient的屬性沒有被序列化
ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("UserInfo.txt"));
o.writeObject(userInfo);
o.close();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
try {
//在反序列化之前改變name的值
userInfo.setName("程序員老改");
// 重新讀取內(nèi)容
ObjectInputStream in = new ObjectInputStream(new FileInputStream("UserInfo.txt"));
UserInfo readUserInfo = (UserInfo) in.readObject();
//讀取后psw的內(nèi)容為null
System.out.println(readUserInfo.toString());
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}運(yùn)行結(jié)果：
name=程序員老過, psw=456
name=程序員老改, psw=null
從程序運(yùn)行結(jié)果中可以看出，在反序列化之前試著改變name的值為程序員老改，結(jié)果是成功的！現(xiàn)在對比一下兩個程序是不是就很清晰了？
static關(guān)鍵字修飾的成員屬性優(yōu)于非靜態(tài)成員屬性加載到內(nèi)存中，同時靜態(tài)也優(yōu)于對象進(jìn)入到內(nèi)存中，被static修飾的成員變量不能被序列化，序列化的都是對象，靜態(tài)變量不是對象狀態(tài)的一部分，因此它不參與序列化。所以將靜態(tài)變量聲明為transient變量是沒有用處的。因此，反序列化后類中static型變量name的值實際上是當(dāng)前JVM中對應(yīng)static變量的值，這個值是JVM中的并不是反序列化得出的。
3.6、final序列化情況
對于final關(guān)鍵字來講，final變量將直接通過值參與序列化，至于代碼程序我就不再貼出來了，大家可以試著用final修飾驗證一下！
主要注意的是final 和transient可以同時修飾同一個變量，結(jié)果也是一樣的，對transient沒有影響，這里主要提一下，希望各位以后在開發(fā)中遇到這些情況不會滿頭霧水！
4、java類中serialVersionUID作用
既然提到了transient關(guān)鍵字就不得不提到序列化，既然提到了序列化，就不得不提到serialVersionUID了，它是啥呢？基本上有序列化就會存在這個serialVersionUID。
serialVersionUID適用于Java的序列化機(jī)制。簡單來說，Java的序列化機(jī)制是通過判斷類的serialVersionUID來驗證版本一致性的。在進(jìn)行反序列化時，JVM會把傳來的字節(jié)流中的serialVersionUID與本地相應(yīng)實體類的serialVersionUID進(jìn)行比較，如果相同就認(rèn)為是一致的，可以進(jìn)行反序列化，否則就會出現(xiàn)序列化版本不一致的異常，即是InvalidCastException，在開發(fā)中有時候可寫可不寫，建議最好還是寫上比較好。
5、transient關(guān)鍵字小結(jié)
1、變量被transient修飾，變量將不會被序列化
2、transient關(guān)鍵字只能修飾變量，而不能修飾方法和類。
3、被static關(guān)鍵字修飾的變量不參與序列化，一個靜態(tài)static變量不管是否被transient修飾，均不能被序列化。
4、final變量值參與序列化，final transient同時修飾變量，final不會影響transient，一樣不會參與序列化
第二點需要注意的是：本地變量是不能被transient關(guān)鍵字修飾的。變量如果是用戶自定義類變量，則該類需要實現(xiàn)Serializable接口
第三點需要注意的是：反序列化后類中static型變量的值實際上是當(dāng)前JVM中對應(yīng)static變量的值，這個值是JVM中的并不是反序列化得出的。
結(jié)語：被transient關(guān)鍵字修飾導(dǎo)致不被序列化，其優(yōu)點是可以節(jié)省存儲空間。
優(yōu)化程序！隨之而來的是會導(dǎo)致被transient修飾的字段會重新計算，初始化！
到此這篇關(guān)于java中的transient關(guān)鍵字解讀的文章就介紹到這了,更多相關(guān)java的transient內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
由于項目需要,需要對二進(jìn)制文件進(jìn)行讀取,所以這篇文章主要給大家介紹了關(guān)于JAVA讀取二進(jìn)制文件以及畫圖的相關(guān)資料,文中通過實例代碼介紹的非常詳細(xì),需要的朋友可以參考下2023-07-07
springboot多數(shù)據(jù)源使用@Qualifier自動注入無效的解決
這篇文章主要介紹了springboot多數(shù)據(jù)源使用@Qualifier自動注入無效的解決，具有很好的參考價值，希望對大家有所幫助。也希望大家多多支持腳本之家2021-11-11
Spring事務(wù)中的事務(wù)傳播行為使用方式詳解
Spring框架作為一個輕量級的開源框架，在企業(yè)應(yīng)用開發(fā)中被廣泛使用，在Spring事務(wù)管理中，事務(wù)傳播行為是非常重要的一部分，它定義了方法如何參與到已經(jīng)存在的事務(wù)中或者如何開啟新的事務(wù)，本文將詳細(xì)介紹Spring事務(wù)中的幾種事務(wù)傳播行為，詳細(xì)講解具體使用方法2023-06-06
Jmeter 中 CSV 如何參數(shù)化測試數(shù)據(jù)并實現(xiàn)自動斷言示例詳解
這篇文章主要介紹了Jmeter 中 CSV 如何參數(shù)化測試數(shù)據(jù)并實現(xiàn)自動斷言,本文通過示例給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-07-07
springboot獲取properties屬性值的多種方式總結(jié)
這篇文章主要介紹了springboot獲取properties屬性值的多種方式總結(jié)，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-03-03
簡單說說Java SE、Java EE、Java ME三者之間的區(qū)別
本篇文章小編就為大家簡單說說Java SE、Java EE、Java ME三者之間的區(qū)別。需要的朋友可以過來參考下，希望對大家有所幫助2013-10-10
在Java中對象以引用來指向JVM的內(nèi)存區(qū)塊,這里我們總結(jié)了強(qiáng)引用、軟引用、弱引用和假象引用(幽靈引用),下面這篇文章主要給大家介紹了關(guān)于jvm中引用類型的相關(guān)資料,需要的朋友可以參考下2024-04-04
發(fā)現(xiàn)了一篇JDK作者的論文《The?java.util.concurrent?Synchronizer?Framework》主要描述了作者對AbstractQueuedSynchronizer同步器框架的設(shè)計和實現(xiàn)。權(quán)威性毋庸置疑！自然需要拜讀一下，配上中文翻譯，希望大家能有所收獲2022-02-02
當(dāng)我們學(xué)習(xí)一門編程語言的時候，我們都會先學(xué)如何輸出Hello World！本文通過幾個例子給大家介紹輸出Hello World的代碼，感興趣的朋友一起看看吧2021-06-06
在閱讀AtomicInteger的源碼時，看到了這個類：sum.msic.Unsafe，之前從沒見過。所以花了點時間研究了下，下面這篇文章主要給大家介紹了關(guān)于Java中Unsafe類的相關(guān)資料，需要的朋友可以參考借鑒，下面來一起學(xué)習(xí)學(xué)習(xí)吧2018-05-05