Puoi raggiungere questo approccio mescolando il modello di strategia e il modello di comando.
È possibile definire le classi per i metodi di servizio, una classe per il proxy di servizio, una classe per la configurazione e una classe per effettuare una chiamata di servizio.
Definisci un'interfaccia per i tuoi metodi di servizio:
public interface IServiceMethod {
void setClient(Service service);
Object execute();
}
Crea classi per i tuoi metodi di servizio:
public class SomeMethod implements IServiceMethod {
private Service service;
public SomeMethod() {
}
@Override
public void setClient(Service service) {
this.client = client;
}
@Override
public T execute() {
return client.getService().someMethod();
}
}
Definisci una classe di configurazione:
public class ServiceConfiguration {
private String endPointUrl;
private EnvironmentType envType; //DEV,TEST,PROD
private String userName;
private String password;
private boolean isActive;
}
Definisci una classe per avvolgere il servizio e la sua configurazione:
public interface IServiceProxy {
Service getService();
ServiceConfiguration getConfiguration();
}
Costruisci il tuo proxy di servizio con la configurazione e ottieni endpoint (e altri dati di configurazione necessari) da qualche fornitore:
public class ServiceProxy implements IServiceProxy {
private Service service;
private ServiceConfiguration configuration;
public ServiceProxy(ServiceConfiguration serviceConfiguration) {
this.service = someFactory.getInstance().getClient(serviceConfiguration);
this.serviceConfiguration = serviceConfiguration;
}
@Override
public Service getService() {
return service;
}
@Override
public ServiceConfiguration getConfiguration() {
return configuration;
}
}
Costruisci MethodExecutor con il metodo:
public class MethodExecutor{
private IServiceMethod iServiceMethod;
public MethodExecutor(IServiceMethod iServiceMethod) {
this.iServiceMethod = iServiceMethod;
}
public Object execute() {
return iServiceMethod.execute();
}
}