java - Java中的延迟引用设置

Question

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

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

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

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

我如何在 Java 中实现这种延迟引用设置？

Answer 1

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

如果没有，要么稍后在外部列表中记录所需的操作，要么为每个成员使用带有解析方法的接口(interface): 公共(public)接口(interface) 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