Java中的延迟引用设置

Question

我正在开发一个类似 CORBA 的对象间协议，它支持对象聚合传输。

当聚合的对象被序列化时，它们可能会引用稍后序列化的对象。这些是前向参考。一个简单的例子是循环列表。如果每个对象都具有对先前序列化对象的引用，则第一个对象将具有对最后一个序列化对象的引用以关闭循环。

当反序列化和实例化包含此类前向引用的对象时，其值是未知的。只有当相应的对象被反序列化并实例化时，引用值才是已知的并且可以被设置。

在 C 或 C++ 中，我使用引用（指针）本身来保存对同一对象的引用列表，以便在实例化该对象时进行设置。在 Java 中这是不可能的。

我怎样才能在Java中实现这种延迟的引用设置？

Answer 1

如果对象是不可变的，那么您构建一个临时结构，它将以适当的顺序创建它们（显然，这不适用于循环列表，除非您使用设置最终字段反射序列化支持）。

如果没有，请稍后在外部列表中记录所需的操作，或者为每个成员使用带有解析方法的接口：
公共接口 IBar {
IBar 解析 ( );

    static IBar EMPTY = new IBar() { 
        public IBar resolve () { 
            throw new RuntimeException(); 
        }
    }
}

public interface IFoo {
    IFoo resolve ( );
    ...
}

public class Foo implements IFoo {
    private IBar bar = IBar.EMPTY;

    public Foo ( IBar bar ) { this.bar = bar; }

    public Bar getBar () {
        return bar.resolve();
    }

    public String getId () { ... }

    public IFoo resolve () {
        bar = bar.resolve();
        return this;
    }
}

public class Loader {
    private HashMap<String,IFoo> fooRefs = new ...
    private HashMap<String,IBar> barRefs = new ...

    private IBar barRef ( String id ) {
        IFoo foo = fooRefs.get(id);

        if (foo==null) {
            foo = new ForwardFooRef(id);
            fooRefs.put(id,foo);
        }

        return foo;
    }

    private IFoo created ( IFoo foo ) {
        IFoo extant = fooRefs.get(foo.getId());

        if (extant != null) 
            if ( extant instanceof ForwardFooRef) 
                ((ForwardFooRef)extant).setReferent(foo);
            else
                throw new RuntimeException("more than one object with the same id ");

        return foo;
    }

    public void load () {
        create each object
        register it using created
        if a ref is found, use the maps to look it up
        if the ref is in teh map, use it
        if ref is forward, it's created with a temp

        walk object tree resolving anything