Refactor código java

Question

conjetura bien esta pregunta se parece mucho a:

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

considerar esta pregunta cerrada!

---

me gustaría refactorizar código que se ve algo como esto:

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

Es el código que comprueba la entrada de la toma para realizar alguna acción, pero no me gusta la construcción if else porque cada Cuando se agrega un nuevo comando al servidor (código), se debe agregar un nuevo if else que es feo. Además, al eliminar un comando, se debe modificar if else.

Answer 1

Recoge esos comandos en un Map<String, Command> donde Command es un interface con un método execute().

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. 
} 

Para obtener un paso más allá, usted podría considerar para llenar el mapa de forma dinámica mediante el escaneo de las clases que implementan una interfaz específica (Command en este caso) o una anotación específica en la ruta de clase. Google Reflections puede ayudar mucho en esto.

Actualización (de los comentarios) También puede considerar combinar el answer of Instantsoup con mi respuesta. Durante el método buildExecutor(), primero debe obtener el comando de un Map y si el comando no existe en Map, a continuación, tratar de cargar la clase asociada y la puso en el Map. Tipo de carga floja. Esto es más eficiente que escanear todo el classpath como en mi respuesta y crearlo cada vez como en la respuesta de Instantsoup.

Answer 2

Una forma podría ser tener una interfaz ICommand que es el contrato general para un comando, por ejemplo:

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

Y entonces usted podría utilizar el mecanismo de Java SPI para auto-descubrir sus diversas implementaciones y registrarlos en a Map<String,ICommand> y luego haz knownCommandsMap.get(input).execute(ctx) o algo por el estilo.

Esta práctica le permite desacoplar su servicio de implementaciones de mandatos, con eficacia haciendo los enchufable.

El registro de una clase de implementación con el SPI se hace agregando un archivo denominado como el nombre completo de su clase ICommand (de modo que si está en el archivo ficticio el archivo va a ser META-INF/dummy.ICommand dentro de su classpath), y luego ' ll cargar y registrarlos como:

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

Answer 3

¿Qué hay de las interfaces, una fábrica y un poco de reflexión? Todavía tendrá que manejar excepciones en malas entradas, pero siempre tendrá que hacer esto. Con este método, solo agrega una nueva implementación de Executor para una nueva entrada.

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

Su ejemplo de código se convierte entonces en

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

Answer 4

Construyendo el Patten de comandos en una clase de enumeración puede reducir algunos de los código repetitivo. Vamos a suponer que x es input.equals(x) en "XX" e y en input.equals(y) es "AA"

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

Usted dice que está procesando la entrada de un zócalo. ¿Cuánta entrada? ¿Qué tan complejo es? ¿Qué tan estructurado es?

Dependiendo de las respuestas a esas preguntas, es mejor escribir una gramática y dejar que un generador de analizador (por ejemplo, ANTLR) genere el código de procesamiento de entrada.