Como seguir o princípio de responsabilidade única no meu executor HttpClient?
estou usandoRestTemplate
como meuHttpClient
para executar a URL e o servidor retornará uma string json como resposta. O cliente ligará para esta biblioteca passandoDataKey
objeto que possuiuserId
iniciar.
userId
, Vou descobrir quais são as máquinas que posso acessar para obter os dados e depois armazená-las em umLinkedList
, para que eu possa executá-los sequencialmente.Depois disso, vou verificar se o primeiro nome do host está na lista de bloqueios ou não. Se não estiver na lista de bloqueios, criarei uma URL com o primeiro nome de host na lista e a executarei. Se a resposta for bem-sucedida, retornarei a resposta. Mas digamos que se esse primeiro nome de host estiver na lista de bloqueios, tentarei obter o segundo nome de host na lista, criar o URL e executá-lo, basicamente,primeiro encontre o nome do host que não está na lista de bloqueios antes de criar o URL.Agora, digamos que se selecionamos o primeiro nome do host que não estava na lista de bloqueios e executamos a URL e de alguma forma o servidor estava inoperante ou não estava respondendo, executarei o segundo nome do host na lista e continuarei fazendo isso até obter uma resposta bem-sucedida.Mas verifique se eles também não estavam na lista de bloqueios, por isso precisamos seguir o ponto acima.Se todos os servidores estiverem inativos ou na lista de bloqueios, eu posso simplesmente registrar e retornar o erro de que o serviço não está disponível.Abaixo está minha classe DataClient, que será chamada pelo cliente e eles passarãoDataKey
opor-se agetData
método.
public class DataClient implements Client {
private RestTemplate restTemplate = new RestTemplate(new HttpComponentsClientHttpRequestFactory());
private ExecutorService service = Executors.newFixedThreadPool(15);
public Future<DataResponse> getData(DataKey key) {
DataExecutorTask task = new DataExecutorTask(key, restTemplate);
Future<DataResponse> future = service.submit(task);
return future;
}
}
Abaixo está minha classe DataExecutorTask:
public class DataExecutorTask implements Callable<DataResponse> {
private DataKey key;
private RestTemplate restTemplate;
public DataExecutorTask(DataKey key, RestTemplate restTemplate) {
this.restTemplate = restTemplate;
this.key = key;
}
@Override
public DataResponse call() {
DataResponse dataResponse = null;
ResponseEntity<String> response = null;
MappingsHolder mappings = ShardMappings.getMappings(key.getTypeOfFlow());
// given a userId, find all the hostnames
// it can also have four hostname or one hostname or six hostname as well in the list
List<String> hostnames = mappings.getListOfHostnames(key.getUserId());
for (String hostname : hostnames) {
// If host name is null or host name is in local block list, skip sending request to this host
if (ClientUtils.isEmpty(hostname) || ShardMappings.isBlockHost(hostname)) {
continue;
}
try {
String url = generateURL(hostname);
response = restTemplate.exchange(url, HttpMethod.GET, key.getEntity(), String.class);
if (response.getStatusCode() == HttpStatus.NO_CONTENT) {
dataResponse = new DataResponse(response.getBody(), DataErrorEnum.NO_CONTENT,
DataStatusEnum.SUCCESS);
} else {
dataResponse = new DataResponse(response.getBody(), DataErrorEnum.OK,
DataStatusEnum.SUCCESS);
}
break;
// below codes are duplicated looks like
} catch (HttpClientErrorException ex) {
HttpStatusCodeException httpException = (HttpStatusCodeException) ex;
DataErrorEnum error = DataErrorEnum.getErrorEnumByException(httpException);
String errorMessage = httpException.getResponseBodyAsString();
dataResponse = new DataResponse(errorMessage, error, DataStatusEnum.ERROR);
return dataResponse;
} catch (HttpServerErrorException ex) {
HttpStatusCodeException httpException = (HttpStatusCodeException) ex;
DataErrorEnum error = DataErrorEnum.getErrorEnumByException(httpException);
String errorMessage = httpException.getResponseBodyAsString();
dataResponse = new DataResponse(errorMessage, error, DataStatusEnum.ERROR);
return dataResponse;
} catch (RestClientException ex) {
// if it comes here, then it means some of the servers are down so adding it into block list
ShardMappings.blockHost(hostname);
}
}
if (ClientUtils.isEmpty(hostnames)) {
dataResponse = new DataResponse(null, DataErrorEnum.PERT_ERROR, DataStatusEnum.ERROR);
} else if (response == null) { // either all the servers are down or all the servers were in block list
dataResponse = new DataResponse(null, DataErrorEnum.SERVICE_UNAVAILABLE, DataStatusEnum.ERROR);
}
return dataResponse;
}
}
Minha lista de bloqueios continua sendo atualizada de outro encadeamento em segundo plano a cada 1 minuto. Se algum servidor estiver inoperante e não estiver respondendo, preciso bloquear esse servidor usando este -
ShardMappings.blockHost(hostname);
E para verificar se algum servidor está na lista de bloqueios ou não, eu uso isso -
ShardMappings.isBlockHost(hostname);
Eu estou retornandoSERVICE_UNAVAILABLE
se os servidores estiverem inativos ou na lista de bloqueios, com base emresponse == null
Verifica,não tenho certeza se é uma abordagem correta ou não.
Não estou seguindo o Princípio da responsabilidade única aqui, acho que. Alguém pode dar um exemplo de qual é a melhor maneira de usar o princípio SRP aqui.
Depois de pensar muito, consegui extrair a classe hosts como a apresentada abaixo, mas não tenho certezaqual é a melhor maneira de usar isso no meu acima DataExecutorTask
classe.
public class Hosts {
private final LinkedList<String> hostsnames = new LinkedList<String>();
public Hosts(final List<String> hosts) {
checkNotNull(hosts, "hosts cannot be null");
this.hostsnames.addAll(hosts);
}
public Optional<String> getNextAvailableHostname() {
while (!hostsnames.isEmpty()) {
String firstHostname = hostsnames.removeFirst();
if (!ClientUtils.isEmpty(firstHostname) && !ShardMappings.isBlockHost(firstHostname)) {
return Optional.of(firstHostname);
}
}
return Optional.absent();
}
public boolean isEmpty() {
return hostsnames.isEmpty();
}
}