Vermeidung von instanceof beim Überprüfen eines Nachrichtentyps

Question

Ich habe die folgende Situation, in der eine Client-Klasse unterschiedliche Verhalten auf der Grundlage der Art der Nachricht führt, die es empfängt. Ich frage mich, ob es eine bessere Möglichkeit gibt, dies zu tun, da ich die instanceof- und die if-Anweisungen nicht mag.

Eine Sache, die ich mir vorgenommen habe, war, die Methoden aus der Clientklasse herauszuziehen und sie in die Nachrichten einzufügen. Ich würde eine Methode wie process() in die IMessage-Schnittstelle einfügen und dann das nachrichtenspezifische Verhalten in jeden der konkreten Nachrichtentypen einfügen. Dies würde den Client einfach machen, da er nur message.process() aufrufen würde, anstatt Typen zu prüfen. Das einzige Problem dabei ist jedoch, dass das in den Bedingungen enthaltene Verhalten mit Operationen auf Daten in der Klasse Client zu tun hat. Wenn ich also eine Prozessmethode in den konkreten Nachrichtenklassen implementieren würde, müsste ich sie dem Client übergeben und ich weiß nicht, ob das auch wirklich Sinn macht.

Answer 1

Der einfache Weg zur Vermeidung von instanceof testing ist polymorph zu versenden; z.B.

wobei jede Nachrichtenklasse eine geeignete doOperations(Client client) Methode definiert.

EDIT: zweite Lösung, die besser entspricht den Anforderungen.

Eine Alternative, die eine Folge von ‚Instanceof‘ Tests mit einer Switch-Anweisung ersetzt ist:

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

Jeder IMessage Klasse benötigt eine int getMessageType() Methode definieren den entsprechenden Code zurückzukehren. Enums funktionieren genauso gut und sind eleganter, IMO.

Answer 2

Eine Option ist hier eine Handler-Kette. Sie haben eine Kette von Handlern, von denen jeder eine Nachricht verarbeiten kann (falls zutreffend) und dann verbrauchen es, was bedeutet, es wird nicht weiter unten in der Kette weitergegeben werden. Zunächst definieren Sie die Handler Schnittstelle:

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

Und dann die Behandlungskette Logik wie folgt aussieht:

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

Dann kann jeder Handler entscheiden/handhaben consume ein Ereignis:

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

Of natürlich, das wird nicht die Beseitigung der instanceof s - aber es bedeutet, Sie haben keine großen if-elseif-else-if-instanceof Block, der nicht lesbar sein kann

Answer 3

Welche Art von Nachrichtensystem verwenden Sie?

Viele haben Optionen zum Hinzufügen eines Filters zu den Handlern basierend auf Nachrichtenheader oder Inhalt. Wenn dies unterstützt wird, können Sie einfach einen Handler mit einem Filter erstellen, basierend auf Nachrichtentyp, dann ist der Code schön und sauber, ohne die Notwendigkeit für instanceof oder Typüberprüfung (da das Messaging-System bereits für Sie überprüft).

Ich weiß, dass Sie dies in JMS oder dem OSGi-Ereignisdienst tun können.

Da Sie JMS verwenden, können Sie grundsätzlich Ihre Listener registrieren. Dies erstellt einen Listener für jeden eindeutigen Nachrichtentyp.

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); 

Jetzt wird jeder Handler des spezifischen Nachrichtentyp nur (kein instanceof oder if-then) erhält, natürlich unter der Annahme, dass der Absender die Art über Anrufe zu setJMSType() auf der Ansage setzt.

Diese Methode ist in Nachricht integriert, aber Sie können natürlich Ihre eigene Header-Eigenschaft erstellen und stattdessen filtern.

Answer 4

//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() ;  

    } 
} 

Answer 5

Eine Java 8-Lösung, die doppelten Versand verwendet. Wird instanceof nicht vollständig los, erfordert aber nur eine Überprüfung pro Nachricht anstelle einer if-elseif-Kette.

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); 
}