如何在多线程环境中有效使用RestTemplate？

Question

我正在开发一个项目，在该项目中，我需要对正在运行的服务器进行HTTP URL调用，该服务器Restful Service将响应作为JSON字符串返回。

下面是我的主要代码，它使用future和callables-

public class TimeoutThreadExample {

    private ExecutorService executor = Executors.newFixedThreadPool(10);

    public String getData() {
        Future<String> future = executor.submit(new Task());
        String response = null;

        try {
            response = future.get(100, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        return response;
    }
}

下面是我的Task类，它实现Callable接口并使用RestTemplate…

class Task implements Callable<String> {

    private RestTemplate restTemplate = new RestTemplate();

    public String call() throws Exception {

        String url = "some_url";
        String response = restTemplate.getForObject(url, String.class);

        return response;
    }
}

现在我有下面的代码在另一大类DemoTest它调用的getData方法TimeoutThreadExample类5000 times顺序-

public class DemoTest { 
   public static void main(String[] args) {

        TimeoutThreadExample bc = new TimeoutThreadExample();

        for (int i = 0; i <= 5000; i++) {
        //  TimerTest timer = TimerTest.getInstance(); // line 1
            bc.getData();
        //  timer.getDuration(); // line 2
        }
    }
}

所以我的问题是RestTemplate在这里应该是静态的，Task class就像我正确看到的一样，我正在为每个请求重新创建整个连接池，RestTemplate而我猜这不是正确的方法。

注意：
如果我将RestTemplate设为静态，则RestTemplate在注释掉DemoTest衡量性能的类中的line1和line2之后，与非静态相比，我看到的端到端性能更好。

通常，RestTemplate在多线程环境中使用正确的方法是什么？目前，我要依次调用getData方法5000次，但是有些客户会以多线程方式调用它，因此需要知道在多线程环境中使用RestTemplate的最佳方法是什么。

可能是在RestTemplate构造函数中使用ConnectionFactory吗？有什么想法吗？

更新：-

public class TimeoutThreadExample {

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

    public String getData() {
        Future<String> future = executor.submit(new Task(restTemplate));
        String response = null;

        try {
            response = future.get(100, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        return response;
    }
}

而我的下面TaskClass-

class Task implements Callable<String> {

    private RestTemplate restTemplate;

    public Task(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public String call() throws Exception {

        String url = "some_url";
        String response = restTemplate.getForObject(url, String.class);

        return response;
    }
}

Answer 1

如果我不明白您的问题，请纠正我。它似乎与这里的前一个非常相似。

在那里，我们确定这RestTemplate是线程安全的。因此，没有理由不在有意义的地方共享它。无论您在哪里以相同的方式使用它。您的示例似乎是执行此操作的理想场所。

如您所述，RestTemplate为每个Task实例重新创建一个新实例是浪费的。

我将创建RestTemplatein TimeoutThreadExample并将其Task作为构造函数参数传递给the 。

class Task implements Callable<String> {

    private RestTemplate restTemplate;

    public Task(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public String call() throws Exception {

        String url = "some_url";
        String response = restTemplate.getForObject(url, String.class);

        return response;
    }
}

这样，您可以RestTemplate在所有Task对象之间共享实例。

注意，RestTemplate用于SimpleClientHttpRequestFactory创建其连接。