在Java中避免'instanceof'

Question

我有以下（可能是常见的）问题，现在绝对让我困惑：

有几个生成的事件对象扩展了抽象类Event ，我想把它们分成Session Beans，比如

public void divideEvent(Event event) {
    if (event instanceof DocumentEvent) {
        documentGenerator.gerenateDocument(event);
    } else if (event instanceof MailEvent) {
        deliveryManager.deliverMail(event);
        ...
    }
    ...

}

但是将来可能会有两种以上的事件类型，所以if-else将会很长并且可能无法读取。 另外我认为在这种情况下， instanceof并不是真正的“最佳实践”。

我可以向Event类型添加一个抽象方法，让它们自行划分但是我必须在每个实体中注入特定的Session Bean。

是否有任何暗示可以为这个问题实现“漂亮”的解决方案？

谢谢你的帮助！

Answer 1

最简单的方法是让Event提供一个可以调用的方法，以便Event知道该怎么做。

interface Event {
    public void onEvent(Context context);
}

class DocumentEvent implements Event {
    public void onEvent(Context context) {
         context.getDocumentGenerator().gerenateDocument(this);
    }
}

class MailEvent implements Event {
    public void onEvent(Context context) {
         context.getDeliveryManager().deliverMail(event);
    }
}


class Context {
    public void divideEvent(Event event) {
        event.onEvent(this);
    }
}

Answer 2

多态性是你的朋友。

class DocumentGenerator {
   public void generate(DocumentEvent ev){}
   public void generate(MainEvent ev){}
   //... and so on
}

然后就是

 DocumentGenerator dg = new DocumentGenerator();

 // ....
 dg.generate(event);

更新

许多人提出反对意见，“你必须在编译时知道各种事件。” 而且，是的，您显然必须知道您在生成器部件的编译时要解释的事件，否则您何时可以编写生成部件？

这些竞争示例使用Command模式，这很好，但意味着事件不仅要知道它们的表示细节，还要知道如何打印它们的表示。 这意味着每个类可能有两种需求变化，它们的敏感性：事件所代表的变化，以及事件在打印中的表示方式的变化。

现在，考虑一下，例如，需要将其国际化。 在Command-pattern的情况下，你必须转到n 个不同的事件类型的类，并编写新的do方法。 在多态性的情况下，更改被本地化为一个类。

当然，如果您需要进行一次国际化，您可能需要多种语言，这会促使您在Command-pattern案例中为每个类添加类似策略的内容，现在需要n个类× m种语言; 再次，在多态性情况下，您只需要一个策略和一个类。

有理由选择任何一种方法，但声称多态方法是错误的只是不正确。

Answer 3

每个事件都有一个功能，比如do。 每个子类都覆盖do，以执行（：P）适当的操作。 动态调度之后会执行其他所有操作。 你需要做的就是调用event.do（）

Answer 4

我没有评论权，我也不知道确切的答案。 但这只是我或一些人在这里建议使用重载（这发生在编译时，因此只是生成编译错误）来解决这个问题？

只是一个例子。 如你所见，它不会编译。

package com.stackoverflow;

public class Test {
    static abstract class Event {}
    static class MailEvent extends Event {}
    static class DocEvent extends Event {}

    static class Dispatcher {
        void dispatchEvent(DocEvent e) {
            System.out.println("A");
        }

        void dispatchEvent(MailEvent e) {
            System.out.println("B");
        }
    }

    public static void main(String[] args) {
        Dispatcher d = new Dispatcher();
        Event e = new DocEvent();

        d.dispatchEvent(e);
    }

Answer 5

利用方法解析顺序有什么问题？

public void dispatchEvent(DocumentEvent e) {
    documentGenerator.gerenateDocument(event);
}

public void dispatchEvent(MailEvent e) {
    deliveryManager.deliverMail(event);
}

让Java完成匹配正确参数类型的工作，然后正确地调度事件。

Answer 6

这是Sum类型的典型用例，也称为标记联合。 遗憾的是，Java不直接支持它们，因此必须使用访问者模式的某些变体来实现它们。

interface DocumentEvent {
    // stuff specific to document event
}

interface MailEvent {
    // stuff specific to mail event
}

interface EventVisitor {
    void visitDocumentEvent(DocumentEvent event);
    void visitMailEvent(MailEvent event);
}

class EventDivider implements EventVisitor {
    @Override
    void visitDocumentEvent(DocumentEvent event) {
        documentGenerator.gerenateDocument(event);
    } 

