带有连接池的Http客户端工具类HttpClientUtil

一、背景

业务开发中，经常会遇到通过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