Java - transient关键字

小咪咪 2022-05-29 04:59 422阅读 0赞

Java中的对象序列化

在讨论transient之前，有必要先搞清楚Java中序列化的含义；

Java中对象的序列化指的是将对象转换成以字节序列的形式来表示，这些字节序列包含了对象的数据和信息，一个序列化后的对象可以被写到数据库或文件中，也可用于网络传输，一般当我们使用缓存cache（内存空间不够有可能会本地存储到硬盘）或远程调用rpc（网络传输）的时候，经常需要让我们的实体类实现Serializable接口，目的就是为了让其可序列化。

当然，序列化后的最终目的是为了反序列化，恢复成原先的Java对象，所以序列化后的字节序列都是可以恢复成Java对象的，这个过程就是反序列化。

transient关键字

Java中transient关键字的作用，简单地说，就是让某些被修饰的成员属性变量不被序列化，这一看好像很好理解，就是不被序列化，那么什么情况下，一个对象的某些字段不需要被序列化呢？如果有如下情况，可以考虑使用关键字transient修饰：

  1. 类中的字段值可以根据其它字段推导出来，如一个长方形类有三个属性：长度、宽度、面积（示例而已，一般不会这样设计），那么在序列化的时候，面积这个属性就没必要被序列化了；
  2. 其它，看具体业务需求吧，哪些字段不想被序列化；例如，一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

注： HashMap源码中，有个字段是用transient修饰的，我觉得还是有道理的，确实没必要对这个modCount字段进行序列化，因为没有意义，modCount主要用于判断HashMap是否被修改（像put、remove操作的时候，modCount都会自增），对于这种变量，一开始可以为任何值，0当然也是可以（new出来、反序列化出来、或者克隆clone出来的时候都是为0的），没必要持久化其值。

  1. /**
  2.      * The number of times this HashMap has been structurally modified
  3.      * Structural modifications are those that change the number of mappings in
  4.      * the HashMap or otherwise modify its internal structure (e.g.,
  5.      * rehash).  This field is used to make iterators on Collection-views of
  6.      * the HashMap fail-fast.  (See ConcurrentModificationException).
  7.      */
  8.     transient int modCount;

最后，为什么要不被序列化呢，主要是为了节省存储空间，其它的感觉没啥好处，可能还有坏处（有些字段可能需要重新计算，初始化什么的），总的来说，利大于弊。

例如：

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

运行结果为：

  1. read before Serializable: 
  2. username: Alexia
  3. password: 123456
  5. read after Serializable: 
  6. username: Alexia
  7. password: null

密码字段为null，说明被标记为transient的属性在对象被序列化的时候不会被保存。

transient使用小结

  1. 一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
  2. transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。
  3. 被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

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

例如：

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

运行结果：

  1. read before Serializable: 
  2. username: Alexia
  3. password: 123456
  5. read after Serializable: 
  6. username: jmwang
  7. password: null

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

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

思考下面的例子：

  1. import java.io.Externalizable;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.ObjectInput;
  7. import java.io.ObjectInputStream;
  8. import java.io.ObjectOutput;
  9. import java.io.ObjectOutputStream;
  11. /** * @descripiton Externalizable接口的使用 * */
  12. public class ExternalizableTest implements Externalizable { 
  14.     private transient String content = "是的，我将会被序列化，不管我是否被transient关键字修饰";
  16.     @Override
  17.     public void writeExternal(ObjectOutput out) throws IOException {
  18.         out.writeObject(content);
  19.     }
  21.     @Override
  22.     public void readExternal(ObjectInput in) throws IOException,
  23.             ClassNotFoundException {
  24.         content = (String) in.readObject();
  25.     }
  27.     public static void main(String[] args) throws Exception {
  29.         ExternalizableTest et = new ExternalizableTest();
  30.         ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
  31.                 new File("test")));
  32.         out.writeObject(et);
  34.         ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
  35.                 "test")));
  36.         et = (ExternalizableTest) in.readObject();
  37.         System.out.println(et.content);
  39.         out.close();
  40.         in.close();
  41.     }
  42. }

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

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

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

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

参考资料：

  1. https://www.cnblogs.com/chenpi/p/6185773.html
  2. http://www.cnblogs.com/lanxuezaipiao/p/3369962.html

发表评论

表情：
评论列表 （有 0 条评论，422人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java transient关键字

    在 Java 中，序列化用于将对象转换为字节流。字节流由实例的数据以及存储在该实例中的数据类型组成。反序列化执行完全相反的操作。它将字节序列转换为原始对象数据。在序列化过程中，

    左手的ㄟ右手左手的ㄟ右手/ 0 赞/ 103 阅读

    相关 java transient关键字

    transient是用在序列化中的。当我们序列化的过程中，如果我们不想序列化某个字段，那么我们就可以使用这个关键字，jvm就会在序列化的时候自动忽略这个字段的数值。 tran

    Myth丶恋晨Myth丶恋晨/ 0 赞/ 26 阅读

    相关 java transient关键字

    1. transient的作用及使用方法 我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，

    红太狼红太狼/ 0 赞/ 380 阅读

    相关 Java关键字transient

    Java关键字transient transient是类型修饰符，只能用来修饰字段。在对象序列化的过程中，标记为transient的变量不会被序列化。 示例：

    迷南。迷南。/ 0 赞/ 392 阅读

    相关 Java - transient关键字

    Java中的对象序列化 在讨论`transient`之前，有必要先搞清楚Java中序列化的含义； Java中对象的序列化指的是将对象转换成以字节序列的形式来表示，这些字

    小咪咪小咪咪/ 0 赞/ 423 阅读