带有连接池的Http客户端工具类HttpClientUtil
2024-08-28 22:28:19
一、背景
业务开发中，经常会遇到通过http/https向下游服务发送请求。每次都要重复造轮子写HttpClient的逻辑，而且性能、功能参差不齐。这里分享一个高性能的、带连接池的通用Http客户端工具。
请尊重作者劳动成果，转载请标明原文链接：https://www.cnblogs.com/waterystone/p/11551280.html
二、特点
- 基于apache的高性能Http客户端org.apache.http.client.HttpClient；
- 连接池的最大连接数默认是20，可通过系统变量-Dadu.common.http.max.total=200指定；
- 连接池的每个路由的最大连接数默认是2，可通过系统变量-Dadu.common.http.max.per.route=10指定；
- 可设置超时，通过HttpOptions进行设置；
- 可重试，通过HttpOptions进行设置。
三、源码
参考：https://github.com/waterystone/adu-test/blob/master/src/main/java/com/adu/utils/HttpClientUtil.java
package com.adu.utils; import com.adu.Constants;
import com.adu.handler.HttpRequestRetryHandler;
import com.adu.model.HttpOptions;
import com.adu.model.HttpRequest;
import com.adu.model.HttpResponse;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.ContentBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import javax.net.ssl.SSLContext;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors; /**
* 带有连接池的Http客户端工具类。具有如下特点：
* <ol>
* <li>基于apache的高性能Http客户端{@link org.apache.http.client.HttpClient}；</li>
* <li>连接池的最大连接数默认是20，可通过{@link #init(int, int)}、或者系统变量-Dzzarch.common.http.max.total=200指定；</li>
* <li>连接池的每个路由的最大连接数默认是2，可通过{@link #init(int, int)}、或者系统变量-Dzzarch.common.http.max.per.route=10指定；</li>
* <li>可设置超时，通过{@link HttpOptions}进行设置；</li>
* <li>可重试，通过{@link HttpOptions}进行设置；</li>
* </ol>
*
* @author duyunjie
* @date 2019-09-18 16:33
*/
public class HttpClientUtil {
private static final Logger logger = LoggerFactory.getLogger(HttpClientUtil.class); /**
* HttpClient 连接池
*/
private static PoolingHttpClientConnectionManager CONNECTION_MANAGER = buildPoolingHttpClientConnectionManager(null, null); /**
* @param maxTotal 连接池的最大连接数,默认为20。
* @param maxPerRoute 连接池的每个路由的最大连接数，默认为2。
*/
public static void init(int maxTotal, int maxPerRoute) {
CONNECTION_MANAGER = buildPoolingHttpClientConnectionManager(maxTotal, maxPerRoute);
} public static HttpResponse httpGet(HttpRequest httpRequest) throws Exception {
return httpGet(httpRequest, null);
} /**
* 发送 HTTP GET请求
*
* @param httpRequest 请求参数，如url，header等。
* @param httpOptions 配置参数，如重试次数、超时时间等。
* @return
* @throws Exception
*/
public static HttpResponse httpGet(HttpRequest httpRequest, HttpOptions httpOptions) throws Exception {
// 装载请求地址和参数
URIBuilder ub = new URIBuilder(httpRequest.getUrl()); // 转换请求参数
List<NameValuePair> pairs = convertParams2NVPS(httpRequest.getParams());
if (!pairs.isEmpty()) {
ub.setParameters(pairs);
}
HttpGet httpGet = new HttpGet(ub.build()); // 设置请求头
if (Objects.nonNull(httpRequest.getHeaders())) {
for (Map.Entry<String, String> header : httpRequest.getHeaders().entrySet()) {
httpGet.addHeader(header.getKey(), String.valueOf(header.getValue()));
}
} return doHttp(httpGet, httpOptions);
} public static HttpResponse httpPost(HttpRequest httpRequest) throws Exception {
return httpPost(httpRequest, null);
} /**
* 发送 HTTP POST请求
*
* @param httpRequest 请求参数
* @param httpOptions 配置参数
* @return
* @throws Exception
*/
public static HttpResponse httpPost(HttpRequest httpRequest, HttpOptions httpOptions) throws Exception {
HttpPost httpPost = new HttpPost(httpRequest.getUrl()); // 转换请求参数
List<NameValuePair> pairs = convertParams2NVPS(httpRequest.getParams());
if (!pairs.isEmpty()) {
httpPost.setEntity(new UrlEncodedFormEntity(pairs, StandardCharsets.UTF_8.name()));
} // 设置请求头
if (Objects.nonNull(httpRequest.getHeaders())) {
for (Map.Entry<String, String> header : httpRequest.getHeaders().entrySet()) {
httpPost.addHeader(header.getKey(), String.valueOf(header.getValue()));
}
} return doHttp(httpPost, httpOptions);
} /**
* 发送 HTTP POST请求，参数格式JSON
* <p>请求参数是JSON格式，数据编码是UTF-8</p>
*
* @param url
* @param param
* @return
* @throws Exception
*/
public static HttpResponse httpPostJson(String url, String param, HttpOptions httpOptions) throws Exception {
HttpPost httpPost = new HttpPost(url); // 设置请求头
httpPost.addHeader("Content-Type", "application/json; charset=UTF-8"); // 设置请求参数
httpPost.setEntity(new StringEntity(param, StandardCharsets.UTF_8.name())); return doHttp(httpPost, httpOptions);
} /**
* 发送 HTTP POST请求，参数格式XML
* <p>请求参数是XML格式，数据编码是UTF-8</p>
*
* @param url
* @param param
* @return
* @throws Exception
*/
public static HttpResponse httpPostXml(String url, String param, HttpOptions httpOptions) throws Exception {
HttpPost httpPost = new HttpPost(url); // 设置请求头
httpPost.addHeader("Content-Type", "application/xml; charset=UTF-8"); // 设置请求参数
httpPost.setEntity(new StringEntity(param, StandardCharsets.UTF_8.name())); return doHttp(httpPost, httpOptions);
} /**
* 通过post发送multipart信息。
*
* @param url
* @param multiparts
* @param httpOptions
* @return
* @throws Exception
*/
public static HttpResponse httpPostMultipart(String url, Map<String, ContentBody> multiparts, HttpOptions httpOptions) throws Exception {
HttpPost httpPost = new HttpPost(url); // 设置Multipart
if (Objects.nonNull(multiparts)) {
MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
for (Map.Entry<String, ContentBody> multipartEntry : multiparts.entrySet()) {
multipartEntityBuilder.addPart(multipartEntry.getKey(), multipartEntry.getValue());
} httpPost.setEntity(multipartEntityBuilder.build());
} return doHttp(httpPost, httpOptions);
} /**
* 转换请求参数，将Map键值对拼接成QueryString字符串
*
* @param params
* @return
*/
public static String convertParams2QueryStr(Map<String, ?> params) {
List<NameValuePair> pairs = convertParams2NVPS(params); return URLEncodedUtils.format(pairs, StandardCharsets.UTF_8.name());
} /**
* 转换请求参数
*
* @param params
* @return
*/
public static List<NameValuePair> convertParams2NVPS(Map<String, ?> params) {
if (Objects.isNull(params)) {
return new ArrayList<>();
} return params.entrySet().stream().map(param -> new BasicNameValuePair(param.getKey(), String.valueOf(param.getValue()))).collect(Collectors.toList());
} /**
* 发送 HTTP 请求
*
* @param request
* @return
* @throws Exception
*/
private static HttpResponse doHttp(HttpRequestBase request, HttpOptions httpOptions) throws Exception {
if (Objects.isNull(httpOptions)) {//如果为空，则用默认的。
httpOptions = HttpOptions.DEFAULT_HTTP_OPTION;
}
// 设置超时时间
if (Objects.nonNull(httpOptions.getTimeoutMs())) {
request.setConfig(RequestConfig.custom().setSocketTimeout(httpOptions.getTimeoutMs()).build());
} //设置重试策略
HttpRequestRetryHandler httpRequestRetryHandler = null;
if (Objects.nonNull(httpOptions.getRetryCount())) {
httpRequestRetryHandler = new HttpRequestRetryHandler(httpOptions.getRetryCount());
} // 通过连接池获取连接对象
CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(CONNECTION_MANAGER).setRetryHandler(httpRequestRetryHandler).build();
return doRequest(httpClient, request); } /**
* 处理Http/Https请求，并返回请求结果
* <p>注：默认请求编码方式 UTF-8</p>
*
* @param httpClient
* @param request
* @return
* @throws Exception
*/
private static HttpResponse doRequest(CloseableHttpClient httpClient, HttpRequestBase request) throws Exception {
HttpResponse res = new HttpResponse();
CloseableHttpResponse response = null;
long start = System.currentTimeMillis(); try {
// 获取请求结果
response = httpClient.execute(request); // 解析请求结果
HttpEntity entity = response.getEntity();
String result = EntityUtils.toString(entity, StandardCharsets.UTF_8.name()); // 转换结果
EntityUtils.consume(entity); // 关闭IO流 //解析返回header
Map<String, String> headers = new HashMap<>(response.getAllHeaders().length);
for (Header header : response.getAllHeaders()) {
headers.put(header.getName(), header.getValue());
} res.setStatusCode(response.getStatusLine().getStatusCode()).setResult(result).setHeaders(headers);
} finally {
if (Objects.nonNull(response)) {
response.close();
}
} long elapsed = System.currentTimeMillis() - start;
logger.debug("op=end_doRequest,request={},res={},elapsed={}", request, res, elapsed);
return res;
} /**
* 初始化连接池
*
* @return
*/
private static PoolingHttpClientConnectionManager buildPoolingHttpClientConnectionManager(Integer maxTotal, Integer maxPerRoute) {
// 初始化连接池，可用于请求HTTP/HTTPS（信任所有证书）
PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(getRegistry()); // 整个连接池的最大连接数
String maxTotalProperty = null;
if (Objects.nonNull(maxTotal)) { //首先看有没有在参数中显式指定
connectionManager.setMaxTotal(maxTotal);
} else { //如果没有在参数中显式指定，则再看有没有在系统变量中指定
maxTotalProperty = System.getProperty(Constants.SYSTEM_PROPERTY_KEY_HTTP_MAX_TOTAL);
if (Objects.nonNull(maxTotalProperty)) {
connectionManager.setMaxTotal(Integer.valueOf(maxTotalProperty));
}
} // 每个路由的最大连接数
String maxPerRouteProperty = null;
if (Objects.nonNull(maxPerRoute)) { //首先看有没有在参数中显式指定
connectionManager.setDefaultMaxPerRoute(maxPerRoute);
} else { //如果没有在参数中显式指定，则再看有没有在系统变量中指定
maxPerRouteProperty = System.getProperty(Constants.SYSTEM_PROPERTY_KEY_HTTP_MAX_PER_ROUTE);
if (Objects.nonNull(maxPerRouteProperty)) {
connectionManager.setDefaultMaxPerRoute(Integer.valueOf(maxPerRouteProperty));
}
} logger.info("[ZZARCH_COMMON_SUCCESS_buildPoolingHttpClientConnectionManager]maxTotal={},maxPerRoute={},maxTotalProperty={},maxPerRouteProperty={}", maxTotal, maxPerRoute, maxTotalProperty, maxPerRouteProperty);
return connectionManager;
} /**
* 获取 HTTPClient注册器
*
* @return
* @throws Exception
*/
private static Registry<ConnectionSocketFactory> getRegistry() {
try {
return RegistryBuilder.<ConnectionSocketFactory>create().register("http", new PlainConnectionSocketFactory()).register("https", new SSLConnectionSocketFactory(SSLContext.getDefault())).build();
} catch (Exception e) {
logger.error("[ERROR_getRegistry]", e);
} return null;
}
}
end
最新文章
- Dynamics AX 2012 的工业物联网解决方案
- mysql用户名密码忘记了解决方法
- Eclipse 最全快捷键
- 转 父表字表统计查询的sql练习
- 洛谷P1262 间谍网络
- android 纯c/c++开发（转）
- Linux date命令 - 显示和设置系统日期与时间
- PHP - PDO 之 mysql 事务功能
- web前端开发浏览器兼容性 - 持续更新
- OTP语音芯片和掩模语音芯片（mask）的区别
- java下io文件切割合并功能
- B - Numbers That Count
- ORA-20000: ORU-10027: buffer overflow, limit of 10000 bytes
- C51编译器扩展的关键词 & C51中断函数的写法
- java source map
- bzoj 4710: [Jsoi2011]分特产
- 【XSY3320】string AC自动机 哈希 点分治
- Windows下Maven3.3.9安装与配置
- ASP.NET WebApi 基于OAuth2.0实现Token签名认证
- effective c++ 笔记 (26-29)