小编点评

在本文中，我们将讨论Java中的序列化和transient关键字。首先，我们回顾了一下之前面试时学到的关于transient关键字的知识。面试官询问transient关键字修饰的变量是否不可序列化，当时我们并没有给出确切的答案。经过向面试官请教，我们了解到transient关键字修饰的变量在序列化过程中确实不会被序列化。 接下来，我们通过一个案例测试来观察static和transient关键字修饰的字段在序列化过程中的表现。测试结果显示，static修饰的字段没有参与序列化，而transient关键字修饰的字段在反序列化过程中会被重置为默认值。 然后，我们探讨了如何在Java中实现序列化。Java提供了Serializable接口和Externalizable接口两种序列化方式。Serializable接口是一个标识，没有任何方法。而Externalizable接口是Serializable的子接口，它需要实现者重写writeExternal()和readExternal()方法来进行序列化和反序列化操作。在外部序列化中，我们可以对敏感信息进行加密处理。 最后，我们得出结论：在Java序列化中，transient关键字只能修饰字段，而不能修饰方法和类。通过实现Externalizable接口并重写writeExternal()和readExternal()方法，我们可以实现对transient字段的序列化控制。

正文

一、写在开头

在这篇文章中记录一下之前自己面试时学到的东西，是关于transient关键字的，当时面试官问我IO的相关问题，基本上全答出来了，关于如何不序列化对象中某个字段时，我果断的选择了static和transient，但面试官紧接着问了我：“transient关键字修饰的变量当真不可序列化吗？”，这个问题直接给我整不确定了，因为以当时的知识储备，这个问题确实不知道，最终虚心的向这位面试官请教，他告诉了我答案。

虽然那场面试我还是通过了，但是我没去，哈哈！不过还是挺感谢那个耐心的面试官的，随口的一个问题，其实大部分面试官是不会负责给你解答的。

二、案例测试

今天，我们就花一点时间，来把这个问题梳理一遍。我们先写一个测试类，去看一下static和transient关键字修饰的字段，在序列化过程中的表现：

public class Test {
    public static void main(String[] args) throws IOException {
        //初始化对象信息
        Person person = new Person();
        person.setName("JavaBuild");
        person.setAge(30);
        System.out.println(person.getName()+" "+person.getAge());

        //序列化过程
        try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("E:\\person.txt"));) {
            objectOutputStream.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }
        person.par1 = "序列化后静态字段";
        //反序列化过程
        try (ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("E:\\person.txt"));) {
            Person p = (Person) objectInputStream.readObject();
            System.out.println(p);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}
class Person implements Serializable{

    private static final long serialVersionUID = 8711922740433840551L;
    private String name;
    private int age;

    public static String par1 = "静态字段";
    transient String par2 = "临时字段";
    transient int high = 175;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", par1=" + par1 +
                ", high=" + high +
                ", par2='" + par2 + '\'' +
                '}';
    }
}

输出：

JavaBuild 30
Person{name='JavaBuild', age=30, par1=序列化后静态字段, high=0, par2='null'}

通过打印结果我们可以看到，static修饰的字段，并没有参与序列化，读取到了后面修改的值；transient关键字修饰的字段也没参与，而且在反序列化过程中，会被重置为默认值，例如基本数据类型为 0，引用类型为 null。至于原因我们在这里不展开了，上一篇文章里已经提到，大家可以去看看。

三、直入主题

我们再回过头来看看起初的问题：transient 修饰的字段真的不能被序列化？
至少通过Serializable接口标示的序列化方式里，transient字段时不可被序列化的，因为在序列化过程中调用的ObjectStreamClass对象，里面有个方法为getDefaultSerialFields()，已经明确的标记出了transient修饰符不可被序列化！

那我们怎么办呢？

Externalizable接口：

其实呀，除了 Serializable 之外，Java 还提供了一个序列化接口 Externalizable，它是Serializable的子接口，使用 Externalizable 进行反序列化的时候，会调用被序列化类的无参构造方法去创建一个新的对象，然后再将被保存对象的字段值复制过去；实现Externalizable接口时，必须重写其中的writeExternal() 和 readExternal()方法，我们通过这两个方法进行序列化的设计与读取。

适应场景： 因为Externalizable接口拥有着更高的序列化控制能力，所以在序列化过程中，我们需要对一些敏感信息进行加密处理时，它的作用就会体现啦。

我们使用这个接口进行序列化尝试，并且使用transient关键字修饰字段，看一下结果：

public class Test implements Externalizable {

    private transient String text = "我可以被序列化！！！";

    public static void main(String[] args) throws Exception {
        Test test = new Test();
        //序列化
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("E:\\transient.txt"));
        out.writeObject(test);
        //反序列化
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("E:\\transient.txt"));
        test = (Test)in.readObject();
        System.out.println(test.text);
        //关闭流
        out.close();
        in.close();
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(text);
    }

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

输出：

我可以被序列化！！！

数据成功被序列化到txt文件中，并成功的反序列化读取到程序中了！即便text被transient修饰着！

四、总结

通过上面的学习，我们知道了在Java的序列化中有 Serializable、Externalizable这两个接口，前者没有任何方法，只是一个标识，而后者作为子类，提供了必须重写的方法，用以自定义序列化设计。此外，transient 关键字只能修饰字段，而不能修饰方法和类，需要注意。