Cómo refactorizar múltiples declaraciones provistas de interruptores

Jacek Wojtowicz

Tengo un punto final de descanso donde basa en el valor de enumeración método llamado I de servicio específico. Todos los servicios se extiende después de la misma clase abstracta.

public abstract class BaseService{
  someMethod()
}

public class ServiceA extends BaseService{
  @Override
  someMethod()
}

public class ServiceB extends BaseService{
  @Override
  someMethod()
}

public class RestEndpoint {
  @Inject
  ServiceA serviceA
  @Inject
  ServiceB serviceB

  public void someEndpoint(Enum value){
    switch (value){
    case 1:
       serviceA.someMethod();
    case 2:
       serviceB.someMethod();
   }
  }
}

La cosa es, puede haber muchos más servicios, y me pregunto si hay alguna forma mejor de hacerlo. Pensé en la implementación de patrón de estrategia, pero no sé si eso no sería 'exageración', ya que habrá en la mayoría de ~ 10/15 servicios.

EDITAR

Así pues mis servicios eran frijoles, lo que inyectaba otros granos en el interior, no había ninguna manera 'fácil' refactorizar esto - yo no podía crear algún método en la clase de enumeración que serían, por ejemplo, return new ServiceA()porque los granos luego dentro de mi ServiceAejemplo, no sería inyectado. Podría tratar de obtener el contexto y el conjunto de frijol específica, pero entonces no estaría a salvo (por ejemplo, u podría intentar inyectar no frijol, y el compilador no le permiten saber al respecto).

Así que si mi BaseServiceaplicación no usaría otros granos, la manera más fácil era crear método en la clase Enum

public abstract BaseService getService();

y poner en práctica esto como

anyServiceA{
 @Override
 public BaseService getService(){
  return new ServiceA();
 }
}

y en el servicio Resto simplemente llamar value.getService().someMethod();

Tal vez que va a ayudar a alguien.

Mak:

En general, hay 7 maneras de instrucción switch refactor están disponibles (podría ser más que eso :)).

1) Implementing the Strategy Pattern via Java Enum
2) Implementing the Command Pattern
3) Using the Java 8+ Supplier
4) Defining a Custom Functional Interface
5) Relying on Abstract Factory
6) Implementing State Pattern
7) Implementing via Predicate

Puede consultar este enlace para la implementación

https://www.developer.com/java/data/seven-ways-to-refactor-java-switch-statements.html

Espero que esto le pueda ayudar.