Verschiedene Möglichkeiten, den Ereignistyp zu bestimmen - Welches Designmuster soll verwendet werden?

Question

In meiner Anwendung gibt es zwei Möglichkeiten Ereignisse kann empfangen werden - entweder aus dem Hintergrund von der BackgroundEventListener Klasse behandelt oder in einer Zeile aus Datei von der FromFileEventListener Klasse behandelt lesen. Lassen Sie uns annehmen, dass sie beide die folgende Schnittstelle implementieren:

public interface EventListener<E> { 
    void mousePressed(E mouseEvent); 
    void mouseReleased(E mouseEvent); 
    void mouseClicked(E mouseEvent); 
} 

Die BackgroundEventListener Klasse:

public class BackgroundEventListener implements EventListener<MouseEvent> { 
    EventHandler<MouseEvent> eventHandler; 
    public BackgroundEventListener() { 
    eventHandler = new BackgroundEventHandler(); 
    } 
    @Override 
    public void mousePressed(MouseEvent mouseEvent) { 
    eventHandler.handleEvent(mouseEvent, "mousePressed"); 
    } 
    @Override 
    public void mouseReleased(MouseEvent mouseEvent) { 
    eventHandler.handleEvent(mouseEvent, "mouseReleased"); 
    } 
    @Override 
    public void mouseClicked(MouseEvent mouseEvent) { 
    eventHandler.handleEvent(mouseEvent, "mouseClicked"); 
    } 
} 

Wir können sehen, dass die BackgroundEventListener Klasse in der Art der Veranstaltung geht direkt abhängig davon, welche der Methoden aufgerufen wurde .

EventHandler Schnittstelle und Implementierungen:

public interface EventHandler<E> { 
    void handleEvent(E event, String type); 
} 

Hintergrund:

public class BackgroundEventHandler implements EventHandler<MouseEvent> { 
    @Override 
    public void handleEvent(MouseEvent event, String type) { 
//  TODO handle event coming from background 
    } 
} 

Aus Datei:

public class FromFileEventHandler implements EventHandler<String> { 
    @Override 
    public void handleEvent(String event, String type) { 
//  TODO handle event coming from background 
    } 
} 

kommt meine Frage. Im Hintergrundfall muss der Ereignistyp explizit als zusätzliches Argument übergeben werden. Wenn jedoch ein Ereignis aus einer Datei gelesen wird, ist die Information über den Typ des Ereignisses in dem Ereignis selbst vorhanden. Daher würde die FromFileEventListener Klasse brauchen so etwas wie folgt aussehen:

public class FromFileEventListener implements EventListener<String> { 
    EventHandler<String> eventHandler; 
    public FromFileEventListener() { 
    eventHandler = new FromFileEventHandler(); 
    } 
    @Override 
    public void mousePressed(String event) { 
    eventHandler.handleEvent(event, Utils.getTypeOutOfEvent(event)); 
    } 
    @Override 
    public void mouseReleased(String event) { 
    eventHandler.handleEvent(event, Utils.getTypeOutOfEvent(event)); 
    } 
    @Override 
    public void mouseClicked(String event) { 
    eventHandler.handleEvent(event, Utils.getTypeOutOfEvent(event)); 
    } 
} 

Dies führt im Falle als erstes Argument übergeben wird, und das zweite Argument der Art ist, die zuvor extrahiert werden muss, zum Beispiel ein mit Öffentliche statische Methode getTypeOutOfEvent(String event) der Klasse Utils - eine offensichtlich unnötige Duplizierung von Daten und Splitting-Event-Verarbeitung zwischen verschiedenen Klassen.

Was wäre die elegante Lösung für dieses Problem? Welches Designmuster sollte ich verwenden? (Ein Weg, ich dachte, war ein EventWrapper zu schaffen, die ich zu wickeln verwenden könnte entweder ein String event oder ein MouseEvent event, String type Paar)

Answer 1

Meiner Meinung nach gibt es Platz für Strategy Muster. Sie haben zwei Möglichkeiten, Ereignisse zu empfangen. Daher sollten Sie zwei Strategien kennen, wie Sie damit umgehen können.