引入依赖

  1. <dependency>
  2.     <groupId>org.apache.httpcomponents</groupId>
  3.     <artifactId>httpclient</artifactId>
  4.     <version>4.5.13</version>
  5. </dependency>

参数配置

连接池参数：

配置 简介 默认值
maxConnTotal 最大连接数 20
maxConnPerRoute 分配给同一个route(路由)最大的并发数。
举例来说，我们使用HttpClient的实现来分别请求 www.baidu.com 的资源和 www.bing.com 的资源那么他就会产生两个route		 2
connTimeToLive 连接池中connection的存活时间 永久有效
maxIdleTime 最大空闲时间 如果没有指定maxIdleTime的话，但是有设置evictExpiredConnections的话，默认是10秒

RequestConfig常用参数：

重要参数 默认值 特殊值（0）





超时参数		 socketTimeout 指客户端从服务器读取数据的timeout，超出后会抛出SocketTimeOutException -1，未定义使用默认值 无限超时
connectTimeout 客户端和服务器建立连接的timeout，就是http请求的三个阶段，一：建立连接；二：数据传送；三，断开连接。超时后会ConnectionTimeOutException -1，未定义使用默认值 无限超时
connectionRequestTimeout 从连接池获取连接的timeout。
HttpClient中的要用连接时尝试从连接池中获取，若是在等待了一定的时间后还没有获取到可用连接（比如连接池中没有空闲连接了）则会抛出获取连接超时异常。
 -1，未定义使用默认值 无限超时

高并发下性能优化-http连接池

首先,明确两点:

1.http连接池不是万能的,过多的长连接会占用服务器资源,导致其他服务受阻
2.http连接池只适用于请求是经常访问同一主机(或同一个接口)的情况下
3.并发数不高的情况下资源利用率低下

使用http连接池的优点:

1.复用http连接,省去了tcp的3次握手和4次挥手的时间,极大降低请求响应的时间
2.自动管理tcp连接,不用人为地释放/创建连接

使用http连接池的大致流程 :

1.创建PoolingHttpClientConnectionManager实例
2.给manager设置参数
3.给manager设置重试策略
4.给manager设置连接管理策略
5.开启监控线程,及时关闭被服务器单向断开的连接
6.构建HttpClient实例
7.创建HttpPost/HttpGet实例,并设置参数
8.获取响应,做适当的处理
9.将用完的连接放回连接池

使用方式：

