我的问题是以尽可能可扩展的方式为不同的消息实现不同的行为。我知道访问者模式，我知道双重分派(dispatch)，但我似乎无法找到一个让我满意的解决方案(至少不在 java 的范围内)。

我的情况如下:

我有一个消息层次结构:

和路由器接口(interface)的层次结构，每个接口(interface)都为自己的消息类型定义路由方法:

我想实现类似这样的:

能够添加和删除路由某些消息的功能，以及轻松更改某些消息的路由策略。

问题是，如果不切换我的消息，我不想这样做，我无法为界面选择相应的功能，因为像

CompositeRouter comp = new AllRouter(...//new Router instances);
MessageBase msg = new DerivedMessage();
msg.process(comp);

将导致java选择重载<runtime message-type>.process(Router)

在编译时，在运行时为相应的路由器对象调用。所以我似乎无法在编译时选择对 process() 的正确调用。我也不能反过来做，因为comp.route(msg)

将解析为<dynamic router-type>.route(MessageBase) .

我可以编写一个访问者，它从 CompositeRouter 中选择适当的方法，但因此我必须使用预先为所有 MessageType 定义的相应路由方法来定义访问者接口(interface)，这违背了目的，因为它意味着每当我添加一个新的 DerivedMessage 时我都必须重写访问者。

有没有一种方法可以实现 Message 和 Router 都是可扩展的，或者考虑到当前的 java 特性是没有希望的？

编辑 1:

我忘了提的是，我还有 4 或 5 种其他情况，它们与 Router 几乎相同。 -层次结构，所以我有点想避免方法查找的反射，因为我担心运行时成本。

评论回复:

1. @aruisdante 关于@bot 建议的假设是正确的。我 不能覆盖，因为我会松开运行时类型 MessageBase，如果我覆盖 route(MessageBase)。

2. @aruisdante 和@geceo:我知道我可以做到这一点 - 这就是我所说的“切换转换”(MessageBase 有一个 MessageType 字段) - 但我有 11 个实际消息类和 ~6 个位置在我的代码中 需要它，所以这将是一个巨大的痛苦实现——以及 维护方面。

最佳答案

以下是我过去通常如何解决此类问题:

首先，在您的 Router 中界面，因为看起来你最想Router除了 Composite 之外的实现仅处理单一消息类型，将接口(interface)的定义更改为类似于以下内容:

interface Router<T extends MessageBase> {
    void route(T message);

}

这消除了为各种 Router 提供接口(interface)的需要s 处理特定的实现。你派生Router类然后变成这样的:

class OtherDerivedRouter implements Router<OtherDerivedMessage> {

    @Override
    void route(OtherDerivedMessage message) { //... };

}

现在 CompositeRouter 中发生了什么？好吧，我们做这样的事情:

class CompositeRouter implements Router<MessageBase> {

    protected static class RouterAdaptor< T extends MessageBase> implements Router<MessageBase> {

         private Router<T> router;
         private Class<T>  klass;

         RouterAdaptor(Router<T> router, Class<T> klass) {
             this.router = router;
             this.klass  = klass;
         }

         @Override
         public void route(MessageBase message) {
            try {
                router.route(klass.cast(message));
            } (catch ClassCastException e) {
                // Do whatever, something's gone wrong if this happens
            }
         }
     }

     private Map<Class<?>, RouterAdaptor<?>> routerMap;

     @Override
     public void route(MessageBase message) {
         RouterAdaptor<?> adaptor = routerMap.get(message.getClass());
         if (adaptor != null) {
             adaptor.route(message)
         } else {
           // do your default routing case here
         }
     }

     public <T extends MessageBase> void registerRouter(Router<T> router, Class<T> klass) {
         // Right now don't check for overwrite of existing registration, could do so here
         routerMap.put(klass, new RouterAdaptor<T>(router, kass));
     }

     CompositeRouter(/*...*/) {
         //initialize routerMap with Map type of choice, etc
     }

}

RouterAdaptor分派(dispatch) Router 期望的正确消息类型的繁重工作它持有的实现。离开CompositeRouter只需要将这些适配器的注册表存储到它们的消息类型。

这种方法最大的缺点是，感谢 Type Erasure , 无法创建 Router自己直接处理多种消息类型的实现。从 Java 的角度来看，在运行时 Router<MessageBase>与Router<OtherDerivedMessage>相同, 因此像 SuperRouter implements Router<MessageBase>, Router<OtherDerivedMessage> 这样的东西是非法的，与使用 C++ 模板不同。这也是您需要通过 explisit Class<T> 的原因周围的对象，而不仅仅是能够直接从 Router<T> 推断类型.

关于java - Java 的双向可扩展层次结构，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28902349/