java中的 transient 关键字的实际使用

前言

在实际开发中，使用到 transient 关键字的时候不是很多。实际上，transient 这个关键字在实际开发中的用处还是挺多的。先回顾一下它的基本用法：

一旦变量被 transient 修饰，变量将不再是持久化对象的一部分，该变量内容在序列化后无法获得访问；
transient 关键字只能修饰变量，不能修饰方法和类。注意，本地变量是不能被 transient 关键字修饰的；
一个静态变量不管是否被 transient 关键字修饰，都不能被序列化。

正文

当对象被序列化时，transient 阻止实例中那些用此关键字声明的变量持久化；当对象被反序列化时，对应的变量不会被恢复。
在实际开发中，用到了这一点。一个类实现了 Serializable 接口，但是这个类有一个属性却没有实现 Serializable 接口，这样导致了 NotSerializableException。
看下面的小例子：

public class SerializableA implements Serializable {
    private String mName;
    private transient UnSerializableB mUnSerializableB;

    public String getName() {
        return mName == null ? "" : mName;
    }

    public void setName(String name) {
        mName = name;
    }

    public UnSerializableB getUnSerializableB() {
        return mUnSerializableB;
    }

    public void setUnSerializableB(UnSerializableB unSerializableB) {
        mUnSerializableB = unSerializableB;
    }

    @Override
    public String toString() {
        return "SerializableA{" +
                "mName='" + mName + '\'' +
                ", mUnSerializableB=" + mUnSerializableB +
                '}';
    }
}

public class UnSerializableB {
    private String mName;

    public String getName() {
        return mName == null ? "" : mName;
    }

    public void setName(String name) {
        mName = name;
    }
}

测试代码：

public class Test {
    public static void main(String[] args) {
        SerializableA serializableA = new SerializableA();
        serializableA.setName("SerializableA");
        UnSerializableB unSerializableB = new UnSerializableB();
        unSerializableB.setName("UnSerializableB");
        serializableA.setUnSerializableB(unSerializableB);

        // 序列化
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/a.java"));
            oos.writeObject(serializableA);
            oos.flush();
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行代码，可以看到报错日志：

java.io.NotSerializableException: com.test.UnSerializableB
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
	at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
	at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
	at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
	at com.test.Test.main(Test.java:22)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at com.intellij.rt.execution.application.AppMainV2.main(AppMainV2.java:131)

日志指向了没有序列化的 UnSerializableB。我们知道，这时把 UnSerializableB 实现 Serializable 接口，就可以了。但是，实际上，UnSerializableB 不需要序列化，这该怎么办呢？
在 SerializableA 中的 UnSerializableB 变量前加 transient 关键字，阻止序列化这个字段。

private transient UnSerializableB mUnSerializableB;

添加反序列化的代码：

public class Test {
    public static void main(String[] args) {
        SerializableA serializableA = new SerializableA();
        serializableA.setName("SerializableA");
        UnSerializableB unSerializableB = new UnSerializableB();
        unSerializableB.setName("UnSerializableB");
        serializableA.setUnSerializableB(unSerializableB);
        System.out.println("before serial: " + serializableA);
        // 序列化
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/a.java"));
            oos.writeObject(serializableA);
            oos.flush();
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/a.java"));
            SerializableA serializableA1 = (SerializableA) ois.readObject();
            ois.close();
            System.out.println("after serial: " + serializableA1);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

再次运行程序：

before serial: SerializableA{mName='SerializableA', mUnSerializableB=com.wql.downloader.test.UnSerializableB@78308db1}
after serial: SerializableA{mName='SerializableA', mUnSerializableB=null}

从日志中，可以看到不再报错，并且反序列后 mUnSerializableB 的值是取不到的。
对于一个实现了 Serializable 接口的变量，再使用 transient 修饰它，会阻止它序列化吗？
给 SerializableA 的 mName 前面增加 transient 关键字：

private transient String mName;

运行程序，查看日志：

before serial: SerializableA{mName='SerializableA', mUnSerializableB=com.wql.downloader.test.UnSerializableB@78308db1}
after serial: SerializableA{mName='null', mUnSerializableB=null}

答案是可以阻止它序列化。

最后

开发中，是在从 Activity 给 Fragment 通过 Intent 传递数据时，出现的这个问题。但是，这个报错的出现并不是很迅速，不知道是什么原因？不过，报错的指向还是很明确的。
写下这个知识点，这样就可以加深印象了。

参考

Java transient关键字使用小记
在Java中如何使用transient