transient关键字的理解

　　谈到这个transient这个关键字，我们应该会立马想到序列化这个过程；什么是序列化？什么又是反序列化呢？序列化就是将对象转化内成二进制，而反序列化就是就二进制文件转换成对象的过程。一旦变量使用了transient之后，那么该变量是不会被序列化的。什么场景下使用这个关键字呢，比如说用户的密码这种敏感的字段来说，我们不希望通过网络去传输，而只需要让它存在于内存当中即可。不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。下面我们看一个Demo（这个例子没有使用transient关键字）。

package com.gosaint.server;

import java.io.Serializable;

/**
 * @Authgor: gosaint
 * @Description:
 * @Date Created in 10:32 2018/3/9
 * @Modified By:实现了序列化接口
 */
public class User  implements Serializable{
    private String username;
    private String password;
    private String agent;

    public String getUsername() {
        return username;
    }

    public void setUsername(final String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(final String password) {
        this.password = password;
    }

    public String getAgent() {
        return agent;
    }

    public void setAgent(final String agent) {
        this.agent = agent;
    }

    @Override public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", agent='" + agent + '\'' +
                '}';
    }
}

实现了Seriable接口，接着我们使用对象流写出和写入：

package com.gosaint.server;

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

/**
 * @Authgor: gosaint
 * @Description:
 * @Date Created in 10:33 2018/3/9
 * @Modified By:
 */
public class TransientTest {
    public static void main(String[] args) {
        User user=new User();
        user.setUsername("caozg");
        user.setPassword("123456");
        user.setAgent("男");

        System.out.println("序列化之前读取");
        System.out.println("username :"+user.getUsername());
        System.out.println("password :"+user.getPassword());
        System.out.println("agent    :"+user.getAgent());

        //将对象写出到流
        try {
            ObjectOutputStream os=new ObjectOutputStream(new FileOutputStream("D:/user.txt"));
            // 将对象写入文件
            os.writeObject(user);
            os.flush();
            os.close();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }
        try {
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream("D:/user.txt"));
            user=(User)ois.readObject();//读取对象
            ois.close();
            System.out.println("===================");
            System.out.println("序列化之后的数据读取");
            System.out.println("username :"+user.getUsername());
            System.out.println("password :"+user.getPassword());
            System.out.println("agent    :"+user.getAgent());

        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }

    }
}

看生成之后的user.txt序列化文件：

aced 0005 7372 0017 636f 6d2e 676f 7361
696e 742e 7365 7276 6572 2e55 7365 72ee
4b64 d20f b657 4a02 0003 4c00 0561 6765
6e74 7400 124c 6a61 7661 2f6c 616e 672f
5374 7269 6e67 3b4c 0008 7061 7373 776f
7264 7100 7e00 014c 0008 7573 6572 6e61
6d65 7100 7e00 0178 7074 0003 e794 b774
0006 3132 3334 3536 7400 0563 616f 7a67

看不懂吧，反正是二进制文件，我也看不懂！那么就看看控制台的输出吧。

序列化之前读取
username :caozg
password :123456
agent    :男
===================
序列化之后的数据读取
username :caozg
password :123456
agent    :男

此时发现对象完全被序列化操作了。接下来我们对密码使用transient关键字；

public class User  implements Serializable{
    private String username;
    private transient String password;
    private String agent;
}

控制台的打印如下：

序列化之前读取
username :caozg
password :123456
agent    :男
===================
序列化之后的数据读取
username :caozg
password :null
agent    :男

密码没有被序列化；

关于transient关键字的使用总结：

　　1>:一旦变量使用了transient关键字修饰，那么将不能被序列化；该变量的内容在对象序列化之后也无法访问

　　2>:transient只能修饰成员变量，不能修饰类和方法，不可以修饰局部变量；如果变量是对象类型，则该对象也要实现Seriable接口

　　3>:当变量使用static修饰，则该变量不可以被序列化；一个静态变量不管是否被transient修饰，均不能被序列化。因为变量被static修饰，它属于类变量，属于JVM所有。

请看下面的代码，变量username被static修饰了。

public class User  implements Serializable{
    private static String username;
    private transient String password;
    private String agent;
}

序列化之前读取
username :caozg
password :123456
agent    :男
===================
序列化之后的数据读取
username :caozg
password :null
agent    :男

发现输入输出username相同，那么是不是被序列化了呢？其实不是哈。原因我在第三点已经说明。下面我在序列化之前修改代码：

package com.gosaint.server;

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

/**
 * @Authgor: gosaint
 * @Description:
 * @Date Created in 10:33 2018/3/9
 * @Modified By:
 */
public class TransientTest {
    public static void main(String[] args) {
        User user=new User();
        user.setUsername("caozg");
        user.setPassword("123456");
        user.setAgent("男");

        System.out.println("序列化之前读取");
        System.out.println("username :"+user.getUsername());
        System.out.println("password :"+user.getPassword());
        System.out.println("agent    :"+user.getAgent());

        //将对象写出到流
        try {
            ObjectOutputStream os=new ObjectOutputStream(new FileOutputStream("D:/user.txt"));
            // 将对象写入文件
            os.writeObject(user);
            os.flush();
            os.close();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }
        try {
            user.setUsername("caozg2222");
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream("D:/user.txt"));
            user=(User)ois.readObject();//读取对象
            ois.close();
            System.out.println("===================");
            System.out.println("序列化之后的数据读取");
            System.out.println("username :"+user.getUsername());
            System.out.println("password :"+user.getPassword());
            System.out.println("agent    :"+user.getAgent());

        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }

    }
}

序列化之前读取
username :caozg
password :123456
agent :男
===================
序列化之后的数据读取
username :caozg2222
password :null
agent :男

看到了吗，本来序列化的是caozg。但是最后写出的是caozg2222。因此static修饰的变量不能被序列化。

看如下的代码：

package com.gosaint.server;

import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

/**
 * @Authgor: gosaint
 * @Description:
 * @Date Created in 11:30 2018/3/9
 * @Modified By:
 */
public class ExternalizableTest implements Externalizable {
    private transient String content = "是的，我将会被序列化，不管我是否被transient关键字修饰";
    @Override
    public void writeExternal(final ObjectOutput objectOutput) throws IOException {
        objectOutput.writeObject(content);
    }

    @Override
    public void readExternal(final ObjectInput objectInput) throws IOException, ClassNotFoundException {
        content=(String) objectInput.readObject();
    }
    public static void main(String[] args) throws Exception {

        ExternalizableTest et = new ExternalizableTest();
        System.out.println("序列化之前");
        System.out.println(et.content);
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                new File("test")));
        out.writeObject(et);
        ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
                "test")));
        et = (ExternalizableTest) in.readObject();
        System.out.println("序列化之后");
        System.out.println(et.content);
        out.close();
        in.close();
    }
}

Externalizable 实例类的唯一特性是可以被写入序列化流中，该类负责保存和恢复实例内容。

打印内容如下：

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

　　

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

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