9

我有以下情况，其中客户端类根据它接收到的消息类型执行不同的行为。我想知道是否有更好的方法来做到这一点，因为我不喜欢 instanceof 和 if 语句。

我想做的一件事是将方法从客户端类中提取出来并将它们放入消息中。我会在 IMessage 接口中放置一个类似 process() 的方法，然后将特定于消息的行为放在每个具体的消息类型中。这将使客户端变得简单，因为它只会调用 message.process() 而不是检查类型。但是，唯一的问题是条件中包含的行为与对 Client 类中包含的数据的操作有关。因此，如果我确实在具体的消息类中实现了一个流程方法，我将不得不将它传递给客户端，我也不知道这是否真的有意义。

public class Client {
    messageReceived(IMessage message) {
        if(message instanceof concreteMessageA) {
            concreteMessageA msg = (concreteMessageA)message;
            //do concreteMessageA operations
        }
    }
        if (message instanceof concreteMessageB) {
            concreteMessageb msg = (concreteMessageB)message;
            //do concreteMessageB operations
        }
}
4

6 回答 6

7

避免 instanceof 测试的简单方法是多态分派；例如

public class Client {
    void messageReceived(IMessage message) {
        message.doOperations(this);
    }
}

其中每个消息类都定义了一个适当的doOperations(Client client)方法。

编辑：第二个更符合要求的解决方案。

用 switch 语句替换一系列“instanceof”测试的替代方法是：

public class Client {
    void messageReceived(IMessage message) {
        switch (message.getMessageType()) {
        case TYPE_A:
           // process type A
           break;
        case TYPE_B:
           ...
        }
    }
}

每个 IMessage 类都需要定义一个int getMessageType()方法来返回相应的代码。枚举和整数一样工作，而且更优雅，IMO。

于 2009-08-10T04:08:33.690 回答
5

这里的一个选项是处理程序链。您有一个处理程序链，每个处理程序都可以处理一条消息（如果适用）然后使用它，这意味着它不会进一步向下传递。首先定义Handler接口：

public interface Handler {
    void handle(IMessage msg);
}

然后处理程序链逻辑如下所示：

List<Handler> handlers = //...
for (Handler h : handlers) {
    if (!e.isConsumed()) h.handle(e);
}

然后每个处理程序可以决定处理/消费一个事件：

public class MessageAHandler implements Handler {
    public void handle(IMessage msg) {
        if (msg instanceof MessageA) {
            //process message
            //consume event 
            msg.consume();
        }
    }
}

当然，这并没有摆脱instanceofs - 但它确实意味着你没有一个巨大的if-elseif-else-if-instanceof块，这可能是不可读的

于 2009-08-10T06:23:57.613 回答
1

您使用的是什么类型的消息系统？

许多人可以选择根据消息头或内容向处理程序添加过滤器。如果支持这一点，您只需根据消息类型创建一个带有过滤器的处理程序，然后您的代码就干净整洁，无需 instanceof 或检查类型（因为消息传递系统已经为您检查了它）。

我知道您可以在 JMS 或 OSGi 事件服务中执行此操作。

由于您使用的是 JMS，因此您基本上可以执行以下操作来注册您的侦听器。这将为每个唯一的消息类型创建一个侦听器。

  String filterMsg1 = "JMSType='messageType1'";
  String filterMsg2 = "JMSType='messageType2'";

  // Create a receiver using this filter
  Receiver receiverType1 = session.createReceiver(queue, filterMsg1);
  Receiver receiverType2 = session.createReceiver(queue, filterMsg2);

  receiverType1.setMessageHandler(messageType1Handler);
  receiverType2.setMessageHandler(messageType2Handler);

现在每个处理程序将只接收特定的消息类型（没有 instanceof 或 if-then），当然假设发送者通过调用传出消息上的 setJMSType() 来设置类型。

此方法内置于消息中，但您当然可以创建自己的标头属性并对其进行过滤。

于 2009-08-10T14:09:09.573 回答
0 
//Message.java

abstract class Message{
     public abstract void doOperations();
 }

//MessageA.java

 class MessageA extends Message{
    public void doOperations(){ 
         //do concreteMessageA operations ;
    }
 }

   //MessageB.java

class MessageB extends Message {
     public void doOperations(){ 
         //do concreteMessageB operations 
     }
}

//MessageExample.java

class MessageExample{
   public static void main(String[] args) {
        doSmth(new MessageA());
    }

    public static void doSmth(Message message) {
       message.doOperations() ;     

     }
}
于 2010-08-11T08:20:42.410 回答
0

使用双重分派的 Java 8 解决方案。没有完全摆脱，instanceof但每条消息只需要一次检查，而不是 if-elseif 链。

public interface Message extends Consumer<Consumer<Message>> {};

public interface MessageA extends Message {

   @Override
   default void accept(Consumer<Message> consumer) {
      if(consumer instanceof MessageAReceiver){
        ((MessageAReceiver)consumer).accept(this);
      } else {
        Message.super.accept(this);
      }
   }
}

public interface MessageAReceiver extends Consumer<Message>{
   void accept(MessageA message);
}
于 2016-08-25T03:24:11.243 回答
0

使用 JMS 2.0，您可以使用：

consumer.receiveBody(String.class)

有关更多信息，您可以参考这里：

于 2019-04-04T11:32:48.047 回答