HttpClient 高并发工具类

Java工具类

依赖

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.15</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.13</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.13</version>
        </dependency>

HttpClientUtil.java

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
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.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;

import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * 20220518重构，引入单例连接池
 *
 * @author liuenqi
 */
public class HttpClientUtil {
    private static final Log log = LogFactory.getLog(HttpClientUtil.class);
    private static volatile CloseableHttpClient httpClient = null;

    private HttpClientUtil() {
    }

    private static CloseableHttpClient getHttpClient() {
        if (Objects.isNull(httpClient)) {
            synchronized (HttpClientUtil.class) {
                if (Objects.isNull(httpClient)) {
                    PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
                    // 连接池总容量
                    connectionManager.setMaxTotal(100);
                    // 每个host为一组，此参数用于控制每组中连接池的容量 【重要】
                    connectionManager.setDefaultMaxPerRoute(10);

                    RequestConfig requestConfig = RequestConfig.custom()
                            // 从连接池中取连接超时时间
                            .setConnectionRequestTimeout(5000)
                            // 建立链接超时时间
                            .setConnectTimeout(5000)
                            // 等待读取数据时间
                            .setSocketTimeout(20000).build();

                    httpClient = HttpClientBuilder.create()
                            // 关闭自动重试
                            .disableAutomaticRetries()
                            // 设置连接池
                            .setConnectionManager(connectionManager)
                            // setConnectionTimeToLive(2, TimeUnit.MINUTES) 设置链接最大存活时间 此选项无效
                            // 设置连接自动回收时间
                            .evictIdleConnections(1, TimeUnit.MINUTES)
                            // 设置超时时间
                            .setDefaultRequestConfig(requestConfig).build();
                }
            }
        }
        return httpClient;
    }

    /**
     * 不带header参数的JSON格式Post请求
     *
     * @param url          请求URL
     * @param bodyJsonData body参数
     * @return 响应体
     */
    public static String httpPost(String url, Map<String, Object> bodyJsonData) {
        String result = null;

        HttpPost httpPost = new HttpPost(url);
        httpPost.addHeader("Content-Type", MediaType.APPLICATION_JSON_VALUE);

        // 组装body
        if (MapUtils.isNotEmpty(bodyJsonData)) {
            StringEntity stringEntity = new StringEntity(JSONObject.toJSONString(bodyJsonData), StandardCharsets.UTF_8);
            stringEntity.setContentType(MediaType.APPLICATION_JSON_VALUE);
            stringEntity.setContentEncoding(StandardCharsets.UTF_8.name());
            httpPost.setEntity(stringEntity);
        }

        // 不要关闭client，会导致连接池被关闭
        CloseableHttpClient client = getHttpClient();

        // 自动释放response
        try (CloseableHttpResponse response = client.execute(httpPost)) {
            HttpEntity entity = response.getEntity();
            result = EntityUtils.toString(entity, StandardCharsets.UTF_8.name());

            // 状态值判断 非2xx抛出异常
            int status = response.getStatusLine().getStatusCode();
            if (status < HttpStatus.OK.value() || status >= HttpStatus.MULTIPLE_CHOICES.value()) {
                throw new RuntimeException(httpPost.getURI() + " 状态异常: " + status + ",响应: " + result);
            }

            EntityUtils.consume(entity);
        } catch (Exception e) {
            log.error("HttpClientUtil httpPost ERROR: " + e.getMessage(), e);
        } finally {
            // 记得释放连接
            httpPost.releaseConnection();
        }

        return result;
    }

    /**
     * Get请求
     *
     * @param url 请求URL
     * @return 响应体
     */
    public static String httpGet(String url) {
        return httpGet(url, null, null);
    }

    /**
     * 携带url参数的Get请求
     *
     * @param url      请求URL
     * @param urlParam url参数
     * @return 响应体
     */
    public static String httpGet(String url, Map<String, String> urlParam) {
        return httpGet(url, null, urlParam);
    }

