本篇博客转自 一直在路上

Java transient关键字使用小记

1. transient的作用及使用方法

我们都知道一个对象只要实现了Serilizable接口,这个对象就可以被序列化,Java的这种序列化模式为开发者提供了很多便利,我们可以不必关系具体序列化的过程,只要这个类实现了Serilizable接口,这个类的所有属性和方法都会自动序列化。

然而在实际开发过程中,我们常常会遇到这样的问题,这个类的有些属性需要序列化,而其他属性不需要被序列化,打个比方,如果一个用户有一些敏感信息(如密码,银行卡号等),为了安全起见,不希望在网络操作(主要涉及到序列化操作,本地序列化缓存也适用)中被传输,这些信息对应的变量就可以加上transient关键字。换句话说,这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

总之,java 的transient关键字为我们提供了便利,你只需要实现Serilizable接口,将不需要序列化的属性前添加关键字transient,序列化对象的时候,这个属性就不会序列化到指定的目的地中。

示例code如下:

  1.  
  2. <span style="font-size:12px;">import java.io.FileInputStream;  
  3. import java.io.FileNotFoundException;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8. import java.io.Serializable;  
  9.   
  10. /** 
  11.  * @description 使用transient关键字不序列化某个变量 
  12.  *        注意读取的时候,读取数据的顺序一定要和存放数据的顺序保持一致 
  13.  *         
  14.  * @author Alexia 
  15.  * @date  2013-10-15 
  16.  */  
  17. public class TransientTest {  
  18.       
  19.     public static void main(String[] args) {  
  20.           
  21.         User user = new User();  
  22.         user.setUsername("Alexia");  
  23.         user.setPasswd("123456");  
  24.           
  25.         System.out.println("read before Serializable: ");  
  26.         System.out.println("username: " + user.getUsername());  
  27.         System.err.println("password: " + user.getPasswd());  
  28.           
  29.         try {  
  30.             ObjectOutputStream os = new ObjectOutputStream(  
  31.                     new FileOutputStream("C:/user.txt"));  
  32.             os.writeObject(user); // 将User对象写进文件  
  33.             os.flush();  
  34.             os.close();  
  35.         } catch (FileNotFoundException e) {  
  36.             e.printStackTrace();  
  37.         } catch (IOException e) {  
  38.             e.printStackTrace();  
  39.         }  
  40.         try {  
  41.             ObjectInputStream is = new ObjectInputStream(new FileInputStream(  
  42.                     "C:/user.txt"));  
  43.             user = (User) is.readObject(); // 从流中读取User的数据  
  44.             is.close();  
  45.               
  46.             System.out.println("\nread after Serializable: ");  
  47.             System.out.println("username: " + user.getUsername());  
  48.             System.err.println("password: " + user.getPasswd());  
  49.               
  50.         } catch (FileNotFoundException e) {  
  51.             e.printStackTrace();  
  52.         } catch (IOException e) {  
  53.             e.printStackTrace();  
  54.         } catch (ClassNotFoundException e) {  
  55.             e.printStackTrace();  
  56.         }  
  57.     }  
  58. }  
  59.   
  60. class User implements Serializable {  
  61.     private static final long serialVersionUID = 8294180014912103005L;    
  62.       
  63.     private String username;  
  64.     private transient String passwd;  
  65.       
  66.     public String getUsername() {  
  67.         return username;  
  68.     }  
  69.       
  70.     public void setUsername(String username) {  
  71.         this.username = username;  
  72.     }  
  73.       
  74.     public String getPasswd() {  
  75.         return passwd;  
  76.     }  
  77.       
  78.     public void setPasswd(String passwd) {  
  79.         this.passwd = passwd;  
  80.     }  
  81.   
  82. }</span>  

输出为:

  1.  
  2. <span style="font-size:12px;">read before Serializable:   
  3. username: Alexia  
  4. password: 123456  
  5.   
  6. read after Serializable:   
  7. username: Alexia  
  8. password: null</span>  

