我怎么能不序列化继承的非瞬态字段？

Question

这个问题

我有一个Serializable类(让我们称之为A),带有一个非瞬态布尔字段,以及一个子类(B),同一个字段应该是瞬态的.我怎样才能做到这一点？

更确切地说,我希望false在反序列化B时将字段恢复为默认的布尔值(),尽管我希望在反序列化时将其恢复为正确的值.但是,从A继承的其他字段仍应恢复.

在功能上,A表示在会话之间恢复的对象,B是特定类型的A,其状态应在每个新会话上重置.

快速代码示例:

public class A implements java.io.Serializable {

    private String label;
    // non-transient
    private boolean field;

    public String getLabel() {
        return label;
    }

    public void setLabel(String label) {
        this.label = label;
    }

    public boolean isField() {
        return field;
    }

    public void setField(boolean field) {
        this.field = field;
    }
}

public class B extends A {
    // field should be transient for this class
    // label should remain non-transient
}

---

我选择不保留的一些可能的解决方案

• 一个简单的解决方案是更改B extends A为A extends B,使字段瞬态,并添加writeObject()A以序列化字段.但是,B extends A它具有功能意义,我不相信还原它是明智的.

• 我可以实现一个readObject()覆盖该字段的反序列化值的方法.然而,这感觉就像一个肮脏的解决方案,我不希望使用它,除非没有其他选择.

• 我试着写一个writeObject()方法来模拟一个瞬态字段,但它不起作用,我不知道为什么.如果有人有线索,那可能是我的解决方案:

public class B extends A {
    private void writeObject(ObjectOutputStream out) throws IOException {
        // save current state
        boolean field = isField();

        // synchronized to make sure this instance is not interrogated
        // while changed for serialization
        synchronized (this) {
            // emulate transient state and serialize
            setField(false);
            out.defaultWriteObject();

            // restore state
            setField(field);
        }
    }
}

• 编辑:@ rocketboy使用阴影效果的解决方案,但我对阴影感到不舒服,因为它会留下一个未使用的字段(A的非瞬态字段永远不会被使用,而B的瞬态版本将被写入和读取).这可能是一个解决方案.做实验的Java开发人员认为这是一个干净的解决方案吗？

public class B extends A {
    // shadow A's field
    private transient boolean field;

    @Override
    public boolean getField() {
        return field;
    }

    @Override
    public void setField(boolean field) {
        this.field = field;
    }
}

---

答案

按照@ m1o2的建议,我已经能够使用Externalizable接口实现我的解决方案:

public class B extends A implements java.io.Externalizable {

    // Do not forget to have a public no-arg constructor
    // for Serialization to work
    public B() {
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // Write only the fields I am interested in
        out.writeObject(getLabel());
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        // Read the serialized fields IN THE ORDER THEY WERE WRITTEN
        setLabel((String) in.readObject());
    }
}

但请注意,这是适用的,因为A和B是简单的类.对于具有许多字段且趋势发展的类,这可能会花费更多(除非使用基于反射的一些代码).

Answer 1

如果您不关心超类字段（所有字段），您可以使用Externalized接口