Umgestalten Java-Code

Question

Ok Vermutung diese Frage sieht viel wie:

What is the best way to replace or substitute if..else if..else trees in programs?

betrachten diese Frage GESCHLOSSEN!

---

Ich möchte Code Refactoring, die etwa wie folgt aussieht:

String input; // input from client socket. 
if (input.equals(x)) { 
    doX(); 
} else if (input.equals(y)) { 
    doY(); 
} else { 
    unknown_command(); 
} 

Es ist Code, der eine Eingabe von Socket überprüft, eine Aktion auszuführen, aber ich weiß nicht wie die if else Konstruktion, weil jeder Wenn ein neuer Befehl zum Server (Code) hinzugefügt wird, muss ein neuer Befehl hinzugefügt werden, der sonst hässlich ist. Auch beim Löschen eines Befehls muss die if else geändert werden.

Answer 1

Sammeln Sie diese Befehle in einer Map<String, Command>, wobei Command eine interface mit einer execute() Methode ist.

Map<String, Command> commands = new HashMap<String, Command>(); 
// Fill it with concrete Command implementations with `x`, `y` and so on as keys. 

// Then do: 
Command command = commands.get(input); 
if (command != null) { 
    command.execute(); 
} else { 
    // unknown command. 
} 

Um einen Schritt weiter kommen soll, können Sie die Karte dynamisch durch Scannen für die Klassen füllen eine bestimmte Schnittstelle (Command in diesem Fall) oder eine bestimmte Anmerkung im Classpath zu implementieren. Google Reflections kann viel dabei helfen.

Update (aus den Kommentaren) Sie können auch die Kombination der answer of Instantsoup mit meiner Antwort in Betracht ziehen. Rufen Sie während der Methode buildExecutor() zuerst den Befehl von einer Map und wenn der Befehl in Map nicht existiert, dann versuchen Sie, die zugehörige Klasse zu laden und in die Map. Eine Art faules Laden. Dies ist effizienter, als den gesamten Klassenpfad wie in meiner Antwort zu durchsuchen und ihn jedes Mal zu erstellen, wie in der Antwort von Instantsoup.

Answer 2

Eine Möglichkeit könnte sein, eine Schnittstelle zu haben ICommand, dass der Rahmenvertrag für einen Befehl, zB:

public interface ICommand { 
    /** @param context The command's execution context */ 
    public void execute(final Object context); 
    public String getKeyword(); 
} 

Und dann könnte man die Java verwenden SPI Mechanismus auf Ihre verschiedenen Implementierungen automatisch entdecken und registrieren sie in a Map<String,ICommand> und dann tun knownCommandsMap.get(input).execute(ctx) oder etwas Ähnliches.

Dies ermöglicht Ihnen praktisch, Ihren Dienst von Befehlsimplementierungen zu entkoppeln und diese Pluggable effektiv zu machen.

Die Registrierung einer Implementierungsklasse mit dem SPI erfolgt durch Hinzufügen einer Datei namens vollqualifizierter Name Ihrer ICommand-Klasse (wenn sie also im Paket dummy ist, wird die Datei innerhalb Ihres Klassenpfads META-INF/dummy.ICommand sein). ll laden und registrieren sie als:

final ServiceLoader<ICommand> spi = ServiceLoader.load(ICommand.class); 
for(final ICommand commandImpl : spi) 
    knownCommandsMap.put(commandImpl.getKeyword(), commandImpl); 

Answer 3

Wie wäre es mit Schnittstellen, eine Fabrik, und ein wenig Reflexion? Sie müssen weiterhin Ausnahmen bei ungültigen Eingaben behandeln, aber Sie müssen dies immer tun. Mit dieser Methode fügen Sie einfach eine neue Implementierung von Executor für eine neue Eingabe hinzu.

public class ExecutorFactory 
{ 
    public static Executor buildExecutor(String input) throws Exception 
    { 
     Class<Executor> forName = (Class<Executor>) Class.forName(input); 
     return (Executor) executorClass.newInstance(); 
    } 
} 

public interface Executor 
{ 
    public void execute(); 
} 


public class InputA implements Executor 
{ 
    public void execute() 
    { 
     // do A stuff 
    } 
} 

public class InputB implements Executor 
{ 
    public void execute() 
    { 
     // do B stuff 
    } 
} 

Ihr Codebeispiel wird dann

String input; 
ExecutorFactory.buildExecutor(input).execute(); 

Answer 4

Aufbau der Befehl patten auf einer Enum-Klasse können einige der Standardcode reduzieren. Nehmen wir an, dass x in input.equals(x) ist „XX“ und y in input.equals(y) ist „YY“

enum Commands { 
    XX { 
    public void execute() { doX(); }   
    }, 
    YY { 
    public void execute() { doY(); }   
    }; 

    public abstract void execute(); 
} 

String input = ...; // Get it from somewhere 

try { 
    Commands.valueOf(input).execute(); 
} 
catch(IllegalArgumentException e) { 
    unknown_command(); 
} 

Answer 5

Sie sagen, dass Sie eine Eingabe von einem Sockel sind zu verarbeiten. Wie viel Input? Wie komplex ist das? Wie strukturiert ist das?

Je nach den Antworten auf diese Fragen können Sie eine Grammatik besser schreiben und einen Parsergenerator (z. B. ANTLR) den Eingabeverarbeitungscode generieren lassen.