密码字段为null,说明反序列化时根本没有从文件中获取到信息。

2. transient使用小结

1)一旦变量被transient修饰,变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问。

2)transient关键字只能修饰变量,而不能修饰方法和类。注意,本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量,则该类需要实现Serializable接口。

3)被transient关键字修饰的变量不再能被序列化,一个静态变量不管是否被transient修饰,均不能被序列化。

第三点可能有些人很迷惑,因为发现在User类中的username字段前加上transient关键字后,程序运行结果依然不变,即static类型的username也读出来为“Alexia”了,这不与第三点说的矛盾吗?实际上是这样的:第三点确实没错(一个静态变量不管是否被transient修饰,均不能被序列化),反序列化后类中static型变量username的值为当前JVM中对应static变量的值,这个值是JVM中的不是反序列化得出的,不相信?好吧,下面我来证明:

  1.  
  2. <span style="font-size:12px;">import java.io.FileInputStream;  
  3. import java.io.FileNotFoundException;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8. import java.io.Serializable;  
  9.   
  10. /** 
  11.  * @description 使用transient关键字不序列化某个变量 
  12.  *        注意读取的时候,读取数据的顺序一定要和存放数据的顺序保持一致 
  13.  *         
  14.  * @author Alexia 
  15.  * @date  2013-10-15 
  16.  */  
  17. public class TransientTest {  
  18.       
  19.     public static void main(String[] args) {  
  20.           
  21.         User user = new User();  
  22.         user.setUsername("Alexia");  
  23.         user.setPasswd("123456");  
  24.           
  25.         System.out.println("read before Serializable: ");  
  26.         System.out.println("username: " + user.getUsername());  
  27.         System.err.println("password: " + user.getPasswd());  
  28.           
  29.         try {  
  30.             ObjectOutputStream os = new ObjectOutputStream(  
  31.                     new FileOutputStream("C:/user.txt"));  
  32.             os.writeObject(user); // 将User对象写进文件  
  33.             os.flush();  
  34.             os.close();  
  35.         } catch (FileNotFoundException e) {  
  36.             e.printStackTrace();  
  37.         } catch (IOException e) {  
  38.             e.printStackTrace();  
  39.         }  
  40.         try {  
  41.             // 在反序列化之前改变username的值  
  42.             User.username = "jmwang";  
  43.               
  44.             ObjectInputStream is = new ObjectInputStream(new FileInputStream(  
  45.                     "C:/user.txt"));  
  46.             user = (User) is.readObject(); // 从流中读取User的数据  
  47.             is.close();  
  48.               
  49.             System.out.println("\nread after Serializable: ");  
  50.             System.out.println("username: " + user.getUsername());  
  51.             System.err.println("password: " + user.getPasswd());  
  52.               
  53.         } catch (FileNotFoundException e) {  
  54.             e.printStackTrace();  
  55.         } catch (IOException e) {  
  56.             e.printStackTrace();  
  57.         } catch (ClassNotFoundException e) {  
  58.             e.printStackTrace();  
  59.         }  
  60.     }  
  61. }  
  62.   
  63. class User implements Serializable {  
  64.     private static final long serialVersionUID = 8294180014912103005L;    
  65.       
  66.     public static String username;  
  67.     private transient String passwd;  
  68.       
  69.     public String getUsername() {  
  70.         return username;  
  71.     }  
  72.       
  73.     public void setUsername(String username) {  
  74.         this.username = username;  
  75.     }  
  76.       
  77.     public String getPasswd() {  
  78.         return passwd;  
  79.     }  
  80.       
  81.     public void setPasswd(String passwd) {  
  82.         this.passwd = passwd;  
  83.     }  
  84.   
  85. }</span>  

运行结果为:

  1.  
  2. <span style="font-size:12px;">read before Serializable:   
  3. username: Alexia  
  4. password: 123456  
  5.   
  6. read after Serializable:   
  7. username: jmwang  
  8. password: null</span>  

