transient变量真的不能被序列化吗？_transient不能被序列化-CSDN博客

本文链接：https://blog.csdn.net/ahopedog/article/details/106659994

Java中的transient关键字用于防止属性在序列化过程中被保存。然而，如果类实现了Externalizable接口并自定义序列化方法，transient变量仍可能被序列化。实验表明，即使有transient修饰，通过writeExternal()和readExternal()方法，变量的值仍会被存储和恢复，揭示了序列化过程中的这一特殊情况。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一些敏感信息，比如密码和银行卡号等在java对象序列化时不希望被序列化，不被序列化的属性就不会被存储到磁盘上，或通过网络传输。为了实现属性不被序列化，只需要在属性前加上transient关键字就能达到目的。

但是，使用transient的属性就一定不会被序列化吗？带着这个疑问，我们开始进行一下测试，看看真相到底是什么样的。

被序列化的类首先需要实现Serializable接口，序列化时使用ObjectOutputStream的writeObject()方法，将类实例写入到对象流中。反序列化时使用ObjectInputStream的readObject()方法，从对象流读取对象。

@Getter
@Setter
public class Transient1 implements Serializable{

    private int id;
    private String name;
    private transient String accountNum;

    public String toString(){
        return "id:" + id +
                ",name:" + name +
                ",accountNum:" + accountNum;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //创建对象
        Transient1 t = new Transient1();
        t.setId(1);
        t.setName("name");
        t.setAccountNum("xxxx000111");
        System.out.println("序列化前："+t);

        //序列化
        ByteArrayOutputStream outByte = new ByteArrayOutputStream(100);
        ObjectOutputStream out = new ObjectOutputStream(outByte);
        out.writeObject(t);

        //反序列化
        ByteArrayInputStream inByte = new ByteArrayInputStream(outByte.toByteArray());
        ObjectInputStream in = new ObjectInputStream(inByte);
        Transient1 t2 = (Transient1) in.readObject();
        System.out.println("序列化后: " + t2);
    }
}

输出结果：

序列化前：id:1,name:name,accountNum:xxxx000111

序列化后: id:1,name:name,accountNum:null

上面代码是常规的序列化过程，可以看到，序列化后accountNum的内容没有从对象流中恢复，也就达到了敏感信息不被序列化的目的。

对象序列化还有另一种实现方式，不知道你知不知道。那就是实现Externalizable接口。

@Getter
@Setter
public class Transient2 implements Externalizable{

    private int id;
    private String name;
    private transient String accountNum;

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeInt(id);
        out.writeUTF(name);
        out.writeUTF(accountNum);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        id = in.readInt();
        name = in.readUTF();
        accountNum = in.readUTF();
    }

    public String toString(){
        return "id:" + id +
                ",name:" + name +
                ",accountNum:" + accountNum;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //创建对象
        Transient2 t = new Transient2();
        t.setId(1);
        t.setName("name");
        t.setAccountNum("xxxx000111");
        System.out.println("序列化前："+t);

        //序列化
        ByteArrayOutputStream outByte = new ByteArrayOutputStream(100);
        ObjectOutputStream out = new ObjectOutputStream(outByte);
        out.writeObject(t);

        //反序列化
        ByteArrayInputStream inByte = new ByteArrayInputStream(outByte.toByteArray());
        ObjectInputStream in = new ObjectInputStream(inByte);
        Transient2 t2 = (Transient2) in.readObject();
        System.out.println("序列化后: " + t2);
    }
}

输出结果：

序列化前：id:1,name:name,accountNum:xxxx000111

序列化后: id:1,name:name,accountNum:xxxx000111

看到了吗，序列化后，accountNum被恢复了。

使用Externalizable实现序列化比实现Serializable稍微麻烦点，需要自己实现writeExternal()和readExternal()两个方法，writeExternal()会在序列化时被调用，readExternal()在反序列化时被调用。

使用Serializable序列化时，会自动将类里所有没有transient的属性写入流对象中。Externalizable就有些麻烦了，序列化和反序列化的细节都需要有自己实现，哪些字段需要，哪些不需要完全由自己决定。坏处是很麻烦，好处就是更灵活。

上面代码中在writeExternal()中写了out.writeUTF(accountNum);所以accountNum被序列化到流里了，这时不管有没有transient。相反在readExternal()方法中使用accountNum = in.readUTF();
对accountNum进行了反序列化。这时已经与transient完全没有关系了，一切都是手动的写入和赋值过程。

好了，现在你觉得属性加上transient后就真的不会被序列化吗？