如何正确使用HttpClient以及restTemplate

importjava.util.concurrent.TimeUnit;

importorg.apache.http.HeaderElement;
importorg.apache.http.HeaderElementIterator;
importorg.apache.http.HttpResponse;
importorg.apache.http.client.HttpClient;
importorg.apache.http.client.config.RequestConfig;
importorg.apache.http.config.Registry;
importorg.apache.http.config.RegistryBuilder;
importorg.apache.http.conn.ConnectionKeepAliveStrategy;
importorg.apache.http.conn.socket.ConnectionSocketFactory;
importorg.apache.http.conn.socket.PlainConnectionSocketFactory;
importorg.apache.http.conn.ssl.SSLConnectionSocketFactory;
importorg.apache.http.impl.client.HttpClients;
importorg.apache.http.impl.conn.PoolingHttpClientConnectionManager;
importorg.apache.http.message.BasicHeaderElementIterator;
importorg.apache.http.protocol.HTTP;
importorg.apache.http.protocol.HttpContext;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.http.client.ClientHttpRequestFactory;
importorg.springframework.http.client.HttpComponentsClientHttpRequestFactory;
importorg.springframework.web.client.RestTemplate;

@Configuration
public classRestTemplateConfig {

    @Autowired
    privateRestTemplateProperties restTemplateProperties;

    @Bean
    publicRestTemplate restTemplate() {
        return newRestTemplate(httpRequestFactory());
    }

    @Bean
    publicClientHttpRequestFactory httpRequestFactory() {
        return newHttpComponentsClientHttpRequestFactory(httpClient());
    }

    //pool监测线程，定期移除过期连接、空闲连接/*public static class IdleConnectionMonitorThread extends Thread {

        private final HttpClientConnectionManager connMgr;

        public IdleConnectionMonitorThread(HttpClientConnectionManager connMgr) {
            super();
            this.connMgr = connMgr;
        }

        @Override
        public void run() {
            try {
                while (true) {
                    synchronized (this) {
                        Thread.sleep(5000);
                        connMgr.closeExpiredConnections();
                        connMgr.closeIdleConnections(5, TimeUnit.SECONDS);
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
*/@Bean
    publicHttpClient httpClient() {
        //支持http和https
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.getSocketFactory())
                .register("https", SSLConnectionSocketFactory.getSocketFactory()).build();
        PoolingHttpClientConnectionManager connectionManager = newPoolingHttpClientConnectionManager(registry);
        connectionManager.setMaxTotal(restTemplateProperties.getMaxTotal());
        connectionManager.setDefaultMaxPerRoute(restTemplateProperties.getDefaultMaxPerRoute());
        connectionManager.setValidateAfterInactivity(restTemplateProperties.getValidateAfterInactivity());

        RequestConfig requestConfig =RequestConfig.custom()
                .setConnectTimeout(restTemplateProperties.getConnectTimeout())
                .setSocketTimeout(restTemplateProperties.getSocketTimeout())
                .setConnectionRequestTimeout(restTemplateProperties.getConnectionRequestTimeout()).build();

        //keep-alive策略
        ConnectionKeepAliveStrategy keepAliveStrategy = newConnectionKeepAliveStrategy() {
            @Override
            public longgetKeepAliveDuration(HttpResponse response, HttpContext context) {
                //如果服务端response返回了Keep-Alive header
                HeaderElementIterator it = newBasicHeaderElementIterator(
                        response.headerIterator(HTTP.CONN_KEEP_ALIVE));
                while(it.hasNext()) {
                    HeaderElement he =it.nextElement();
                    String param =he.getName();
                    String value =he.getValue();
                    if (value != null && param.equalsIgnoreCase("timeout")) {
                        try{
                            return Long.parseLong(value) * 1000;
                        } catch(NumberFormatException ignore) {
                        }
                    }
                }
                //否则设置客户端默认keep-alive超时时间
                returnrestTemplateProperties.getClientDefaultKeepAliveTime();
            }
        };

        /*Thread t = new IdleConnectionMonitorThread(connectionManager);
         t.setName("httpconnections-pool-evict-thread"); 
         t.start();
         */
        returnHttpClients.custom()
                .setDefaultRequestConfig(requestConfig)
                .setConnectionManager(connectionManager)
                .evictExpiredConnections()    //设置后台线程剔除失效连接
.evictIdleConnections(restTemplateProperties.getMaxIdleTime(), TimeUnit.MILLISECONDS)
                .setKeepAliveStrategy(keepAliveStrategy).build();
    }
}

importorg.springframework.boot.context.properties.ConfigurationProperties;
importorg.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix="resttemplate")
public classRestTemplateProperties {
    
    private Integer maxTotal;    //总连接数
    private Integer defaultMaxPerRoute; //单个路由最大连接数
    private Integer connectTimeout;        //与远程服务器建立连接的时间
    private Integer connectionRequestTimeout;    //从connection manager获取连接的超时时间
    private Integer socketTimeout;    //建立连接之后，等待远程服务器返回数据的时间，也就是两个数据包（请求包和响应包）之间不活动的最大时间
    privateInteger validateAfterInactivity;
    private Integer clientDefaultKeepAliveTime; //客户端默认keep-alive时间
    private Integer maxIdleTime;    //连接最大空闲时间
    publicInteger getMaxTotal() {
        returnmaxTotal;
    }
    public voidsetMaxTotal(Integer maxTotal) {
        this.maxTotal =maxTotal;
    }
    publicInteger getDefaultMaxPerRoute() {
        returndefaultMaxPerRoute;
    }
    public voidsetDefaultMaxPerRoute(Integer defaultMaxPerRoute) {
        this.defaultMaxPerRoute =defaultMaxPerRoute;
    }
    publicInteger getConnectTimeout() {
        returnconnectTimeout;
    }
    public voidsetConnectTimeout(Integer connectTimeout) {
        this.connectTimeout =connectTimeout;
    }
    publicInteger getConnectionRequestTimeout() {
        returnconnectionRequestTimeout;
    }
    public voidsetConnectionRequestTimeout(Integer connectionRequestTimeout) {
        this.connectionRequestTimeout =connectionRequestTimeout;
    }
    publicInteger getSocketTimeout() {
        returnsocketTimeout;
    }
    public voidsetSocketTimeout(Integer socketTimeout) {
        this.socketTimeout =socketTimeout;
    }
    publicInteger getValidateAfterInactivity() {
        returnvalidateAfterInactivity;
    }
    public voidsetValidateAfterInactivity(Integer validateAfterInactivity) {
        this.validateAfterInactivity =validateAfterInactivity;
    }
    publicInteger getClientDefaultKeepAliveTime() {
        returnclientDefaultKeepAliveTime;
    }
    public voidsetClientDefaultKeepAliveTime(Integer clientDefaultKeepAliveTime) {
        this.clientDefaultKeepAliveTime =clientDefaultKeepAliveTime;
    }
    publicInteger getMaxIdleTime() {
        returnmaxIdleTime;
    }
    public voidsetMaxIdleTime(Integer maxIdleTime) {
        this.maxIdleTime =maxIdleTime;
    }
    
}

resttemplate.max-total=2000resttemplate.default-max-per-route=1000resttemplate.connect-timeout=5000resttemplate.connection-request-timeout=1000resttemplate.socket-timeout=5000resttemplate.validate-after-inactivity=2000resttemplate.client-default-keep-alive-time=5000resttemplate.max-idle-time=5000