这说明反序列化后类中static型变量username的值为当前JVM中对应static变量的值,为修改后jmwang,而不是序列化时的值Alexia。

3. transient使用细节——被transient关键字修饰的变量真的不能被序列化吗?

思考下面的例子:

  1.  
  2. <span style="font-size:12px;">import java.io.Externalizable;  
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.ObjectInput;  
  8. import java.io.ObjectInputStream;  
  9. import java.io.ObjectOutput;  
  10. import java.io.ObjectOutputStream;  
  11.   
  12. /** 
  13.  * @descripiton Externalizable接口的使用 
  14.  *  
  15.  * @author Alexia 
  16.  * @date 2013-10-15 
  17.  * 
  18.  */  
  19. public class ExternalizableTest implements Externalizable {  
  20.   
  21.     private transient String content = "是的,我将会被序列化,不管我是否被transient关键字修饰";  
  22.   
  23.     @Override  
  24.     public void writeExternal(ObjectOutput out) throws IOException {  
  25.         out.writeObject(content);  
  26.     }  
  27.   
  28.     @Override  
  29.     public void readExternal(ObjectInput in) throws IOException,  
  30.             ClassNotFoundException {  
  31.         content = (String) in.readObject();  
  32.     }  
  33.   
  34.     public static void main(String[] args) throws Exception {  
  35.           
  36.         ExternalizableTest et = new ExternalizableTest();  
  37.         ObjectOutput out = new ObjectOutputStream(new FileOutputStream(  
  38.                 new File("test")));  
  39.         out.writeObject(et);  
  40.   
  41.         ObjectInput in = new ObjectInputStream(new FileInputStream(new File(  
  42.                 "test")));  
  43.         et = (ExternalizableTest) in.readObject();  
  44.         System.out.println(et.content);  
  45.   
  46.         out.close();  
  47.         in.close();  
  48.     }  
  49. }</span>  

content变量会被序列化吗?好吧,我把答案都输出来了,是的,运行结果就是:

  1. 是的,我将会被序列化,不管我是否被transient关键字修饰

这是为什么呢,不是说类的变量被transient关键字修饰以后将不能序列化了吗?

我们知道在Java中,对象的序列化可以通过实现两种接口来实现,若实现的是Serializable接口,则所有的序列化将会自动进行,若实现的是Externalizable接口,则没有任何东西可以自动序列化,需要在writeExternal方法中进行手工指定所要序列化的变量,这与是否被transient修饰无关。因此第二个例子输出的是变量content初始化的内容,而不是null。

transient关键字的用法的更多相关文章

  1. Java基础之instanceof和transient关键字用法

    instanceof 用于检测指定对象是否是某个类(本类.父类.子类.接口)的实例.Java中的instanceof也称为类型比较运算符,因为它将类型与实例进行比较. 返回true或false. 如果 ...

  2. Java对象表示方式1:序列化、反序列化和transient关键字的作用

    平时我们在Java内存中的对象,是无法进行IO操作或者网络通信的,因为在进行IO操作或者网络通信的时候,人家根本不知道内存中的对象是个什么东西,因此必须将对象以某种方式表示出来,即存储对象中的状态.一 ...

  3. 序列化、反序列化和transient关键字的作用

    引言 将 Java 对象序列化为二进制文件的 Java 序列化技术是 Java 系列技术中一个较为重要的技术点,在大部分情况下,开发人员只需要了解被序列化的类需要实现 Serializable 接口, ...

  4. transient关键字和serialVersionUID

    此文章很大部分转载于Java的架构师技术栈微信公众号,博主均测试通过加上自己理解写出 最近阅读java集合的源码,发现transient关键字,就了解了一下他的用法,transient关键字一般在实现 ...

  5. transient关键字的作用

    代码如下: import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutpu ...

  6. Java transient 关键字

    1)一旦变量被transient修饰,变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问. 2)transient关键字只能修饰变量,而不能修饰方法和类.注意,本地变量是不能被trans ...

  7. 序列化,反序列化和transient关键字

    一.序列化和反序列化的概念 序列化:指把java对象转换为字节序列的过程. 反序列化:指把字节序列恢复为java对象的过程. 对象的序列化主要有两种用途: 1) 把对象的字节序列保存到硬盘上,通常存放 ...

  8. 关于Java中的transient关键字

    Java中的transient关键字是在序列化时候用的,如果用transient修饰变量,那么该变量不会被序列化. 下面的例子中创建了一个Student类,有三个成员变量:id,name,age.ag ...

  9. [转载]C#中as和is关键字的用法

    这篇文章主要介绍了C#中as和is关键字的用法的相关资料,需要的朋友可以参考下. 原文链接:http://www.jb51.net/article/80944.htm#comments  在程序中,进 ...

