如何重写ObjectOutputStream.writeStreamHeader()？

Question

可以重写方法 ObjectOutputStream.writeStreamHeader() 以将数据添加到标头或附加到标头。 但是，如果该数据基于传递给派生类的构造函数的参数，例如：

public class MyObjectOutputStream extends ObjectOutputStream {

    public MyObjectOutputStream( int myData, OutputStream out ) throws IOException {
        super( out );
        m_myData = myData;
    }

    protected void writeStreamHeader() throws IOException {
        write( m_myData );            // WRONG: m_myData not initialized yet
        super.writeStreamHeader();
    }

    private final int m_myData;
}

它不起作用，因为在初始化 m_myData 之前调用 super() ，并且 >super() 调用 writeStreamHeader()。 我能想到解决这个问题的唯一方法是使用 ThreadLocal ，例如：

public class MyObjectOutputStream extends ObjectOutputStream {

    public MyObjectOutputStream( int myData, OutputStream out ) throws IOException {
        super( thunk( myData, out ) );
    }

    protected void writeStreamHeader() throws IOException {
        write( m_myData.get().intValue() );
        super.writeStreamHeader();
    }

    private static OutputStream thunk( int myData, OutputStream out ) {
        m_myData.set( myData );
        return out;
    }

    private static final ThreadLocal<Integer> m_myData = new ThreadLocal<Integer>();
}

这似乎可行，但是有更好的（不那么笨拙的）方法吗？

Answer 1

使用组合而不是继承。

public class MyObjOutStream implements DataOutput, ObjectOutput, ObjectStreamConstants {
    //same interfaces that ObjectOutputStream implements

    private ObjectOutputStream objOutStream;

    //implement all the methods below
}

仅当您准备好时才实例化 ObjectOutputStream。 您需要在接口中实现的其余方法只需调用 objOutStream 上的相同方法即可

Answer 2

从构造函数中调用非最终方法通常是一个坏主意（正是出于您提出的原因）。

您可以在不扩展 ObjectOutputStream 的情况下实现自定义序列化吗？ 我正在考虑流组合。 例如，您可以通过在 ObjectOutputStream 之前将标头写入底层 OutputStream 来添加标头。 这显然不能在 ObjectOutputStream 的子类中完成，但可以轻松地从外部完成。

   out.write(myExtraHeader);
   ObjectOutputStream oos = new ObjectOutputStream(out);

如果您愿意，您可以将这一切很好地包装在 ObjectOutput 接口后面，正如 Stu Thompson 在他的回答中建议的那样，这样它看起来就像一个 ObjectOutputStream 一样。

更新：

查看 JavaDocs 和 ObjectOutputStream 的源代码，发现有第二个（受保护的）构造函数，它不会调用 writeStreamHeader()。

但是，该构造函数也不会初始化其他内部结构。 引用文档，
它的目的是“用于完全重新实现 ObjectOutputStream 的子类
不必分配仅由 ObjectOutputStream 的此实现使用的私有数据。在这种情况下，它还调用一些其他方法，例如“writeObjectOverride”。混乱...

Answer 3

你就不能这样做吗？ 当您初始化所需字段时，忽略超级构造函数中的 writeStreamHeader 调用并自己执行一个：

public class MyObjectOutputStream extends ObjectOutputStream {

private boolean initalized = false;
private final int m_myData;

protected MyObjectOutputStream(int myData, OutputStream out) throws IOException, SecurityException {
    super(out);
    m_myData = myData;
    initalized = true;
    writeStreamHeader();
}

protected void writeStreamHeader() throws IOException {

    if(!initalized){
        return;
    }

    write( m_myData );
    super.writeStreamHeader();
}
}

编辑：

或者，按照 Thilo，可以这样写：

public class MyObjectOutputStream extends ObjectOutputStream {

    private final int m_myData;

    protected MyObjectOutputStream(int myData, OutputStream out) throws IOException, SecurityException {
        super(out);
        m_myData = myData;
        write( m_myData );
        super.writeStreamHeader();
    }

    protected void writeStreamHeader() throws IOException {
        // work is done in the constructor
    }
}

Answer 4

有一个通用的方法可以解决此类问题。 创建类和内部类，并在外部作用域中引用变量。 （请注意，这仅适用于 -target 1.4 或 grter，这是当前版本的 javac 中的默认设置。使用 -target 1.3 您将获得 NPE。）

public static ObjectOutputStream newInstance(
    final int myData, final OutputStream out
) throws IOException {
    return new ObjectOutputStream(out) {
        @Override
        protected void writeStreamHeader() throws IOException {
            write(myData);
            super.writeStreamHeader();
        }
    };
}

但是，在构造 ObjectOuputStream 之前将数据写出可能会更容易。