transient关键字

先解释下什么是序列化

我们的对象并不只是存在内存中，还需要传输网络，或者保存起来下次再加载出来用，所以需要Java序列化技术。

Java序列化技术正是将对象转变成一串由二进制字节组成的数组，可以通过将二进制数据保存到磁盘或者传输网络，磁盘或者网络接收者可以在对象的属类的模板上来反序列化类的对象，达到对象持久化的目的。

什么是transient？

简单来说就是，被transient修饰的变量不能被序列化

首先来看示例1：

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

public class TransientTest {

public static void main(String[] args) throws Exception {

    User user = new User();
    user.setUsername("Java技术栈");
    user.setId("javastack");

    System.out.println("\n序列化之前");
    System.out.println("username: " + user.getUsername());
    System.out.println("id: " + user.getId());

    ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("d:/user.txt"));
    os.writeObject(user);
    os.flush();
    os.close();

    ObjectInputStream is = new ObjectInputStream(new FileInputStream("d:/user.txt"));
    user = (User) is.readObject();
    is.close();

    System.out.println("\n序列化之后");
    System.out.println("username: " + user.getUsername());
    System.out.println("id: " + user.getId());

}

}

class User implements Serializable {

private static final long serialVersionUID = 1L;

private String username;
private transient String id;

public String getUsername() {
    return username;
}

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

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

}

输出结果：

序列化之前
username: Java技术栈
id: javastack

序列化之后
username: Java技术栈
id: null

静态变量能被序列化吗？

我们可以来看一个示例2：

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

public class TransientStaticTest {

public static void main(String[] args) throws Exception {

    User2 user = new User2();
    User2.username = "Java技术栈1";
    user.setId("javastack");

    System.out.println("\n序列化之前");
    System.out.println("username: " + user.getUsername());
    System.out.println("id: " + user.getId());

    ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("d:/user.txt"));
    os.writeObject(user);
    os.flush();
    os.close();
    
    // 在反序列化出来之前，改变静态变量的值
    User2.username = "Java技术栈2";

    ObjectInputStream is = new ObjectInputStream(new FileInputStream("d:/user.txt"));
    user = (User2) is.readObject();
    is.close();

    System.out.println("\n序列化之后");
    System.out.println("username: " + user.getUsername());
    System.out.println("id: " + user.getId());

}

}

class User2 implements Serializable {

private static final long serialVersionUID = 1L;

public static String username;
private transient String id;

public String getUsername() {
    return username;
}

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

}

输出结果：

序列化之前
username: Java技术栈1
id: javastack

序列化之后
username: Java技术栈2
id: null

示例2把 username 改为了 public static, 并在反序列化出来之前改变了静态变量的值，结果可以看出序列化之后的值并非序列化进去时的值。

由以上结果分析可知，静态变量不能被序列化，示例2读取出来的是 username 在 JVM 内存中存储的值。

transient真的不能被序列化吗？

接着来看示例3：

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;

public class ExternalizableTest {

public static void main(String[] args) throws Exception {

    User3 user = new User3();
    user.setUsername("Java技术栈");
    user.setId("javastack");
    ObjectOutput objectOutput = new ObjectOutputStream(new FileOutputStream(new File("javastack")));
    objectOutput.writeObject(user);

    ObjectInput objectInput = new ObjectInputStream(new FileInputStream(new File("javastack")));
    user = (User3) objectInput.readObject();

    System.out.println(user.getUsername());
    System.out.println(user.getId());

    objectOutput.close();
    objectInput.close();
}

}

class User3 implements Externalizable {

private static final long serialVersionUID = 1L;

public User3() {

}

private String username;
private transient String id;

public String getUsername() {
    return username;
}

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

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

@Override
public void writeExternal(ObjectOutput objectOutput) throws IOException {
    objectOutput.writeObject(id);
}

@Override
public void readExternal(ObjectInput objectInput) throws IOException, ClassNotFoundException {
    id = (String) objectInput.readObject();
}

}

输出结果：

null
javastack

示例3的 id 被 transient 修改了，为什么还能序列化出来？那是因为 User3 实现了接口 Externalizable，而不是 Serializable。

在 Java 中有两种实现序列化的方式，Serializable 和 Externalizable，可能大部分人只知道 Serializable 而不知道 Externalizable。

这两种序列化方式的区别是：实现了 Serializable 接口是自动序列化的，实现 Externalizable 则需要手动序列化，通过 writeExternal 和 readExternal 方法手动进行，这也是为什么上面的 username 为 null 的原因了。

transient 关键字总结

1）transient修饰的变量不能被序列化；

2）transient只作用于实现 Serializable 接口；

3）transient只能用来修饰普通成员变量字段；

4）不管有没有 transient 修饰，静态变量都不能被序列化；