随机推荐

  1. Jquery 搭配 css 使用,简单有效

    前几篇博客中讲了Jquery的基础和点击实际,下面来说一下和css搭配着来怎么做 还是和往常一样,举个例子 好几个方块,然后设置颜色 <!DOCTYPE html PUBLIC "-/ ...

  2. 记一个mvn奇怪错误: Archive for required library: 'D:/mvn/repos/junit/junit/3.8.1/junit-3.8.1.jar' in project 'xxx' cannot be read or is not a valid ZIP file

    我的maven 项目有一个红色感叹号, 而且Problems 存在 errors : Description Resource Path Location Type Archive for requi ...

  3. TinyWeb v1.0 正式完成第一个Release版本(功能基于 libuv 跨平台库)

    使用方法很简单,很容易融入现有项目,使现有项目拥有Web网站功能和WebSocket,以及Socket直连! 并且包含了一个跨平台(windows/linux)工具集合; 嗯,也挺棒的^,^ 在项目中 ...

  4. In-Memory:内存优化表 DMV

    在内存优化表的DMV中,有两个对象ID(Object ID): xtp_object_id 是内部的内存优化表(Internal Memory-Optimized Table)的ID,在对象的整个生命 ...

  5. CSS HTML元素布局及Display属性

    本篇文章主要介绍HTML的内联元素.块级元素的分类与布局,以及dispaly属性对布局的影响. 目录 1. HTML 元素分类:介绍内联元素.块级元素的分类. 2. HTML 元素布局:介绍内联元素. ...

  6. 【热门技术】EventBus 3.0,让事件订阅更简单,从此告别组件消息传递烦恼~

    一.写在前面 还在为时间接收而烦恼吗?还在为各种组件间的消息传递烦恼吗?EventBus 3.0,专注于android的发布.订阅事件总线,让各组件间的消息传递更简单!完美替代Intent,Handl ...

  7. 神技!微信小程序(应用号)抢先入门教程(附最新案例DEMO-豆瓣电影)持续更新

    微信小程序 Demo(豆瓣电影) 由于时间的关系,没有办法写一个完整的说明,后续配合一些视频资料,请持续关注 官方文档:https://mp.weixin.qq.com/debug/wxadoc/de ...

  8. 数塔问题(DP算法)自底向上计算最大值

    Input 输入数据首先包括一个整数C,表示测试实例的个数,每个测试实例的第一行是一个整数N(1 <= N <= 100),表示数塔的高度,接下来用N行数字表示数塔,其中第i行有个i个整数 ...

  9. 如何理解DT将是未来IT的转型之路?

    如今的IT面临着内忧外患的挑战. 一方面,企业多多少少都建立了信息化,有些企业或集团甚至会有数几十个分公司,包含直销.代理.零售以及第三方物流等多种业态.越是复杂的业务,信息化建设越困难,比如运用大量 ...

  10. grep 查找bash脚本中的注释代码

    出于安全性的考虑,不建议在bash脚本中注释掉不使用的代码.也就是说如果某段代码不使用了,那么应该删除掉,而不是简单地注释掉.假如你突然意识到这一点,而以前并没有遵从这个原则,现在需要找出脚本中的注释 ...