Implementierung einer Kommunikation

[Generic1]

Hallo,

ich möchte mit einem Server über ein Protokoll kommunizieren. Das Protokoll ist zwar nicht so schwierig, es werden aber Strings vom Server zu Client hin und hergeschickt und dazu hätte ich eine Frage.

Ich sende einen String zum Server z.B.: 01 ANFRAGE CLIENTID
und bekomme je nach ANFRAGE- Text eine Antwort als String 01 ANTWORT CLIENTID (ANTWORT, CLIENTID haben eine definierte länge, z.B.: 15 Zeichen ANTWORT, 20 Zeichen CLIENTID)
Je nach Antwort sende ich dann wieder eine ANFRAGE an den Server usw.

Das schaut für mich sehr nach State- Maschine aus und es gibt auch ein State- Diagramm, wo das dargestellt ist.

Meine Frage wäre jetzt, wie man das am Besten implementiert, Die Anfragen mit einem StringBuffer zusammenzustellen dürfte kein Problem sein. Was schon eher ein Problem ist sind die Antworten, da ich zuerst wahrscheinlich mit "substring" die einzelnen Sachen aus dem Protokoll heraussuchen muss (Antwort, ClientID,..) und dann leider kein switch - case für die Strings einsetzen kann.

Hat vielleicht jemand eine Idee wie man das am Besten machen kann ohne eine rießige if-else if wurst zu schreiben?
Vielen Dank,
lg

 

[JohannisderKaeufer]

Warum kannst du kein switch - case für deine Strings verwenden?

Wenn du die Strings vorab schon als Enums definieren kannst, machst du mit valueOf(Class<T> enumType, String name) aus dem String den Enum-Wert, den du nun in Verbindung mit Switch case nutzen kannst.

Oder du machst das ganze Objektorientiert.
Für jede Antwort einen ResponseHandler

Interface ResponseHandler{

boolean handles(String response);

handleResponse();
}

class ...{
Collection<ResponseHandler> handlers = ...

void registerHandlers(){
handlers.add(new AHandler());
handlers.add(new BHandler());
}

void handleResponse(String response){
  for(ResponseHandler handler: handlers){
    if(handler.handels(response)){
      handler.handleResponse();
      break;
    }
  }
}
}

 

[Generic1]

Könntest du das mit dem OO Ansatz nochmal erklären, ganz hab ich das nicht verstanden. Für jede verschiedene Antwort gibt es einen eigenen Handler, ist dasd so? Und class ...{ implementiert ResponseHandler, oder?
Vielen Dank,
lg

 

[JohannisderKaeufer]

Nehmen wir an du hast einen Roboter

class Roboter{
  void turnLeft();
  void turnRight();
  void grab();
  ...
}

und nun bekommst du die Befehle über das Netzwerk in Form von Strings

String command = getCommand();

und möchtest das der Roboter diese nun dementsprechend ausführt. "left" bedeutet turnLeft, "right" für turnRight etc.

Dann kannst du sowas machen

public class TurnRightCommand implements ResponseHandler{
  public boolean handles(String command){
    return command.equals("right");
  }
  public void handle(Roboter robby){
    robby.turnRight();
  }
}

Das machst du für jeden Befehl.

Jetzt kannst du in deiner Netzwerkklasse folgendes machen

class Network{
  private Roboter robby = new Roboter();

  private Collection<ResponseHandler> responseHandlers = new ArrayList<ResponseHandler>();
  public Network(){
    //Handler Registrieren
    responseHandlers.add(new TurnRightCommand());
    responseHandlers.add(new TurnLeftCommand());
    ...
  }
  public void handleRequests(){
    String command = getCommand();
    for(ResponseHandler handler : responseHandlers){
      if(handler.handles(command)){
        handler.handle(robby);
        break;
      }
    }
  }

}

Du gehst also eine Liste durch und fragst jedes Element ob es mit dem Befehl etwas anfangen kann. Kann es etwas damit anfangen, dann lässt du dieses Element das ganze auch ausführen.

Nun kann man das ganze auch noch etwas geschickter Anfangen in dem man das Registrieren der Handler, nicht so macht wie hier beschrieben, sondern alle Handler in ein Package packt und dann dort nach allen Dateien sucht und per Reflection schaut ob sie vom Typ ResponseHandler sind und sie dann automatisch zur Liste hinzufügt.

Das ganze nennt sich auch Front Controller Pattern und findet z.B. in vielen Webframeworks Verwendung.

Der Vorteil gegenüber einem Ellenlangen if-else-Marathon liegt, darin das du jeden ResponseHandler einzeln Testen kannst. Ist ja eine recht überschaubare Klasse. Und die Klasse Network macht auch nicht viel mehr als zu entscheiden welches Objekt einen Befehl abarbeitet.

 

[Generic1]

Ich hab das Ganze jetzt mit dem State- Pattern gemacht.
Was mich jetzt stört ist, dass ich in jedem meiner States etwas zum Server senden muss, d.h. das ich die Kommunikation zum Server maximal verteilt habe - jetzt bin ich wieder am überlegen ob ich nicht doch ein switch - case mache, das zwar nicht so schon ist aber da hab ich den Code wenigstens nur in einer Klasse.
Habt ihr einen Vorschlag dazu bzw. hat von euch schon mal jemand eine Kommunikation mittels State- Diagramm gemacht? .
lg

 

[FArt]

Ich hätte auch das Kommando-Pattern vorgeschlagen, alternativ evtl. Status oder Strategie, das müsste man sich mal genau ansehen.

 

[Generic1]

Könntest du das genauer beschreiben wie du das machen würdest.
So weit ich das verstehe, würdest du eine Klasse haben, die das senden und empfangen steuert, wenn ein String empfangen wurde, diesen auswerten und einem Objekt übergeben, welches zuständig dafür ist -> ich würde dann also eine Klasse haben, welche für die Server- Kommunikation zuständig ist und die weiteren Objekte für die Abarbeitung des empfangenen -> hast du das so gemeint?
lg

 

[FArt]

Steht eigentlich hier ganz gut: Kommando (Entwurfsmuster) ? Wikipedia