您好,登錄后才能下訂單哦!
這篇文章將為大家詳細(xì)講解有關(guān)java中的transient關(guān)鍵字的用法,文章內(nèi)容質(zhì)量較高,因此分享給大家做個(gè)參考,希望大家閱讀完這篇文章后可以有所收獲。
transient是java語(yǔ)言的關(guān)鍵字,變量修飾符,如果用transient聲明一個(gè)實(shí)例變量,當(dāng)對(duì)象存儲(chǔ)時(shí),它的值不需要維持。換句話來(lái)說(shuō)就是,用transient關(guān)鍵字標(biāo)記的成員變量不參與序列化過(guò)程。
在學(xué)習(xí)java的過(guò)程中transient
關(guān)鍵字少見的原因其實(shí)離不開它的作用:transient
關(guān)鍵字的主要作用就是讓某些被transient關(guān)鍵字修飾的成員屬性變量不被序列化。實(shí)際上也正是因此,在學(xué)習(xí)過(guò)程中很少用得上序列化操作,一般都是在實(shí)際開發(fā)中!至于序列化,相信有很多小白童鞋一直迷迷糊糊或者沒有具體的概念,下面本篇文章就介紹一下。
1、何謂序列化?
說(shuō)起序列化,隨之而來(lái)的另一個(gè)概念就是反序列化,小白童鞋不要慌,記住了序列化就相當(dāng)于記住了反序列化,因?yàn)榉葱蛄谢褪切蛄谢催^(guò)來(lái),所以博主建議只記住序列化概念即可,省的搞暈自己。
專業(yè)術(shù)語(yǔ)定義的序列化:
Java提供了一種對(duì)象序列化的機(jī)制。用一個(gè)字節(jié)序列可以表示一個(gè)對(duì)象,該字節(jié)序列包含該對(duì)象的數(shù)據(jù)、對(duì)象的類型和對(duì)象中存儲(chǔ)的屬性等信息。字節(jié)序列寫出到文件之后,相當(dāng)于文件中持久保存了一個(gè)對(duì)象的信息。反之,該字節(jié)序列還可以從文件中讀取回來(lái),重構(gòu)對(duì)象,對(duì)它進(jìn)行反序列化。對(duì)象的數(shù)據(jù)、對(duì)象的類型和對(duì)象中存儲(chǔ)的數(shù)據(jù)信息,都可以用來(lái)在內(nèi)存中創(chuàng)建對(duì)象。
宜春的術(shù)語(yǔ)定義序列化:
序列化: 字節(jié) ——> 對(duì)象
其實(shí),我總結(jié)的就是上面的結(jié)論,如果不理解,直接參照專業(yè)術(shù)語(yǔ)的定義,理解之后就記住我的話就行了,記不住,請(qǐng)打死我(我踢m簡(jiǎn)直就是個(gè)天才)
圖理解序列化:
啥?你不懂啥是字節(jié)?其實(shí),我在一篇IO流的文章里就已經(jīng)介紹了序列化,放心,絕對(duì)特別詳細(xì)~光看文章名字就知道了~
史上最騷最全最詳細(xì)的IO流教程,小白都能看懂!
2、為何要序列化?
從上一節(jié)提到序列化的概念,知道概念之后,我們就必須要知道 為何要序列化了。
講為何要序列化原因之前,博主我舉個(gè)栗子:
就像你去街上買菜,一般操作都是用塑料袋給包裝起來(lái),直到回家要做菜的時(shí)候就把菜給拿出來(lái)。而這一系列操作就像極了序列化和反序列化!
Java中對(duì)象的序列化指的是將對(duì)象轉(zhuǎn)換成以字節(jié)序列的形式來(lái)表示,這些字節(jié)序列包含了對(duì)象的數(shù)據(jù)和信息,一個(gè)序列化后的對(duì)象 可以被寫到數(shù)據(jù)庫(kù)或文件中,也可用于 網(wǎng)絡(luò)傳輸,一般當(dāng)我們使用 緩存cache(內(nèi)存空間不夠有可能會(huì)本地存儲(chǔ)到硬盤)或 遠(yuǎn)程調(diào)用rpc(網(wǎng)絡(luò)傳輸)的時(shí)候,經(jīng)常需要讓我們的實(shí)體類實(shí)現(xiàn)Serializable
接口,目的就是為了讓其可序列化。
● 在開發(fā)過(guò)程中要使用transient關(guān)鍵字修飾的栗子:
如果一個(gè)用戶有一些密碼等信息,為了安全起見,不希望在網(wǎng)絡(luò)操作中被傳輸,這些信息對(duì)應(yīng)的變量就可以加上transient關(guān)鍵字。換句話說(shuō),這個(gè)字段的生命周期僅存于調(diào)用者的內(nèi)存中而不會(huì)寫到磁盤里持久化。
● 在開發(fā)過(guò)程中不需要transient關(guān)鍵字修飾的栗子:
1、類中的字段值可以根據(jù)其它字段推導(dǎo)出來(lái)。
2、看具體業(yè)務(wù)需求,哪些字段不想被序列化;
不知道各位有木有想過(guò)為什么要不被序列化呢?其實(shí)主要是為了節(jié)省存儲(chǔ)空間。優(yōu)化程序!
PS:記得之前看
HashMap
源碼的時(shí)候,發(fā)現(xiàn)有個(gè)字段是用transient
修飾的,我覺得還是有道理的,確實(shí)沒必要對(duì)這個(gè)modCount字段進(jìn)行序列化,因?yàn)闆]有意義,modCount主要用于判斷HashMap是否被修改(像put、remove操作的時(shí)候,modCount
都會(huì)自增),對(duì)于這種變量,一開始可以為任何值,0當(dāng)然也是可以(new出來(lái)、反序列化出來(lái)、或者克隆clone出來(lái)的時(shí)候都是為0的),沒必要持久化其值。
當(dāng)然,序列化后的最終目的是為了反序列化,恢復(fù)成原先的Java對(duì)象,要不然序列化后干嘛呢,就像買菜一樣,用塑料袋包裹最后還是為了方便安全到家再去掉塑料袋,所以序列化后的字節(jié)序列都是可以恢復(fù)成Java對(duì)象的,這個(gè)過(guò)程就是反序列化。
3、序列化與transient的使用
1、需要做序列化的對(duì)象的類,必須實(shí)現(xiàn)序列化接口:Java.lang.Serializable 接口(一個(gè)標(biāo)志接口,沒有任何抽象方法),Java 中大多數(shù)類都實(shí)現(xiàn)了該接口,比如:String
,Integer
類等,不實(shí)現(xiàn)此接口的類將不會(huì)使任何狀態(tài)序列化或反序列化,會(huì)拋NotSerializableException
異常 。
2、底層會(huì)判斷,如果當(dāng)前對(duì)象是 Serializable
的實(shí)例,才允許做序列化,Java對(duì)象 instanceof Serializable
來(lái)判斷。
3、在 Java 中使用對(duì)象流ObjectOutputStream
來(lái)完成序列化以及ObjectInputStream
流反序列化
==ObjectOutputStream:通過(guò) writeObject()方法做序列化操作==
==ObjectInputStream:通過(guò) readObject() 方法做反序列化操作==
4、該類的所有屬性必須是可序列化的。如果有一個(gè)屬性不需要可序列化的,則該屬性必須注明是瞬態(tài)的,使用transient
關(guān)鍵字修飾。
由于字節(jié)嘛所以肯定要涉及流的操作,也就是對(duì)象流也叫序列化流ObjectOutputstream,下面進(jìn)行多種情況分析序列化的操作代碼!
在這里,我真的強(qiáng)烈建議看宜春博客的讀者朋友,請(qǐng)?jiān)囍デ?,切記一眼帶過(guò)或者復(fù)制過(guò)去運(yùn)行就完事了,特別是小白童鞋,相信我!你一定會(huì)有不一樣的收獲。千萬(wàn)不要覺得浪費(fèi)時(shí)間,有時(shí)候慢就是快,宜春親身體會(huì)!
3.1、沒有實(shí)現(xiàn)Serializable接口進(jìn)行序列化情況
package TransientTest; import java.io.*; class UserInfo { //================================注意這里沒有實(shí)現(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、實(shí)現(xiàn)Serializable接口序列化情況
當(dāng)我們加上實(shí)現(xiàn)Serializable接口再運(yùn)行會(huì)發(fā)現(xiàn),項(xiàng)目中出現(xiàn)的userinfo.txt
文件內(nèi)容是這樣的:
其實(shí)這都不是重點(diǎn),重點(diǎn)是序列化操作成功了!
3.3、普通序列化情況
package TransientTest; import java.io.*; class UserInfo implements Serializable{ //第一步實(shí)現(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方法會(huì)拋出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{ //第一步實(shí)現(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方法會(huì)拋出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)然各位可以去試試,這能說(shuō)明什么呢?說(shuō)明被標(biāo)記為transient
的屬性在對(duì)象被序列化的時(shí)候不會(huì)被保存(或者說(shuō)變量不會(huì)持久化)
3.5、static序列化情況
package TransientTest; import java.io.*; class UserInfo implements Serializable{ //第一步實(shí)現(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方法會(huì)拋出ClassNotFoundException System.out.println("序列化之后信息:"+o); } catch (IOException e) { e.printStackTrace(); } } }
運(yùn)行結(jié)果:
序列化之前信息:UserInfo{name='程序員老王', password='123'} 序列化之后信息:UserInfo{name='程序員老王', password='123'}
這個(gè)時(shí)候,你就會(huì)錯(cuò)誤的認(rèn)為static修飾的也被序列化了,其實(shí)不然,實(shí)際上這里很容易被搞暈!明明取出null
(默認(rèn)值)就可以說(shuō)明不會(huì)被序列化,這里明明沒有變成默認(rèn)值,為何還要說(shuō)static
不會(huì)被序列化呢?
實(shí)際上,反序列化后類中static型變量name的值實(shí)際上是當(dāng)前JVM中對(duì)應(yīng)static變量的值,這個(gè)值是JVM中的并不是反序列化得出的。也就是說(shuō)被static修飾的變量并沒有參與序列化!但是咱也不能口說(shuō)無(wú)憑啊,是的,那我們就來(lái)看兩個(gè)程序?qū)Ρ纫幌戮兔靼琢耍?/p>
第一個(gè)程序:這是一個(gè)沒有被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("程序員老過(guò)", "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=程序員老過(guò), psw=456 name=程序員老過(guò), psw=null
從程序運(yùn)行結(jié)果中可以看出,在反序列化之前試著改變name的值為程序員老改,結(jié)果是沒有成功的!
第二個(gè)程序:這是一個(gè)被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("程序員老過(guò)", "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=程序員老過(guò), psw=456 name=程序員老改, psw=null
從程序運(yùn)行結(jié)果中可以看出,在反序列化之前試著改變name的值為程序員老改,結(jié)果是成功的!現(xiàn)在對(duì)比一下兩個(gè)程序是不是就很清晰了?
static關(guān)鍵字修飾的成員屬性優(yōu)于非靜態(tài)成員屬性加載到內(nèi)存中,同時(shí)靜態(tài)也優(yōu)于對(duì)象進(jìn)入到內(nèi)存中,被static修飾的成員變量不能被序列化,序列化的都是對(duì)象,靜態(tài)變量不是對(duì)象狀態(tài)的一部分,因此它不參與序列化。所以將靜態(tài)變量聲明為transient變量是沒有用處的。因此,反序列化后類中static型變量name的值實(shí)際上是當(dāng)前JVM中對(duì)應(yīng)static變量的值,這個(gè)值是JVM中的并不是反序列化得出的。
如果對(duì)static關(guān)鍵字還是不太清楚理解的童鞋可以參考這篇文章,應(yīng)該算是不錯(cuò)的:深入理解static關(guān)鍵字
3.6、final序列化情況
對(duì)于final關(guān)鍵字來(lái)講,final變量將直接通過(guò)值參與序列化,至于代碼程序我就不再貼出來(lái)了,大家可以試著用final修飾驗(yàn)證一下!
主要注意的是final 和transient可以同時(shí)修飾同一個(gè)變量,結(jié)果也是一樣的,對(duì)transient沒有影響,這里主要提一下,希望各位以后在開發(fā)中遇到這些情況不會(huì)滿頭霧水!
4、java類中serialVersionUID作用
既然提到了transient關(guān)鍵字就不得不提到序列化,既然提到了序列化,就不得不提到serialVersionUID
了,它是啥呢?基本上有序列化就會(huì)存在這個(gè)serialVersionUID。
serialVersionUID
適用于Java的序列化機(jī)制。簡(jiǎn)單來(lái)說(shuō),Java的序列化機(jī)制是通過(guò)判斷類的serialVersionUID
來(lái)驗(yàn)證版本一致性的。在進(jìn)行反序列化時(shí),JVM會(huì)把傳來(lái)的字節(jié)流中的serialVersionUID
與本地相應(yīng)實(shí)體類的serialVersionUID
進(jìn)行比較,如果相同就認(rèn)為是一致的,可以進(jìn)行反序列化,否則就會(huì)出現(xiàn)序列化版本不一致的異常,即是InvalidCastException
,在開發(fā)中有時(shí)候可寫可不寫,建議最好還是寫上比較好。
5、transient關(guān)鍵字小結(jié)
1、變量被transient修飾,變量將不會(huì)被序列化
2、transient關(guān)鍵字只能修飾變量,而不能修飾方法和類。
3、被static關(guān)鍵字修飾的變量不參與序列化,一個(gè)靜態(tài)static變量不管是否被transient修飾,均不能被序列化。
4、final變量值參與序列化,final transient同時(shí)修飾變量,final不會(huì)影響transient,一樣不會(huì)參與序列化
第二點(diǎn)需要注意的是:本地變量是不能被transient關(guān)鍵字修飾的。變量如果是用戶自定義類變量,則該類需要實(shí)現(xiàn)Serializable接口
第三點(diǎn)需要注意的是:反序列化后類中static型變量的值實(shí)際上是當(dāng)前JVM中對(duì)應(yīng)static變量的值,這個(gè)值是JVM中的并不是反序列化得出的。
結(jié)語(yǔ):被transient關(guān)鍵字修飾導(dǎo)致不被序列化,其優(yōu)點(diǎn)是可以節(jié)省存儲(chǔ)空間。優(yōu)化程序!隨之而來(lái)的是會(huì)導(dǎo)致被transient修飾的字段會(huì)重新計(jì)算,初始化!
以上就是java中的transient關(guān)鍵字的用法,看完之后是否有所收獲呢?如果想了解更多相關(guān)內(nèi)容,歡迎關(guān)注億速云行業(yè)資訊,感謝各位的閱讀。
免責(zé)聲明:本站發(fā)布的內(nèi)容(圖片、視頻和文字)以原創(chuàng)、轉(zhuǎn)載和分享為主,文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng),如果涉及侵權(quán)請(qǐng)聯(lián)系站長(zhǎng)郵箱:is@yisu.com進(jìn)行舉報(bào),并提供相關(guān)證據(jù),一經(jīng)查實(shí),將立刻刪除涉嫌侵權(quán)內(nèi)容。