    /**
     * 携带header参数与url参数的Get请求
     *
     * @param url         请求URL
     * @param headerParam header参数
     * @param urlParam    url参数
     * @return 响应体
     */
    public static String httpGet(String url, Map<String, String> headerParam, Map<String, String> urlParam) {
        String result = null;

        HttpGet httpGet = new HttpGet();
        try {
            // 拼装header参数
            if (MapUtils.isNotEmpty(headerParam)) {
                for (String key : headerParam.keySet()) {
                    httpGet.addHeader(key, headerParam.get(key));
                }
            }

            // 拼装url参数
            URIBuilder uriBuilder = new URIBuilder(url);
            if (MapUtils.isNotEmpty(urlParam)) {
                for (String key : urlParam.keySet()) {
                    uriBuilder.addParameter(key, urlParam.get(key));
                }
            }

            httpGet.setURI(uriBuilder.build());

            // 不要关闭client，会导致连接池被关闭
            CloseableHttpClient client = getHttpClient();
            CloseableHttpResponse response = client.execute(httpGet);

            HttpEntity entity = response.getEntity();
            result = EntityUtils.toString(entity, StandardCharsets.UTF_8.name());

            // 状态值判断 非2xx抛出异常
            int status = response.getStatusLine().getStatusCode();
            if (status < HttpStatus.OK.value() || status >= HttpStatus.MULTIPLE_CHOICES.value()) {
                throw new RuntimeException(httpGet.getURI() + " 状态异常: " + status + ",响应: " + result);
            }

            EntityUtils.consume(entity);
        } catch (Exception e) {
            log.error("HttpClientUtil doGet ERROR: " + e.getMessage(), e);
        } finally {
            // 记得释放连接
            httpGet.releaseConnection();
        }

        return result;
    }
}

如果需要支持https

Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.getSocketFactory())
                .register("https", sslConnectionSocketFactory())
                .build();
PoolingHttpClientConnectionManager httpClientConnectionManager = new PoolingHttpClientConnectionManager(registry);
//最大连接数
httpClientConnectionManager.setMaxTotal(100);
//并发数
httpClientConnectionManager.setDefaultMaxPerRoute(10);


/**
 * 支持SSL 
 */
private SSLConnectionSocketFactory sslConnectionSocketFactory() {
        try {
            return new SSLConnectionSocketFactory(
                    SSLContexts.custom().loadTrustMaterial(null, new TrustSelfSignedStrategy()).build(),
                    NoopHostnameVerifier.INSTANCE);
        } catch (Exception e) {
            return SSLConnectionSocketFactory.getSocketFactory();
        }
 }

如果需要修改请求重试

                    httpClient = HttpClientBuilder.create()
                            // 关闭自动重试
                            // .disableAutomaticRetries()
                             // 自定义自动重试
                            .setRetryHandler(httpRequestRetryHandler())
                            // 设置连接池
                            .setConnectionManager(connectionManager)
                            // setConnectionTimeToLive(2, TimeUnit.MINUTES) 设置链接最大存活时间 此选项无效
                            // 设置连接自动回收时间
                            .evictIdleConnections(1, TimeUnit.MINUTES)
                            // 设置超时时间
                            .setDefaultRequestConfig(requestConfig).build();
                            
 /**
     * 自动重试
     */
    private HttpRequestRetryHandler httpRequestRetryHandler() {
        return (exception, executionCount, context) -> {
            if (executionCount >= 5) {// 如果已经重试了5次，就放弃
                return false;
            }
            if (exception instanceof NoHttpResponseException) {// 如果服务器丢掉了连接，那么就重试
                return true;
            }
            if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常
                return false;
            }
            if (exception instanceof InterruptedIOException) {// 超时
                return false;
            }
            if (exception instanceof UnknownHostException) {// 目标服务器不可达
                return false;
            }
            if (exception instanceof SSLException) {// SSL握手异常
                return false;
            }

            HttpClientContext clientContext = HttpClientContext
                    .adapt(context);
            HttpRequest request = clientContext.getRequest();
            // 如果请求是幂等的，就再次尝试
            return !(request instanceof HttpEntityEnclosingRequest);
        };
    }

