Question

声音令人毛骨悚然，呵呵...

我正在开发一个GUI驱动的应用程序，它大量使用访问者模式。我采用这种方法是因为对于我来说，以类特定的方式处理一堆图形元素很重要，尽管类本身需要充当简单的数据对象。在这方面，他们完全不了解他们在我的应用程序逻辑中所受的众多场景。

我对这个设计选择的问题是随着我的应用程序的增长，我发现自己不得不对anonymous Visitor实现进行持续的运行时分配，以便在方法体中描述我的特定于类的代码。由于其中许多都依赖于在调用时提供的参数，因此我无法将其中的许多内容提取到可重用的static实现中。

以下是一个示例，使用在运行时传递的Shaker对象，仅对Button类型执行操作。

private abstract class Graphical implements Visitor.Dispatch {
    /* Position. */
    private int X;
    private int Y;
};

private final class Button extends Graphical {
    @Override public final void onVisit(final Visitor pVisitor) { pVisitor.onReceived(this); } };

private final class ScrollBar extends Graphical {
    @Override public final void onVisit(final Visitor pVisitor) { pVisitor.onReceived(this); }
};

public static interface Visitor {
    /* Adapter. */
    public static class Adapter implements Visitor {
        @Override public void onReceived(   Button    pButton) { }
        @Override public void onReceived(ScrollBar pScrollBar) { }
    };
    /* Dispatch Method. */
    public static interface Dispatch {
        public abstract void onVisit(final Visitor pVisitor);
    };
    /* Visitor Implementations. */
    public abstract void onReceived(final    Button    pButton);
    public abstract void onReceived(final ScrollBar pScrollBar);
};

/* Iterates through a List of Graphicals and Shakes a Button. */
public static void onShakeButtons(final List<Graphical> pGraphicals, final Shaker pShaker) {
    /* Allocate a Visitor. */
    final Visitor.Adapter lVisitor = new Visitor.Adapter() { @Override public void onReceived(final Button pButton) {
        /* Shake the Button! */
        pShaker.onShake(pButton);
    } };
    /* Iterate the Graphicals. */
    for(final Graphical lGraphical : pGraphicals) { lGraphical.onVisit(lVisitor); }
}

有人可以建议如何减少我正在制作的分配数量吗？或者我对如何应用模式有一个真正的误解？

Answer 1

有一个选项。您可以在访问者中为非静态对象创建容器，并使用新的非静态对象更新这些容器并重用访问者。

public class ConcreteVisitor extends Visitor {

        private final AtomicReference<MyClass> mValue_1 = new AtomicReference<MyClass>();

        private final AtomicReference<SomeClass> mValue_2 = new AtomicReference<SomeClass>();

        public void updateVisitor(MyClass newMyClass, SomeClass newSomeClass) {
            mValue_1.set(newMyClass)
            mValue_2.set(newSomeClass)
        }

        @Override
        public void visitElement_1(Element_1 element) {
            // use your updated values here
        }

        @Override
        public void visitElement_2(Element_2 element) {
            // use your updated values here
        }
    }

当您需要重复使用访问者时，只需更新值，然后再次运行：

    // You create it only once:
    Visitor concreteVisitor = new ConcreteVisitor();

    // and reuse it all the time
    concreteVisitor.updateVisitor(newMyClass, newSomeClass);
    concreteVisitor.visitElement(element);

我使用AtomicReference作为容器，但可以使用自定义容器类。

匿名访客

1 个答案: