对同一web服务进行多个异步调用的最佳方法

Question

我正在使用的应用程序将按以下顺序使用2个REST web服务：

1） 计数记录-了解特定时间范围内的记录数。

2）获取记录——一旦我们有了记录的数量，我们就需要调用这项服务。但是这项服务有一个门槛来一次性获取10K记录。假设第一个服务在特定的时间间隔内告诉我，它有100K的记录，那么我需要以分页方式调用第二个网络服务10次，考虑到它的阈值是一次10K的。

因此，如果我将进行10次同步调用，我的应用程序将太慢而无法响应。所以我需要一种机制来进行异步调用。

我在后端代码中使用spring框架，在web服务调用中使用rest模板。我希望找到对上述PostWeb服务进行异步调用的最佳方法

我做了一些研究，发现异步方法如下：https://spring.io/guides/gs/async-method/

您能告诉我这是我所看到的一种正确的方法吗？或者这是一种更好的异步调用方法吗？期待您的建议，谢谢！

Answer 1

如果它真的必须是异步的，那么使用Spring实现似乎是一个明智的想法。

Answer 2

这只是对@shawn答案的改进。在前面提供的实现中，有时我会遇到以下问题：

while (responses < futures.size()) {        
   for (Future<ResponseEntity<List<Record>>> future : futures) {
       if (future.isDone()) {
            responses++;
            try {
                ResponseEntity<List<Record>> responseEntity = future.get();
                fullListOfRecords.addAll(responseEntity.getBody());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
        }
    }
}

在这里，如果处理了6个线程，有时同一个线程被允许在上面的块中多次输入，所以它最终会有重复的记录作为响应。所以为了避免这种情况，我添加了回调块来创建最终响应，确保没有重复的响应，尽管我们仍然需要while（响应）

@Component
public class SampleAsyncService {
private RestTemplate restTemplate;
private AsyncRestTemplate asyncRestTemplate;

@Value("${myapp.batchSize:1000}")
private int batchSize;

public SampleAsyncService(AsyncRestTemplate asyncRestTemplate, RestTemplate restTemplate) {
    this.asyncRestTemplate = asyncRestTemplate;
    this.restTemplate = restTemplate;
}

public List<Record> callForRecords() {
    ResponseEntity<Integer> response = restTemplate.getForEntity("http://localhost:8081/countService",
            Integer.class);
    int totalRecords = response.getBody().intValue();
    List<Future<ResponseEntity<List<Record>>>> futures = new ArrayList<Future<ResponseEntity<List<Record>>>>();
    for (int offset = 0; offset < totalRecords;) {
        ListenableFuture<ResponseEntity<List<Record>>> future = asyncRestTemplate.exchange(
                "http://localhost:8081/records?startRow={}&endRow={}", HttpMethod.GET, null,
                new ParameterizedTypeReference<List<Record>>() {
                }, offset, batchSize);
        future.addCallback(
                new ListenableFutureCallback<ResponseEntity<ChatTranscript>>() {  
                    @Override  
                    public void onSuccess(ResponseEntity<ChatTranscript> response) {  
                        fullListOfRecords.addAll(responseEntity.getBody());
                        log.debug("Success: " + Thread.currentThread());  
                    }  

                    @Override  
                    public void onFailure(Throwable t) {
                        log.debug("Error: " + Thread.currentThread());
                    }  
                }
            );
        futures.add(future);
        offset = offset + batchSize;
    }

    int responses = 0;
    List<Record> fullListOfRecords = new ArrayList<Record>();
    while (responses < futures.size()) {
        for (Future<ResponseEntity<List<Record>>> future : futures) {
            if (future.isDone()) {
                responses++;
                try {
                    future.get();
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    return fullListOfRecords;
}

public class Record {
}

}

Answer 3

@Journycorner linked是一个很好的开始，但它并没有真正展示整个画面，因为它只发出一个请求。使用Future无疑是正确的。Spring4提供了一个AsyncRestTemplate，它返回一个Future，这正是您想要使用的。

在我的手机上，所以无法写出完整的代码，但这大致就是你想要做的。

@Component
public class SampleAsyncService {
    private RestTemplate restTemplate;
    private AsyncRestTemplate asyncRestTemplate;

    @Value("${myapp.batchSize:1000}")
    private int batchSize;

    public SampleAsyncService(AsyncRestTemplate asyncRestTemplate, RestTemplate restTemplate) {
        this.asyncRestTemplate = asyncRestTemplate;
        this.restTemplate = restTemplate;
    }

    public List<Record> callForRecords() {
        ResponseEntity<Integer> response = restTemplate.getForEntity("http://localhost:8081/countService",
                Integer.class);
        int totalRecords = response.getBody().intValue();
        List<Future<ResponseEntity<List<Record>>>> futures = new ArrayList<Future<ResponseEntity<List<Record>>>>();
        for (int offset = 0; offset < totalRecords;) {
            ListenableFuture<ResponseEntity<List<Record>>> future = asyncRestTemplate.exchange(
                    "http://localhost:8081/records?startRow={}&endRow={}", HttpMethod.GET, null,
                    new ParameterizedTypeReference<List<Record>>() {
                    }, offset, batchSize);
            futures.add(future);
            offset = offset + batchSize;
        }

        int responses = 0;
        List<Record> fullListOfRecords = new ArrayList<Record>();
        while (responses < futures.size()) {
            for (Future<ResponseEntity<List<Record>>> future : futures) {
                if (future.isDone()) {
                    responses++;
                    try {
                        ResponseEntity<List<Record>> responseEntity = future.get();
                        fullListOfRecords.addAll(responseEntity.getBody());
                    } catch (InterruptedException | ExecutionException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        return fullListOfRecords;
    }

    public class Record {
    }
}

*更新*创建完整的代码示例。