更多请求方法

 /**
     * 不带参数的get请求，如果状态码为200，则返回body，如果不为200，则返回null
     *
     * @param url
     */
    public String doGet(String url) {
        log.info("httpGet_url==>{}", url);
        // 声明 http get 请求
        HttpGet httpGet = new HttpGet(url);
        // 装载配置信息
        httpGet.setConfig(this.config);
        // 发起请求
        try {
            CloseableHttpResponse response = this.httpClient.execute(httpGet);
            // 判断状态码是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                // 返回响应体的内容
                String result = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.info("httpGet_result==>{}", result);
                return result;
            }
        } catch (Exception e) {
            log.error("httpGet_error==>", e);
            return null;
        } finally {
            //httpGet.releaseConnection();
        }
        return null;
    }

    /**
     * 带参数的get请求，如果状态码为200，则返回body，如果不为200，则返回null
     *
     * @param url
     */
    public String doGet(String url, Map<String, Object> map) {
        URIBuilder uriBuilder = null;
        try {
            uriBuilder = new URIBuilder(url);
            if (map != null) {
                // 遍历map,拼接请求参数
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    uriBuilder.setParameter(entry.getKey(), entry.getValue().toString());
                }
            }
            return doGet(uriBuilder.build().toString());
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 不带参数post请求
     *
     * @param url
     * @return string json串
     * @throws Exception
     */
    public  String doPost(String url) throws Exception {
        return doPost(url , null,null );
    }

    public  String doPost(String url, Map<String, Object> map) throws Exception {
        return doPost(url , map,null );
    }
    /**
     * 带map参数的post请求
     *
     * @param url
     * @param map
     * @return string json串
     * @throws Exception
     */
    public String doPost(String url, Map<String, Object> map,Map<String, String> headers) throws Exception {
        log.info("httpPost_url==>{},params==>{}",url,map);
        // 声明httpPost请求
        HttpPost httpPost = new HttpPost(url);
        // 加入配置信息
        httpPost.setConfig( this.config );
        if ( headers != null ){
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpPost.setHeader(entry.getKey(),entry.getValue());
            }
        }
        // 判断map是否为空，不为空则进行遍历，封装from表单对象
        if (map != null) {
            List<NameValuePair> list = new ArrayList<>();
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                list.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
            }
            // 构造from表单对象
            UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(list, "UTF-8");

            // 把表单放到post里
            httpPost.setEntity(urlEncodedFormEntity);
        }

        // 发起请求
        try(CloseableHttpResponse response = this.httpClient.execute(httpPost)) {
            if (response.getStatusLine().getStatusCode() == 200) {
                // 返回响应体的内容
                String result = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.info("httpPost_result==>{}",result);
                return result;
            }
        }finally {
            //httpPost.releaseConnection();
        }
        return null;
    }
    /**
     * 带json参数的post请求，用的最多，因为map可以转为json
     *
     * @param url  请求地址host+path
     * @param json json字符串
     * @return string json串
     */
    public String doPost(String url, String json) {
        log.info("httpPost_url==>{},json==>{}",url,json);
        //设置请求路径，请求格式，配置信息
        HttpPost httpPost = new HttpPost(url);
        httpPost.setHeader("Content-Type", "application/json;charset=UTF-8");
        httpPost.setConfig(this.config);
        // 发起请求
        try {
            //格式化请求数据并设值
            StringEntity se = new StringEntity(json, "UTF-8");
            se.setContentType("text/json");
            httpPost.setEntity(se);
            CloseableHttpResponse response = this.httpClient.execute(httpPost);
            // 判断状态码是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                // 返回响应体的内容
                String result = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.info("httpPost_result==>{}", result);
                return result;
            }
        } catch (Exception e) {
            log.error("httpPost_error==>", e);
            return null;
        }finally {
            //httpPost.releaseConnection();
        }
        return null;
    }

如果觉得文章对你有用，请随意赞赏

HttpClient 高并发工具类

https://xcmrfc.fun/archives/httpclient-gao-bing-fa-gong-ju-lei

作者

心尘

发布于

2022-09-30

更新于

2022-09-30

许可协议

CC BY 4.0