瞬态字段的Java序列化

Question

我正在阅读Thinking in Java 4th Edition。这里描述了transient字段序列化的一个奇怪的解决方法:

import java.io.*;
public class SerializationTest implements Serializable {
    private String firstData;
    //transient field, shouldn't be serialized.
    transient private String secondData;
    public SerializationTest(String firstData, String test2) {
        this.firstData = firstData;
        this.secondData = test2;
    }
    /**
     * Private method, same signature as in Serializable interface
     *
     * @param stream
     * @throws IOException
     */
    private void writeObject(ObjectOutputStream stream) throws IOException {
        stream.defaultWriteObject();
        stream.writeObject(secondData);
    }
    /**
     * Private method, same signature as in Serializable interface
     *
     * @param stream
     * @throws IOException
     */
    private void readObject(ObjectInputStream stream)
            throws IOException, ClassNotFoundException {
        stream.defaultReadObject();
        secondData = (String) stream.readObject();
    }
    @Override
    public String toString() {
        return "SerializationTest{" +
                "firstData='" + firstData + ''' +
                ", secondData='" + secondData + ''' +
                '}';
    }
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            fos = new FileOutputStream("object.out");
            oos = new ObjectOutputStream(fos);
            SerializationTest sTest = new SerializationTest("First Data", "Second data");
            oos.writeObject(sTest);
        } finally {
            oos.close();
            fos.close();
        }
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream("object.out");
            ois = new ObjectInputStream(fis);
            SerializationTest sTest = (SerializationTest) ois.readObject();
            System.out.println(sTest);
        } finally {
            ois.close();
            fis.close();
        }
        //Output:
        //SerializationTest{firstData='First Data', secondData='Second data'}
    }
}

可以看到，有实现的私有方法writeObject和readObject。

问题是:

为什么ObjectOutputStream和ObjectInputStream使用反射来访问私有方法?

Java中有多少这样的后门?

Answer 1

后门?它一直在规范中。这是实现对象非默认序列化的唯一方法。

非默认序列化让您坐在序列化驾驶员的位置上。你可以写任何东西到输出流，只要你能读回它，并在流的另一端构造你的对象，你就没事了。

这个人决定序列化瞬态字段的事实不是问题，关键是如果您正在实现自己的序列化方案，您可以做任何您想做的事情。

Answer 2

嗯，这不是"后门"…您实现了一个自定义序列化，该序列化在调用忽略它们的默认序列化之后将瞬态字段输出到输出流。

Answer 3

Serializable接口是一个标记接口。它就像一个标签，用来解释java编译器。还有其他的标记接口，如Clonable等。参见这里了解更多信息。但是现在@annotation的使用越来越多了