    @Override
    void visitMailEvent(MailEvent event) {
        deliveryManager.deliverMail(event);
    }
}

这里我们定义了EventDivider ，现在提供一个调度机制：

interface Event {
    void accept(EventVisitor visitor);
}

class DocumentEventImpl implements Event {
    @Override
    void accept(EventVisitor visitor) {
        visitor.visitDocumentEvent(new DocumentEvent(){
            // concrete document event stuff
        });
    }
}

class MailEventImpl implements Event { ... }

public void divideEvent(Event event) {
    event.accept(new EventDivider());
}

在这里，我使用了最大可能的关注点分离，以便每个类和接口的责任是唯一的。 在现实生活中，项目DocumentEventImpl ， DocumentEvent实现和DocumentEvent接口声明通常合并到单个类DocumentEvent ，但这会引入循环依赖关系并强制在具体类之间产生一些依赖关系（我们知道，人们应该更喜欢依赖于接口）。

另外， void通常应该用类型参数替换以表示结果类型，如下所示：

interface EventVisitor<R> {
    R visitDocumentEvent(DocumentEvent event);
    ...
}

interface Event {
    <R> R accept(EventVisitor<R> visitor);
}

这允许人们使用无状态访问者，这是非常好的处理。

这种技术允许（几乎？）总是机械地消除instanceof而不是必须找出特定问题的解决方案。

Answer 7

您可以针对每种事件类型注册每个处理程序类，并在事件发生时执行调度。

class EventRegister {

   private Map<Event, List<EventListener>> listerMap;


   public void addListener(Event event, EventListener listener) {
           // ... add it to the map (that is, for that event, get the list and add this listener to it
   }

   public void dispatch(Event event) {
           List<EventListener> listeners = map.get(event);
           if (listeners == null || listeners.size() == 0) return;

           for (EventListener l : listeners) {
                    l.onEvent(event);  // better to put in a try-catch
           }
   }
}

interface EventListener {
    void onEvent(Event e);
}

然后让您的特定处理程序实现该接口，并使用EventRegister注册这些处理程序。

Answer 8

你可以有一个Dispatcher接口，定义如下

interface Dispatcher {
    void doDispatch(Event e);
}

使用DocEventDispatcher ， MailEventDispatcher等实现

然后定义一个Map<Class<? extends Event>, Dispatcher> 使用(DocEvent, new DocEventDispatcher())等条目Map<Class<? extends Event>, Dispatcher> 。 然后您的调度方法可以简化为：

public void divideEvent(Event event) {
    dispatcherMap.get(event.getClass()).doDispatch(event);
}

这是一个单元测试：

public class EventDispatcher {
    interface Dispatcher<T extends Event> {
        void doDispatch(T e);
    }

    static class DocEventDispatcher implements Dispatcher<DocEvent> {
        @Override
        public void doDispatch(DocEvent e) {

        }
    }

    static class MailEventDispatcher implements Dispatcher<MailEvent> {
        @Override
        public void doDispatch(MailEvent e) {

        }
    }


    interface Event {

    }

    static class DocEvent implements Event {

    }

    static class MailEvent implements Event {

    }

    @Test
    public void testDispatcherMap() {
        Map<Class<? extends Event>, Dispatcher<? extends Event>> map = new HashMap<Class<? extends Event>, Dispatcher<? extends Event>>();
        map.put(DocEvent.class, new DocEventDispatcher());
        map.put(MailEvent.class, new MailEventDispatcher());

        assertNotNull(map.get(new MailEvent().getClass()));
    }
}