Question

我使用RestTemplate作为我的HttpClient来执行URL，服务器将返回一个json字符串作为响应。客户将通过传递DataKey的{{1}}对象来调用此库。

使用给定的userId，我将找出可以获取数据然后将这些机器存储在userId中的机器，以便我可以按顺序执行它们。 / LI>
之后我将检查第一个主机名是否在阻止列表中。如果它不在阻止列表中，那么我将在列表中创建一个带有第一个主机名的URL并执行它，如果响应成功，则返回响应。但是，让我们说如果第一个主机名在阻止列表中，那么我将尝试获取列表中的第二个主机名并创建URL并执行它，所以基本上， 首先找到主机名在制作网址之前不在阻止列表 。
现在，让我们说如果我们选择了第一个不在阻止列表中的主机名并执行了URL并且某种程度上服务器已关闭或没有响应，那么我将在列表中执行第二个主机名并继续执行此操作直到你得到一个成功的回应。 但请确保它们不在阻止列表中，因此我们需要遵循以上观点。
如果所有服务器都已关闭或在阻止列表中，那么我只需记录并返回服务不可用的错误。

下面是我的DataClient类，它将由客户调用，他们会将LinkedList对象传递给DataKey方法。

getData

下面是我的DataExecutorTask类：

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

我的阻止列表每1分钟从另一个后台线程继续更新。如果任何服务器关闭而没有响应，那么我需要使用这个 -

来阻止该服务器

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

为了检查是否有任何服务器在阻止列表中，我使用了这个 -

ShardMappings.blockHost(hostname);

如果服务器关闭或阻止列表，我将返回ShardMappings.isBlockHost(hostname);，基于SERVICE_UNAVAILABLE检查， 不确定它是否正确。

我在这里没有遵循单一责任原则我想是。任何人都可以举例说明在这里使用SRP原理的最佳方法。

经过深思熟虑之后，我能够提取下面给出的主机类，但不确定 在上面中使用它的最佳方法 {{1} } class。

response == null

Answer 1

您的担忧是有效的。首先，让我们看看原始数据执行程序的作用：

First, it is getting list of hostnames
Next, it loops through every hostnames that do the following things:
    It checks whether the hostname is valid to send request.
    If not valid: skip. 
    Else continue.
        Generate the URL based on hostname
        Send the request
        Translate the request response to domain response
        Handle exceptions
If the hostnames is empty, generate an empty response
Return response

现在，我们可以做些什么来关注SRP？我可以看到，我们可以将这些操作分组到一些组中。我可以看到，这些操作可以分为：

HostnameValidator:        checks whether the hostname is valid to send request
--------------
HostnameRequestSender:    Generate the URL
                          Send the request
--------------
HttpToDataResponse:       Translate the request response to domain response
--------------
HostnameExceptionHandler: Handle exceptions

这就是解除操作和跟踪SRP的一种方法。还有其他方法，例如简化您的操作：

First, it is getting list of hostnames
If the hostnames is empty, generate an empty response
Next, it loops through every hostnames that do the following things:
    It checks whether the hostname is valid to send request
    If not valid: remove hostname
    Else: Generate the URL based on hostname
Next, it loops through every valid hostnames that do the following things:
    Send the request
    Translate the request response to domain response
    Handle exceptions
Return response

然后它也可以分成：

HostnameValidator:        checks whether the hostname is valid to send request
--------------
ValidHostnameData:        Getting list of hostnames
                          Loops through every hostnames that do the following things:
                              Checks whether the hostname is valid to send request
                              If not valid: remove hostname
                              Else: Generate the URL based on hostname
--------------
HostnameRequestSender:    Send the request
--------------
HttpToDataResponse:       Translate the request response to domain response
--------------
HostnameExceptionHandler: Handle exceptions

当然还有其他方法可以做到。我将实现细节留空，因为有很多方法可以实现它。

如何在我的HttpClient执行器中遵循单一责任原则？

1 个答案: