如何通过 RequestFactory 有效地使用 RestTemplate？

Question

我正在开发一个项目，在该项目中我需要对运行 Restful 服务的服务器进行 HTTP URL 调用，该服务将响应作为 JSON 字符串返回。我在这里使用RestTemplate 和HttpComponentsClientHttpRequestFactory 来执行一个url。

我使用HttpComponentsClientHttpRequestFactory 在我的RestTemplate 上设置了http 请求超时（读取和连接超时）。

下面是我的界面：

public interface Client {

    // for synchronous
    public String getSyncData(String key, long timeout);

    // for asynchronous
    public String getAsyncData(String key, long timeout);
}

下面是我的客户端接口实现-

public class DataClient implements Client {

    private final RestTemplate restTemplate = new RestTemplate();
    private ExecutorService executor = Executors.newFixedThreadPool(10);

    // for synchronous call
    @Override
    public String getSyncData(String key, long timeout) {
        String response = null;

        try {
            Task task = new Task(key, restTemplate, timeout);

            // direct call, implementing sync call as async + waiting is bad idea. 
            // It is meaningless and consumes one thread from the thread pool per a call.               
            response = task.call();
        } catch (Exception ex) {
            PotoLogging.logErrors(ex, DataErrorEnum.CLIENT_ERROR, key);
        }

        return response;
    }

    // for asynchronous call
    @Override
    public Future<String> getAsyncData(String key, long timeout) {
        Future<String> future = null;

        try {
            Task task = new Task(key, restTemplate, timeout);
            future = executor.submit(task); 
        } catch (Exception ex) {
            PotoLogging.logErrors(ex, DataErrorEnum.CLIENT_ERROR, key);
        }

        return future;
    }
}

下面是我的简单任务类

class Task implements Callable<String> {

    private RestTemplate restTemplate;
    private String key;
    private long timeout; // in milliseconds

    public Task(String key, RestTemplate restTemplate, long timeout) {
        this.key = key;
        this.restTemplate = restTemplate;
        this.timeout = timeout;
    }

    public String call() throws Exception {

        String url = "some_url_created_by_using_key";

        // does this looks right the way I am setting request factory?
        // or is there any other effficient way to do this?
        restTemplate.setRequestFactory(clientHttpRequestFactory());
        String response = restTemplate.exchange(url, HttpMethod.GET, null, String.class);

        return response;
    }

    private static ClientHttpRequestFactory clientHttpRequestFactory() {
        // is it ok to create a new instance of HttpComponentsClientHttpRequestFactory everytime?
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setReadTimeout(timeout); // setting timeout as read timeout
        factory.setConnectTimeout(timeout); // setting timeout as connect timeout
        return factory;
    }   
}

现在我的问题是 - 我每次在 Task 类的调用方法中使用 RestTemplate 和 setRequestFactory 的方式是否有效？由于RestTemplate 创建起来非常繁重，所以不确定我是否做对了。

每次都可以创建HttpComponentsClientHttpRequestFactory 的新实例吗？会贵吗？

如果我们需要设置读取和连接超时，使用RestTemplate 的正确和有效方法是什么。

这个库会这样使用——

String response = DataClientFactory.getInstance().getSyncData(keyData, 100);

Answer 1

据我所知，您重复使用相同的RestTemplate 对象，但每个Task 都在执行此行：restTemplate.setRequestFactory(clientHttpRequestFactory());。这似乎可以有竞争条件，例如一个Task 可以设置另一个Task 会意外使用的RequestFactory。

否则，您似乎正确地使用了RestTemplate。

您的超时多久更改一次？如果您主要使用一两个超时，您可以使用带有预加载超时的RequestFactory 构造函数创建一两个RestTemplates。如果您是效率的坚持者，请创建一个 HashMap<Integer, RestTemplate>，它会在每次请求新的超时时缓存具有特定超时的 RestTemplate。

否则，查看RestTemplate's constructor 和HttpComponentsClientHttpRequestFactory's constructor 的代码，它们看起来并不会特别繁重，因此重复调用它们可能不会成为太大的瓶颈。