Java transient关键字

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想   
用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。   

transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。  

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

首先，让我们看一些Java serialization的代码： 

import java.util.Date;

public class LoggingInfo implements java.io.Serializable {  

    private Date loggingDate = new Date();  

    private String uid;  

    private transient String pwd;  
     
    LoggingInfo(String user, String password) {  
        uid = user;  
        pwd = password;  
    }  

    public String toString() {  
        String password=null;  
        if(pwd == null) {  
            password = "NOT SET";  
        }  
        else {  
            password = pwd;  
        }  
        return"logon info: \n   " + "user: " + uid +  
            "\n   logging date : " + loggingDate.toString() +  
            "\n   password: " + password;  
    }  
} 

 现在我们创建一个这个类的实例，并且串行化(serialize)它 ,然后将这个串行化对象写如磁盘。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class TestTransient implements java.io.Serializable {  
    
    public static void main(String[] args) {
        LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");  
        System.out.println(logInfo.toString());  
        try {  
           ObjectOutputStream o = new ObjectOutputStream(  
                        new FileOutputStream("logInfo.out"));  
           o.writeObject(logInfo);  
           o.close();  
        } catch(Exception e) {
            //deal with exception 
        } 
        //To read the object back, we can write    
        try {  
           ObjectInputStream in =new ObjectInputStream(  
                        new FileInputStream("logInfo.out"));  
           LoggingInfo logInfoIn = (LoggingInfo)in.readObject();  
           System.out.println(logInfoIn.toString());  
        } catch(Exception e) {
            //deal with exception 
        }
    }
} 

输出结果：

logon info: 
   user: MIKE
   logging date : Wed Apr 13 22:13:44 CST 2016
   password: MECHANICS
logon info: 
   user: MIKE
   logging date : Wed Apr 13 22:13:44 CST 2016
   password: NOT SET

注意：

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

2）transient关键字只能修饰字段，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，

则该类需要实现Serializable接口。

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

第三点可能有些人很迷惑，因为发现在User类中的uid字段前加上static关键字后，程序运行结果依然不变，

即static类型的uid也读出来为“Mike”了，这不与第三点说的矛盾吗？

实际上是这样的：第三点确实没错（一个静态变量不管是否被transient修饰，均不能被序列化），反序列化后类中static型变量username的值

为当前JVM中对应static变量的值，这个值是JVM中的不是反序列化得出的。