(Best Practice) Verarbeitung von Protokoll Befehlen

Also, ich habe eine Client/Server Anwendung geschrieben, die Daten und Befehle (einfache Strings) hin und her schickt. Die Verarbeitung übernimmt dabei ein eigenes Protokoll. Bislang sieht das so aus, das ich Konstanten habe, die die Befehle definieren und eine Methode mit sehr vielen If-Bedingungen, welche die weitere Verarbeitung übernimmt (je nachdem welcher Befehl gesendet wurde).
Dafür hab ich ein Interface,..

public interface Protocol
{
   public static final String COMMAND_1 = "befehl1";
   //[...]


   public void process(String input);
}

... welches von zwei Klassen implementiert wird (jeweils ein ServerProtocol und ein ClientProtocol).

public class ServerProtocol implements Protocol
{
   public void procss(String input)
   {
      if(input.equals(Protocol.COMMAND_1)
      {   // tu was
      }
     // [... und viele weitere]
   }
}

Das ist jedoch sehr Erweiterungs- und Wartungsunfreundlich wie ich finde. Wie könnte man das anders lösen?

Mein bisherigen Idee ist folgende:
Ich habe eine abstrakte Klasse für einen Befehl:

public abstract class Command
{
    private String name;
    
    public Command(String name)
    {
	this.name = name;
    }
    
    public abstract void execute();


    public String getCommandName()
    {
	return name;
    }
}

In dem ServerProtocol gibt es nun eine Map, in der alle möglichen Befehle für die Server-Seite eingefügt werden.

private void init()
    {
	Map<String, Command> temp = new HashMap<String, Command>();
	temp.put(COMMAND_1, new Command(COMMAND_1)
	{


	    @Override
	    public void execute()
	    {
		client.tuWas();
	    }
	});
        //[...]
        commands = Collections.unmodifiableMap(temp);
}

Aufgerufen wird das dann durch die process(String input) Methode.

@Override
    public void processInput(String data)
    {
	commands.get(data).execute();
    }

Das ist schon besser als vorher, jedoch auch nicht ganz optimal, da man auch hier wieder suchen muss, wenn man einen Befehl ändern will. Hab da gedacht, man könnte eventuell etwas mit Reflection machen, aber das funktioniert auch nicht, da ich das nicht automatisieren kann, da die Verarbeitung eines Behfels ja immer unterschiedlich ist.

Also nochmal die Frage, gibt es eine bessere Möglichkeit?

block_

Ein Paket mit den Klassen hab ich mir auch schon überlegt, allerdings bin ich mir nich sicher ob das so sinnvoll ist, da es schon jetzt eine Menge Befehle sind. Wenn man das laden dann noch mit Reflection lösen könnte, würde ich mir das nochmal überlegen, aber wie ich das gesehen hab geht das nicht so wirklich.
Müsste man mal ausporbieren, welche der beiden Methoden praktikabler ist.

block_

Es wurde kein Framework genutzt. Der Server, und der Client auch, wurde mit Java(Android) selbst implementiert (Plain Sockets).
Also die ganze App sieht bisher so aus:
In der App ist sowohl der Client-Anteil, als auch der Server-Anteil, damit die App unabhängig von externen Server ist (und man in jedem Netzwerk, in das man reinkommt, die App nutzen kann). Kommuniziert wird nur über WLAN, nicht übers Internet. Befinden sich mehrere Geräte im WLAN, kann eines davon einen Server starten mit dem sich die anderen verbinden und Daten austauschen können.

block_

Das ich das auf beiden Seiten (Client/Server) ändern muss, dessen bin ich mir schon bewusst. Ich versuche halt einen möglichst guten Kompromiss zu finden, der das ganze übersichtlicher macht, aber auch das man an so wenig Stellen wie möglich Änderungen durchführen muss.
Deine Kombination aus enum+int und switch würde mir bisher nicht viel bringen, da ich die Befehle als String brauche ( "server_tu_dies"). Allerdings könnte man den enum auch eine String Varaiable verpassen, wodurch aber die switch nicht mehr funktionieren würde (Strings in switch erst ab java7). Würde ich dann für jeden Befehl eine Klasse anlegen und dazu ein enum mit dem Namen der Klasse, könnte man das laden mit Reflection lösen und man hätte nur noch zwei Stellen die man ändern muss. Da es aber sowieso darauf hinaus läuft, an mehreren Stellen zu bearbeiten muss ich mir erst angucken, welche Methode einfacher und schneller zu handhaben ist.

Zitat von Lucas de Vil

Dein Objektansatz ist zwar recht schön, doch verstößt er für mich gegen das Prinzip der Kapselung. Es sollten ja Daten und Logik getrennt sein.

Wo siehst du hier eine Verletzung des dir genannten Prinzips? In meinen Augen ist das alles Logik.

block_