java原生使用方式：

  1. package com.powerX.httpClient;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.io.OutputStream;
  8. import java.net.HttpURLConnection;
  9. import java.net.MalformedURLException;
  10. import java.net.URL;
  12. public class HttpClient {
  13.     public static String doGet(String httpurl) {
  14.         HttpURLConnection connection = null;
  15.         InputStream is = null;
  16.         BufferedReader br = null;
  17.         String result = null;// 返回结果字符串
  18.         try {
  19.             // 创建远程url连接对象
  20.             URL url = new URL(httpurl);
  21.             // 通过远程url连接对象打开一个连接，强转成httpURLConnection类
  22.             connection = (HttpURLConnection) url.openConnection();
  23.             // 设置连接方式：get
  24.             connection.setRequestMethod("GET");
  25.             // 设置连接主机服务器的超时时间：15000毫秒
  26.             connection.setConnectTimeout(15000);
  27.             // 设置读取远程返回的数据时间：60000毫秒
  28.             connection.setReadTimeout(60000);
  29.             // 发送请求
  30.             connection.connect();
  31.             // 通过connection连接，获取输入流
  32.             if (connection.getResponseCode() == 200) {
  33.                 is = connection.getInputStream();
  34.                 // 封装输入流is，并指定字符集
  35.                 br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
  36.                 // 存放数据
  37.                 StringBuffer sbf = new StringBuffer();
  38.                 String temp = null;
  39.                 while ((temp = br.readLine()) != null) {
  40.                     sbf.append(temp);
  41.                     sbf.append("\r\n");
  42.                 }
  43.                 result = sbf.toString();
  44.             }
  45.         } catch (MalformedURLException e) {
  46.             e.printStackTrace();
  47.         } catch (IOException e) {
  48.             e.printStackTrace();
  49.         } finally {
  50.             // 关闭资源
  51.             if (null != br) {
  52.                 try {
  53.                     br.close();
  54.                 } catch (IOException e) {
  55.                     e.printStackTrace();
  56.                 }
  57.             }
  59.             if (null != is) {
  60.                 try {
  61.                     is.close();
  62.                 } catch (IOException e) {
  63.                     e.printStackTrace();
  64.                 }
  65.             }
  67.             connection.disconnect();// 关闭远程连接
  68.         }
  70.         return result;
  71.     }
  73.     public static String doPost(String httpUrl, String param) {
  75.         HttpURLConnection connection = null;
  76.         InputStream is = null;
  77.         OutputStream os = null;
  78.         BufferedReader br = null;
  79.         String result = null;
  80.         try {
  81.             URL url = new URL(httpUrl);
  82.             // 通过远程url连接对象打开连接
  83.             connection = (HttpURLConnection) url.openConnection();
  84.             // 设置连接请求方式
  85.             connection.setRequestMethod("POST");
  86.             // 设置连接主机服务器超时时间：15000毫秒
  87.             connection.setConnectTimeout(15000);
  88.             // 设置读取主机服务器返回数据超时时间：60000毫秒
  89.             connection.setReadTimeout(60000);
  91.             // 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
  92.             connection.setDoOutput(true);
  93.             // 默认值为：true，当前向远程服务读取数据时，设置为true，该参数可有可无
  94.             connection.setDoInput(true);
  95.             // 设置传入参数的格式:请求参数应该是 name1=value1&name2=value2 的形式。
  96.             connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
  97.             // 设置鉴权信息：Authorization: Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0
  98.             connection.setRequestProperty("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
  99.             // 通过连接对象获取一个输出流
  100.             os = connection.getOutputStream();
  101.             // 通过输出流对象将参数写出去/传输出去,它是通过字节数组写出的
  102.             os.write(param.getBytes());
  103.             // 通过连接对象获取一个输入流，向远程读取
  104.             if (connection.getResponseCode() == 200) {
  106.                 is = connection.getInputStream();
  107.                 // 对输入流对象进行包装:charset根据工作项目组的要求来设置
  108.                 br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
  110.                 StringBuffer sbf = new StringBuffer();
  111.                 String temp = null;
  112.                 // 循环遍历一行一行读取数据
  113.                 while ((temp = br.readLine()) != null) {
  114.                     sbf.append(temp);
  115.                     sbf.append("\r\n");
  116.                 }
  117.                 result = sbf.toString();
  118.             }
  119.         } catch (MalformedURLException e) {
  120.             e.printStackTrace();
  121.         } catch (IOException e) {
  122.             e.printStackTrace();
  123.         } finally {
  124.             // 关闭资源
  125.             if (null != br) {
  126.                 try {
  127.                     br.close();
  128.                 } catch (IOException e) {
  129.                     e.printStackTrace();
  130.                 }
  131.             }
  132.             if (null != os) {
  133.                 try {
  134.                     os.close();
  135.                 } catch (IOException e) {
  136.                     e.printStackTrace();
  137.                 }
  138.             }
  139.             if (null != is) {
  140.                 try {
  141.                     is.close();
  142.                 } catch (IOException e) {
  143.                     e.printStackTrace();
  144.                 }
  145.             }
  146.             // 断开与远程地址url的连接
  147.             connection.disconnect();
  148.         }
  149.         return result;
  150.     }
  151. }

apache httpClient4.5使用方式：

  1. package com.powerX.httpClient;
  3. import java.io.IOException;
  4. import java.io.UnsupportedEncodingException;
  5. import java.util.ArrayList;
  6. import java.util.Iterator;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Map.Entry;
  10. import java.util.Set;
  12. import org.apache.http.HttpEntity;
  13. import org.apache.http.NameValuePair;
  14. import org.apache.http.client.ClientProtocolException;
  15. import org.apache.http.client.config.RequestConfig;
  16. import org.apache.http.client.entity.UrlEncodedFormEntity;
  17. import org.apache.http.client.methods.CloseableHttpResponse;
  18. import org.apache.http.client.methods.HttpGet;
  19. import org.apache.http.client.methods.HttpPost;
  20. import org.apache.http.impl.client.CloseableHttpClient;
  21. import org.apache.http.impl.client.HttpClients;
  22. import org.apache.http.message.BasicNameValuePair;
  23. import org.apache.http.util.EntityUtils;
  25. public class HttpClient4 {
  27.     public static String doGet(String url) {
  28.         CloseableHttpClient httpClient = null;
  29.         CloseableHttpResponse response = null;
  30.         String result = "";
  31.         try {
  32.             // 通过址默认配置创建一个httpClient实例
  33.             httpClient = HttpClients.createDefault();
  34.             // 创建httpGet远程连接实例
  35.             HttpGet httpGet = new HttpGet(url);
  36.             // 设置请求头信息，鉴权
  37.             httpGet.setHeader("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
  38.             // 设置配置请求参数
  39.             RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(35000)// 连接主机服务超时时间
  40.                     .setConnectionRequestTimeout(35000)// 请求超时时间
  41.                     .setSocketTimeout(60000)// 数据读取超时时间
  42.                     .build();
  43.             // 为httpGet实例设置配置
  44.             httpGet.setConfig(requestConfig);
  45.             // 执行get请求得到返回对象
  46.             response = httpClient.execute(httpGet);
  47.             // 通过返回对象获取返回数据
  48.             HttpEntity entity = response.getEntity();
  49.             // 通过EntityUtils中的toString方法将结果转换为字符串
  50.             result = EntityUtils.toString(entity);
  51.         } catch (ClientProtocolException e) {
  52.             e.printStackTrace();
  53.         } catch (IOException e) {
  54.             e.printStackTrace();
  55.         } finally {
  56.             // 关闭资源
  57.             if (null != response) {
  58.                 try {
  59.                     response.close();
  60.                 } catch (IOException e) {
  61.                     e.printStackTrace();
  62.                 }
  63.             }
  64.             if (null != httpClient) {
  65.                 try {
  66.                     httpClient.close();
  67.                 } catch (IOException e) {
  68.                     e.printStackTrace();
  69.                 }
  70.             }
  71.         }
  72.         return result;
  73.     }
  75.     public static String doPost(String url, Map<String, Object> paramMap) {
  76.         CloseableHttpClient httpClient = null;
  77.         CloseableHttpResponse httpResponse = null;
  78.         String result = "";
  79.         // 创建httpClient实例
  80.         httpClient = HttpClients.createDefault();
  81.         // 创建httpPost远程连接实例
  82.         HttpPost httpPost = new HttpPost(url);
  83.         // 配置请求参数实例
  84.         RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(35000)// 设置连接主机服务超时时间
  85.                 .setConnectionRequestTimeout(35000)// 设置连接请求超时时间
  86.                 .setSocketTimeout(60000)// 设置读取数据连接超时时间
  87.                 .build();
  88.         // 为httpPost实例设置配置
  89.         httpPost.setConfig(requestConfig);
  90.         // 设置请求头
  91.         httpPost.addHeader("Content-Type", "application/x-www-form-urlencoded");
  92.         // 封装post请求参数
  93.         if (null != paramMap && paramMap.size() > 0) {
  94.             List<NameValuePair> nvps = new ArrayList<NameValuePair>();
  95.             // 通过map集成entrySet方法获取entity
  96.             Set<Entry<String, Object>> entrySet = paramMap.entrySet();
  97.             // 循环遍历，获取迭代器
  98.             Iterator<Entry<String, Object>> iterator = entrySet.iterator();
  99.             while (iterator.hasNext()) {
  100.                 Entry<String, Object> mapEntry = iterator.next();
  101.                 nvps.add(new BasicNameValuePair(mapEntry.getKey(), mapEntry.getValue().toString()));
  102.             }
  104.             // 为httpPost设置封装好的请求参数
  105.             try {
  106.                 httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
  107.             } catch (UnsupportedEncodingException e) {
  108.                 e.printStackTrace();
  109.             }
  110.         }
  111.         try {
  112.             // httpClient对象执行post请求,并返回响应参数对象
  113.             httpResponse = httpClient.execute(httpPost);
  114.             // 从响应对象中获取响应内容
  115.             HttpEntity entity = httpResponse.getEntity();
  116.             result = EntityUtils.toString(entity);
  117.         } catch (ClientProtocolException e) {
  118.             e.printStackTrace();
  119.         } catch (IOException e) {
  120.             e.printStackTrace();
  121.         } finally {
  122.             // 关闭资源
  123.             if (null != httpResponse) {
  124.                 try {
  125.                     httpResponse.close();
  126.                 } catch (IOException e) {
  127.                     e.printStackTrace();
  128.                 }
  129.             }
  130.             if (null != httpClient) {
  131.                 try {
  132.                     httpClient.close();
  133.                 } catch (IOException e) {
  134.                     e.printStackTrace();
  135.                 }
  136.             }
  137.         }
  138.         return result;
  139.     }
  140. }

springboot使用方式：

连接池方式：

统一配置参数、设置默认值：

  2. import lombok.Data;
  3. import lombok.experimental.Accessors;
  4. import org.apache.commons.lang3.ObjectUtils;
  6. import java.io.Serializable;
  8. /**
  9. * @author yaol
  10. */
  11. @Data
  12. @Accessors(chain = true)
  13. public class HttpClientProperties implements Serializable {
  14.   /**
  15.   * 唯一标识， 日志辅助使用
  16.   */
  17.   private String flag;
  18.   /**
  19.   * 代理ip, null 默认不使用代理
  20.   */
  21.   private String httpProxyHost;
  22.   /**
  23.   * 代理端口，null 默认不使用代理
  24.   */
  25.   private Integer httpProxyPort;
  26.   /**
  27.   * 从连接池获取连接的timeout。 / millisecond
  28.   */
  29.   private Integer connectionRequestTimeout;
  30.   /**
  31.   * 客户端和服务器建立连接的timeout / millisecond
  32.   */
  33.   private Integer connectTimeout;
  34.   /**
  35.   * 客户端从服务器读取数据的timeout / millisecond
  36.   */
  37.   private Integer readTimeout;
  38.   /**
  39.   * 最大空闲连接时间 / millisecond
  40.   */
  41.   private Integer maxIdleTime;
  42.   /**
  43.   * 服务最大连接数
  44.   */
  45.   private Integer maxConnTotal;
  46.   /**
  47.   * 分配给同一个route(路由)最大的并发数
  48.   */
  49.   private Integer maxConnPerRoute;
  50.   /**
  51.   * 是否需要启用证书验证
  52.   */
  53.   private Boolean needSslValidation;
  54.   /**
  55.   * ssl签名证书路径
  56.   */
  57.   private String sslCertPath;
  58.   /**
  59.   * ssl签名证书密码
  60.   */
  61.   private String sslCertPassword;
  63.   /**
  64.   * 异常重试次数（null or <0: 不会重实）
  65.   */
  66.   private Integer retryTimes;
  67.   /**
  68.   * 异常重试间隔（null or <=0: 直接重试，不做间隔） / millisecond
  69.   */
  70.   private Integer retryIntervalTime;
  72.   /**
  73.   * 默认值设置
  74.   */
  75.   public void buildDefault() {
  76.     this.connectTimeout = getConnectTimeout();
  77.     this.readTimeout = getReadTimeout();
  78.     this.connectionRequestTimeout = getConnectionRequestTimeout();
  79.     this.maxIdleTime = getMaxIdleTime();
  80.     this.maxConnTotal = getMaxConnTotal();
  81.     this.maxConnPerRoute = getMaxConnPerRoute();
  82.     this.needSslValidation = getNeedSslValidation();
  83.     this.retryTimes = getRetryTimes();
  84.     this.retryIntervalTime = getRetryIntervalTime();
  85.   }
  87.   public Integer getConnectTimeout() {
  88.     return ObjectUtils.defaultIfNull(this.connectTimeout, 10 * 1000);
  89.   }
  91.   public Integer getReadTimeout() {
  92.     return ObjectUtils.defaultIfNull(this.readTimeout, 10 * 1000);
  93.   }
  95.   public Integer getConnectionRequestTimeout() {
  96.     return ObjectUtils.defaultIfNull(this.connectionRequestTimeout, 3 * 1000);
  97.   }
  99.   public Integer getMaxIdleTime() {
  100.     return ObjectUtils.defaultIfNull(this.maxIdleTime, 20 * 1000);
  101.   }
  103.   public Integer getMaxConnTotal() {
  104.     return ObjectUtils.defaultIfNull(this.maxConnTotal, 200);
  105.   }
  107.   public Integer getMaxConnPerRoute() {
  108.     return ObjectUtils.defaultIfNull(this.maxConnPerRoute, 100);
  109.   }
  111.   public Boolean getNeedSslValidation() {
  112.     return ObjectUtils.defaultIfNull(this.needSslValidation, false);
  113.   }
  115.   public Integer getRetryTimes() {
  116.     return ObjectUtils.defaultIfNull(this.retryTimes, 0);
  117.   }
  119.   public Integer getRetryIntervalTime() {
  120.     return ObjectUtils.defaultIfNull(this.retryIntervalTime, 100);
  121.   }
  123. }

ClientHttpRequestFactory工厂类工具类：

  1. import com.alibaba.fastjson.JSON;
  2. import com.pingxx.common.consts.LogConsts;
  3. import com.pingxx.common.encryption.CertUtil;
  4. import com.pingxx.common.enums.LogTypeEnum;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.apache.commons.lang3.StringUtils;
  7. import org.apache.http.HttpHost;
  8. import org.apache.http.conn.ssl.NoopHostnameVerifier;
  9. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
  10. import org.apache.http.impl.client.CloseableHttpClient;
  11. import org.apache.http.impl.client.HttpClientBuilder;
  12. import org.apache.http.impl.client.HttpClients;
  13. import org.apache.http.ssl.SSLContextBuilder;
  14. import org.apache.http.ssl.SSLContexts;
  15. import org.apache.http.ssl.TrustStrategy;
  16. import org.springframework.http.client.ClientHttpRequestFactory;
  17. import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
  19. import javax.net.ssl.SSLContext;
  20. import java.security.GeneralSecurityException;
  21. import java.security.KeyStore;
  22. import java.util.concurrent.TimeUnit;
  24. import static net.logstash.logback.marker.Markers.append;
  26. /**
  27.  * 统一ClientHttpRequestFactory
  28.  * @author yaol
  29.  */
  30. @Slf4j
  31. public class ClientHttpRequestFactoryUtil {
  33.     /**
  34.      * 统一ClientHttpRequestFactory
  35.      * @param httpClientProperties
  36.      * @return
  37.      */
  38.     public static ClientHttpRequestFactory requestFactory(HttpClientProperties httpClientProperties) {
  39.         log.info("{} httpClientProperties: {}", httpClientProperties.getFlag(), JSON.toJSONString(httpClientProperties));
  41.         try {
  42.             HttpClientBuilder httpClientBuilder = HttpClients.custom();
  44.             if (Boolean.TRUE.equals(httpClientProperties.getNeedSslValidation()) &&
  45.                     StringUtils.isNotBlank(httpClientProperties.getSslCertPath())
  46.             ) {
  47.                 //设置证书
  48.                 KeyStore keyStore = CertUtil.getKeyStore(httpClientProperties.getSslCertPath(),
  49.                         httpClientProperties.getSslCertPassword(), CertUtil.KEY_STORE_TYPE_PKCS12);
  50.                 if (keyStore != null) {
  51.                     SSLContextBuilder sslContextBuilder = SSLContexts.custom();
  52.                     try {
  53.                         sslContextBuilder.loadKeyMaterial(keyStore, httpClientProperties.getSslCertPassword().toCharArray())
  54.                                 .loadTrustMaterial(keyStore, (chain, authType) -> true);
  55.                         SSLContext sslContext = sslContextBuilder
  56.                                 .loadTrustMaterial(keyStore, (chain, authType) -> true)
  57.                                 .build();
  58.                         SSLConnectionSocketFactory connectionSocketFactory = new SSLConnectionSocketFactory(
  59.                                 sslContext, NoopHostnameVerifier.INSTANCE);
  60.                         httpClientBuilder.setSSLSocketFactory(connectionSocketFactory);
  61.                     } catch (GeneralSecurityException e) {
  62.                         log.error(append(LogConsts.LOG_TYPE, LogTypeEnum.EXCEPTION),
  63.                                 "init SSLContext error:{}", httpClientProperties.getFlag(), e);
  64.                         throw new RuntimeException("init SSLContext error");
  65.                     }
  66.                 } else {
  67.                     log.error("HttpClient need ssl cert, but keyStore is null:{}", httpClientProperties.getFlag());
  68.                     throw new RuntimeException("HttpClient need ssl cert, but keyStore is null");
  69.                 }
  70.             } else {
  71.                 //证书绕过
  72.                 TrustStrategy acceptingTrustStrategy = (x509Certificates, authType) -> true;
  73.                 SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
  74.                 SSLConnectionSocketFactory connectionSocketFactory = new SSLConnectionSocketFactory(sslContext,
  75.                         new NoopHostnameVerifier());
  76.                 httpClientBuilder.setSSLSocketFactory(connectionSocketFactory);
  77.             }
  79.             //代理
  80.             if (StringUtils.isNotBlank(httpClientProperties.getHttpProxyHost()) && httpClientProperties.getHttpProxyPort() != null) {
  81.                 httpClientBuilder.setProxy(new HttpHost(httpClientProperties.getHttpProxyHost(), httpClientProperties.getHttpProxyPort(), "http"));
  82.             }
  85.             // 只有io异常才会触发重试
  86.             HttpRequestRetryHandler handler = new HttpRequestRetryHandler() {
  87.                 @Override
  88.                 public boolean retryRequest(IOException exception, int curRetryCount, HttpContext context) {
  89.                     // curRetryCount 每一次都会递增，从1开始
  90.                     if (curRetryCount > retryTimes) {
  91.                         return false;
  92.                     }
  93.                     try {
  94.                         //重试延迟
  95.                         if (retryTimes > 0 && retryIntervalTime > 0 ) {
  96.                             Thread.sleep(curRetryCount * retryIntervalTime);
  97.                         }
  98.                     } catch (InterruptedException e) {
  99.                         throw new RuntimeException(e);
  100.                     }
  101.                     //重试场景
  102.                     if (exception instanceof ConnectTimeoutException
  103.                             || exception instanceof NoHttpResponseException
  104.                             || exception instanceof ConnectException
  105. //                            || exception instanceof UnknownHostException
  106.                     ) {
  107.                         return true;
  108.                     }
  110.                     HttpClientContext clientContext = HttpClientContext.adapt(context);
  111.                     org.apache.http.HttpRequest request = clientContext.getRequest();
  112.                     boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
  113.                     if (idempotent) {
  114.                         // 如果请求被认为是幂等的，那么就重试。即重复执行不影响程序其他效果的
  115.                         return true;
  116.                     }
  117.                     return false;
  118.                 }
  119.             };
  120.             //重试handler
  121.             httpClientBuilder.setRetryHandler(handler);
  125.             //最大连接数
  126.             httpClientBuilder.setMaxConnTotal(httpClientProperties.getMaxConnTotal());
  127.             //分配给同一个route(路由)最大的并发数
  128.             httpClientBuilder.setMaxConnPerRoute(httpClientProperties.getMaxConnPerRoute());
  129.             //最大空闲连接时间
  130.             httpClientBuilder.evictExpiredConnections()
  131.                     .evictIdleConnections(httpClientProperties.getMaxIdleTime(), TimeUnit.MILLISECONDS);
  133.             HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
  134.             //从连接池获取连接的timeout。
  135.             requestFactory.setConnectionRequestTimeout(httpClientProperties.getConnectionRequestTimeout());
  136.             //客户端和服务器建立连接的timeout
  137.             requestFactory.setConnectTimeout(httpClientProperties.getConnectTimeout());
  138.             //指客户端从服务器读取数据的timeout
  139.             requestFactory.setReadTimeout(httpClientProperties.getReadTimeout());
  141.             CloseableHttpClient httpClient = httpClientBuilder.build();
  142.             requestFactory.setHttpClient(httpClient);
  144.             return requestFactory;
  145.         } catch (Exception e) {
  146.             log.error("new ClientHttpRequestFactory exception: {}", httpClientProperties.getFlag(), e);
  147.             throw new RuntimeException("new ClientHttpRequestFactory exception", e);
  148.         }
  149.     }
  150. }

获取nacos配置、初始化restTemplate：

  1. import com.pingxx.common.util.http.ClientHttpRequestFactoryUtil;
  2. import com.pingxx.common.util.http.HttpClientProperties;
  3. import lombok.Getter;
  4. import lombok.Setter;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.boot.context.properties.ConfigurationProperties;
  7. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  8. import org.springframework.boot.web.client.RestTemplateBuilder;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.http.client.ClientHttpRequestFactory;
  12. import org.springframework.web.client.RestTemplate;
  14. @Getter
  15. @Setter
  16. @Slf4j
  17. @EnableConfigurationProperties
  18. @Configuration
  19. @ConfigurationProperties(prefix = "http-client")
  20. public class HttpClientConfig {
  22.     private String httpProxyHost;
  24.     private Integer httpProxyPort;
  26.     private Integer connectionRequestTimeout;
  28.     private Integer connectTimeout;
  30.     private Integer readTimeout;
  32.     private Integer maxIdleTime;
  34.     private Integer maxConnTotal;
  36.     private Integer maxConnPerRoute;
  38.     @Bean
  39.     public ClientHttpRequestFactory requestFactory() {
  40.         HttpClientProperties httpClientProperties = new HttpClientProperties()
  41.                 .setHttpProxyHost(httpProxyHost)
  42.                 .setHttpProxyPort(httpProxyPort)
  43.                 .setConnectionRequestTimeout(connectionRequestTimeout)
  44.                 .setConnectTimeout(connectTimeout)
  45.                 .setReadTimeout(readTimeout)
  46.                 .setMaxIdleTime(maxIdleTime)
  47.                 .setMaxConnTotal(maxConnTotal)
  48.                 .setMaxConnPerRoute(maxConnPerRoute)
  49.                 .setFlag("common");
  50.         httpClientProperties.buildDefault();
  51.         return ClientHttpRequestFactoryUtil.requestFactory(httpClientProperties);
  52.     }
  54.     @Bean
  55.     public RestTemplate restTemplate(RestTemplateBuilder builder) {
  56.         return builder
  57.                 .requestFactory(this::requestFactory)
  58.                 .build();
  59.     }
  60. }

发起请求工具类：

  1. package com.example.boothttp.http;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.slf4j.Marker;
  5. import org.springframework.http.*;
  6. import org.springframework.stereotype.Component;
  7. import org.springframework.web.client.RestTemplate;
  9. import static net.logstash.logback.marker.Markers.append;
  11. /**
  12.  * @author yaol
  13.  */
  14. @Slf4j
  15. @Component
  16. public class HttpRequestHelper {
  18.     public HttpResp send(HttpReq reqArgs, RestTemplate restTemplate) {
  19.         String url = reqArgs.getUrl();
  20.         HttpHeaders reqHeaders = reqArgs.getReqHeaders();
  21.         String reqBody = reqArgs.getReqBody();
  23.         if (reqArgs.getReqHeaders() == null) {
  24.             reqHeaders = new HttpHeaders();
  25.         }
  26.         //设置默认请求头
  27.         reqHeaders.setContentType(MediaType.APPLICATION_JSON);
  28.         reqHeaders.add(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE);
  30.         HttpEntity<String> requestEntity = new HttpEntity<>(reqBody, reqHeaders);
  31.         long requestStartAt = System.currentTimeMillis();
  32.         String responseBody = "";
  33.         int statusCode = 0;
  34.         HttpHeaders responseHeaders = null;
  35.         long costMs;
  36.         try {
  37.             ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, requestEntity, String.class);
  38.             statusCode = responseEntity.getStatusCodeValue();
  39.             responseBody = responseEntity.getBody();
  40.             responseHeaders = responseEntity.getHeaders();
  41.         } finally {
  42.             costMs = System.currentTimeMillis() - requestStartAt;
  43.             if (reqBody.length() > 2048) {
  44.                 reqBody = reqBody.substring(0, 2048);
  45.             }
  46.             //todo log_type
  47.             Marker marker = append("log_type", "third")
  48.                     .and(append("cost_ms", costMs))
  49.                     .and(append("request_url", url))
  50.                     .and(append("status_code", statusCode))
  51.                     .and(append("re_body", reqBody))
  52.                     .and(append("resp_body", responseBody))
  53.                     .and(append("req_headers", reqHeaders.toString()))
  54.                     .and(append("reap_headers", responseHeaders != null ? responseHeaders.toString() : null));
  55.             if (statusCode > 0 && statusCode < HttpStatus.BAD_REQUEST.value()) {
  56.                 log.info(marker, "request succeeded");
  57.             } else {
  58.                 log.warn(marker, "request failed");
  59.             }
  60.         }
  61.         return new HttpResp(responseHeaders, responseBody);
  62.     }
  64. }