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.

Usando o dadouserId, 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();
    }
}