在Java序列化机制中，transient这个关键字非常有用，本篇文章就来带解析一下transient关键字。

1、transient关键字的定义

定义：transient只能用来修饰成员变量（field），被transient修饰的成员变量不参与序列化过程。

简析：Java中的对象如果想要在网络上传输或者存储在磁盘时，就必须要序列化。Java中序列化的本质是Java对象转换为字节序列。但是在序列化的过程中，可以允许被序列对象中的某个成员变量不参与序列化，即该对象完成序列化之后，被transient修饰的成员变量会在字节序列中消失。

举例：

小美的昵称希望被人看到，但是小美的真名不希望被人看到。

x
1
public class XiaoMei implements Serializable {
2
    private static final long serialVersionUID = -4575083234166325540L;
3
​
4
    private String nickName;
5
    private transient String realName;
6
​
7
​
8
    public XiaoMei(String nickName,String realName){
9
        this.nickName = nickName;
10
        this.realName = realName;
11
    }
12
​
13
    public String toString(){
14
        return String.format("XiaoMei.toString(): nickName=%s,realName=%s", nickName,realName);
15
    }
16
}

写个测试代码：

xxxxxxxxxx
1
public class Test {
2
    public static void main(String[] args){
3
        String realName="王小美", nickName="王美美";
4
        XiaoMei x = new XiaoMei(nickName, realName);
5
        System.out.println("序列化前："+x.toString());
6
        ObjectOutputStream outStream;
7
        ObjectInputStream inStream;
8
        //文件保存在本地，把这个路径换成自己的文件路径
9
        //mac的同学把jiangyoujun换成自己的用户名
10
        //windows的同学前面要加D:/这样的磁盘符号
11
        String filePath = "/Users/jiangyoujun/Documents/test.log";
12
        try {
13
            outStream = new ObjectOutputStream(new FileOutputStream(filePath));
14
            outStream.writeObject(x);
15
​
16
            inStream = new ObjectInputStream(new FileInputStream(filePath));
17
            XiaoMei readObject = (XiaoMei)inStream.readObject();
18
            System.out.println("序列化后："+readObject.toString());
19
        } catch (IOException e) {
20
            // TODO Auto-generated catch block
21
            e.printStackTrace();
22
        } catch (ClassNotFoundException e) {
23
            // TODO Auto-generated catch block
24
            e.printStackTrace();
25
        }
26
    }
27
}

输出结果如下：

2
1
序列化前：XiaoMei.toString(): nickName=王美美,realName=王小美
2
序列化后：XiaoMei.toString(): nickName=王美美,realName=null

可以看出，使用transient关键字修饰的成员变量没有被序列化。

2、transient关键字设计思路和底层实现思路

毫无疑问，这是一个平常的编程语言设计思路，即实现两种编码转化的时候，我们希望用户在转化过程中可以控制一些内容。

理解transient的关键在于理解序列化，序列化是Java对象转换为字节序列。

详细的说，就是Java对象在电脑中是存于内存之中的，内存之中的存储方式毫无疑问和磁盘中的存储方式不同（一个显而易见的区别就是对象在内存中的存储分为堆和栈两部分，两部分之间还有指针；但是存到磁盘中肯定不可能带指针，一定是某种文本形式）。序列化和反序列化就是在这两种不同的数据结构之间做转化。

序列化：JVM中的Java对象转化为字节序列。

反序列化：字节序列转化为JVM中的Java对象。

理解到这里，实现原理也是显而易见的，只要在处理两个数据结构转化的过程中，把标为transient的成员变量特殊处理一下就好了。

3、静态成员变量不加transient关键字也不能被序列化

在Java中，静态成员变量是不能被序列化的，不管有没有transient关键字。

大家可以看Serializable的相关文档：

xxxxxxxxxx
1
/**
2
 *The readObject method is responsible for reading from the stream and
3
 * restoring the classes fields. It may call in.defaultReadObject to invoke
4
 * the default mechanism for restoring the object's non-static and
5
 * non-transient fields. 

在所有Serializable的实现类中，都明确说明了实例化过程中不包含静态成员变量和被transient修饰的关键字。

4、使用Externalizable自定义序列化

Externalizable这个接口也是实现序列化的，但是和Serializable有不同。首先，Externalizable是继承Serializable的，其次Externalizable是需要程序员自己指定成员变量实现序列化的。

也就是说，使用Externalizable接口，程序员需要实现writeExternal以及readExternal这两个方法，来自己实现序列化和反序列化。实现的过程中，需要自己指定需要序列化的成员变量，此时，static和transient关键词都是不生效的，因为你重写了序列化中的方法。

举例：

xxxxxxxxxx
1
public class XiaoMei implements Externalizable {
2
    private String nickName;
3
    private transient String realName;
4
    private static String childName="美美";
5
​
6
    public XiaoMei(){
7
    }
8
​
9
    public XiaoMei(String nickName,String realName){
10
        this.nickName = nickName;
11
        this.realName = realName;
12
    }
13
​
14
    public String toString(){
15
        return String.format("XiaoMei.toString(): nickName=%s,realName=%s,childName=%s", nickName,realName,childName);
16
    }
17
​
18
    @Override
19
    public void writeExternal(ObjectOutput out) throws IOException {
20
        out.writeUTF(realName);
21
        out.writeUTF(childName);
22
    }
23
​
24
    @Override
25
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
26
        realName = in.readUTF();
27
        childName = in.readUTF();
28
    }
29
}

使用上述例子中的测试代码，输出结果如下：

xxxxxxxxxx
1
序列化前：XiaoMei.toString(): nickName=王美美,realName=王小美,childName=美美
2
序列化后：XiaoMei.toString(): nickName=null,realName=王小美,childName=美美

可以看出，Externalizable接口中，指定的成员变量被序列化了，不管是否有static和transient关键词，但是不被指定的成员变量不能被序列化。