HttpClient的连接池

最新推荐文章于 2025-06-20 21:47:03 发布
最新推荐文章于 2025-06-20 21:47:03 发布
阅读量2k 收藏 4
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： http协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/MyHerux/article/details/52218438
HttpClient因易用性和灵活性优于URLConnection，尤其适合接口测试。本文讨论为何使用Http连接池，如降低延迟、支持更大并发，并提及HttpClient4.3后推荐使用连接池，介绍相关参考资料。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

写在前面

HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性，它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。

一、为什么要用Http连接池

1、降低延迟：如果不采用连接池，每次连接发起Http请求的时候都会重新建立TCP连接(经历3次握手)，用完就会关闭连接(4次挥手)。

2、支持更大的并发：如果不采用连接池，每次连接都会打开一个端口，在大并发的情况下系统的端口资源很快就会被用完，导致无法建立新的连接。

二、具体实现

httpclient4.3之后就推荐使用连接池的方式了。

package com.icekredit.credit.common.utils;

import net.sf.json.JSONObject;
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.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
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.ssl.SSLContextBuilder;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Class 提高并发数，减少握手次数，httpclient的连接池
 *
 * @author hua xu
 * @version 1.0.0
 * @date 16/08/15
 */
public class HttpUtils {
    private static String NULL_URL = "url is null!";
    private static String ERROR_TYPE = "method is not support!";

    // 类初始化时，自动实例化，饿汉单例模式
    private static final HttpUtils httpUtils = new HttpUtils();

    // 创建httpclient连接池
    private PoolingHttpClientConnectionManager httpClientConnectionManager = null;

    // 单例的静态方法，返回HttpUtils的实例
    public static HttpUtils getHttpUtils() {
        return httpUtils;
    }

    // 私有的构造函数
    private HttpUtils() {
        initHttpClient();
    }

    /**
     * 发送请求
     *
     * @param method     请求方法
     * @param urlString  url
     * @param jsonObject json
     * @return
     * @throws URISyntaxException
     */
    public static String httpRequest(String method, String urlString, JSONObject jsonObject) throws
            URISyntaxException, MalformedURLException {
        if (StringUtils.isEmpty(urlString)) {
            return NULL_URL;
        } else {
            urlString = urlString.trim();
            URL url = new URL(urlString);
            URI uri = new URI(url.getProtocol(), url.getHost(), url.getPath(), url.getQuery(), null);

            CloseableHttpClient httpClient = null;
            if (urlString.startsWith("https")) {
                httpClient = getSSLHttpClient();
            } else {
                httpClient = httpUtils.getHttpClient();
            }
            CloseableHttpResponse response = null;
            String json = null;

            switch (method) {
                case "GET": {
                    HttpGet http = new HttpGet(uri);
                    try {
                        response = httpClient.execute(http);
                        HttpEntity entity = response.getEntity();
                        json = EntityUtils.toString(entity, "utf-8");
                        EntityUtils.consume(entity);
                        return json;
                    } catch (UnsupportedOperationException | IOException e) {
                        e.printStackTrace();
                    } finally {
                        if (response != null) {
                            try {
                                response.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        http.releaseConnection();
                    }
                }
                case "POST": {
                    HttpPost http = new HttpPost(uri);
                    try {
                        StringEntity entity = new StringEntity(jsonObject.toString(), "utf-8");    // 解决中文乱码问题

                        entity.setContentEncoding("UTF-8");
                        entity.setContentType("application/json");
                        http.setEntity(entity);
                        response = httpClient.execute(http);

                        HttpEntity httpEntity = response.getEntity();
                        json = EntityUtils.toString(httpEntity, "utf-8");
                        EntityUtils.consume(entity);
                        return json;
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        if (response != null) {
                            try {
                                response.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        http.releaseConnection();
                    }
                }
                default:
                    return ERROR_TYPE;
            }
        }
    }

    /**
     * 发送请求
     *
     * @param urlString url
     * @param params    发送map
     * @return
     * @throws MalformedURLException
     * @throws URISyntaxException
     */
    public static String httpRequest(String urlString, Map<String, Object> params) throws MalformedURLException,
            URISyntaxException {
        if (StringUtils.isEmpty(urlString)) {
            return NULL_URL;
        } else {
            urlString = urlString.trim();
            URL url = new URL(urlString);
            URI uri = new URI(url.getProtocol(), url.getHost(), url.getPath(), url.getQuery(), null);

            CloseableHttpClient httpClient = null;
            if (urlString.startsWith("https")) {
                httpClient = getSSLHttpClient();
            } else {
                httpClient = httpUtils.getHttpClient();
            }
            CloseableHttpResponse response = null;
            String json = null;

            HttpPost http = new HttpPost(uri);

            try {
                setPostParams(http, params);
                response = httpClient.execute(http);
                HttpEntity httpEntity = response.getEntity();
                json = EntityUtils.toString(httpEntity, "utf-8");
                EntityUtils.consume(httpEntity);
                return json;
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (response != null) {
                    try {
                        response.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                http.releaseConnection();
            }
            return json;
        }
    }

    private static void setPostParams(HttpPost httpost, Map<String, Object> params) {
        List<NameValuePair> nvps = new ArrayList<NameValuePair>();
        Set<String> keySet = params.keySet();
        for (String key : keySet) {
            nvps.add(new BasicNameValuePair(key, params.get(key).toString()));
        }
        try {
            httpost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建httpclient连接池，并初始化httpclient
     */
    public void initHttpClient() {
        LayeredConnectionSocketFactory ssl_sf = null;

        try {
            ssl_sf = new SSLConnectionSocketFactory(SSLContext.getDefault());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }

        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("https", ssl_sf)
                .register("http",
                        new PlainConnectionSocketFactory())
                .build();

        // 创建httpclient连接池
        httpClientConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);

        // 设置连接池最大数量
        httpClientConnectionManager.setMaxTotal(200);

        // 设置单个路由最大连接数量
        httpClientConnectionManager.setDefaultMaxPerRoute(20);
    }

    /**
     * 多线程调用时，需要创建自己的httpclient
     *
     * @return
     */
    public CloseableHttpClient getHttpClient() {
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(60000)
                .setSocketTimeout(60000).build();

        CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(httpClientConnectionManager)
                .setDefaultRequestConfig(requestConfig).build();

        /* CloseableHttpClient httpClient = HttpClients.createDefault();//如果不采用连接池就是这种方式获取连接 */
        return httpClient;
    }

    /**
     * 针对https采用SSL的方式创建httpclient
     *
     * @return
     */
    public static CloseableHttpClient getSSLHttpClient() {
        try {
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                //信任所有
                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    return true;
                }
            }).build();

            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);

            return HttpClients.custom().setSSLSocketFactory(sslsf).build();

        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        }

        return HttpClients.createDefault();
    }
}


//~ Formatted by Jindent --- http://www.jindent.com

参考链接
HttpClient4.5.2 连接池原理及注意事项
HttpClient使用详解
HttpClient4.3教程 第二章 连接管理
Http请求连接池 - HttpClient 连接池

十二、连接池线程池配置——HttpClient连接池
流楚丶格念的博客
08-27 3717
3.x、4.x 和 5.x API 是完全不兼容的，使用起来比较麻烦。在 HttpClient 的执行过程中，连接复用是一个关键的性能优化点。通过合理配置连接池参数、正确处理连接的使用和释放，以及关注连接池的生命周期和性能监控，可以有效提高。下面是对连接池源码的重要步骤分析，包括连接的复用和非复用情况的处理，以及连接池内部的数据结构。此异常通常表示连接池中的连接用尽，导致无法获取到可用连接。这种状态表示线程在等待连接池中的连接。时，到每个主机的并发最多只有 200，但总的并发连接数为 300。
Apache HttpClient连接池泄露问题排查
hdfg159的专栏
09-05 1664
Apache HttpClient连接池泄露问题排查 问题背景 业务系统主要的业务是一个数据聚合管理平台，其中系统有一个功能是同步所有资源（简称 大同步） 业务同步数据请求数据工具是适配 Apache HttpClient 的 Feign ，这种请求封装是我当时根据业务适配业务封装请求 api Feign 版本: 10.10.1 问题来源 在生产环境，大同步功能(20多个任务)发现跑了一半多的任务时候卡住，在测试环境并没有发现这个问题 同步接口 public interface Sync
HttpClient连接池
做的过程自我总结
08-20 3866
推荐Springboot集成http连接池 https://blog.youkuaiyun.com/hellozpc/article/details/106861972 常用的http客户端有JDK原生的URLConnection、Netty的异步HTTP Client、Spring的RestTemplate、Spring Cloud中的Feign。 虽然RestTemplate、Feign使用极其方便，但是屏蔽了太多底层细节，不利于全局把控。 本文主要记载一下基于Apache HttpClient
httpclient实现http连接池
最新发布
TOOZOOY的博客
06-20 426
HTTP连接池是一种优化网络通信性能的技术，通过复用已建立的TCP连接减少重复握手开销，提升资源利用率
httpclient 连接池
shuiwuhen416的专栏
12-31 347
最近项目需要一个http多次请求的需求，发现多次新建HTTP client 会导致请求时间过长或者超时，需要引入HTTP client 连接池。 查阅资料整理如下，直接上代码： import java.io.*; import java.security.KeyManagementException; import java.security.KeyStoreException; im...
httpclient连接池
酸菜鱼的博客
08-10 581
采用连接池的方式创建httpClient package com.qjb.util; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.CloseableHttpCli
HttpClient4.5.2 连接池原理及注意事项
weixin_30258027的博客
04-25 507
随着微服务的流行，服务之间的http调用越来越多，遇到的问题也比较多，写这边文章的目的也是将自己遇到的坑和解决方案跟大家分享 一、为什么要用Http连接池 1、降低延迟：如果不采用连接池，每次连接发起Http请求的时候都会重新建立TCP连接(经历3次握手)，用完就会关闭连接(4次挥手)，如果采用连接池则减少了这部分时间损耗，别小看这几次握手，本人经过测试发现，基本上3倍的时间延迟 2、支持更...
使用HttpClient连接池优化HTTP请求性能示例代码
06-02
使用HttpClient连接池优化HTTP请求性能示例代码
【httpclient连接池的实现】
weixin_43728385的博客
07-12 192
apache httpclient 连接池的实现
http 连接池 java_HttpClient 连接池管理
weixin_32126555的博客
02-21 2420
随着微服务的流行，服务之间的http调用越来越多。在java里面我们可以使用httpclient这个开源工具类来进行处理，但若使用不当，可能性能会比较差，尤其是连接池是否能正常使用。接下来会详细分析下httpclient的连接池原理。1. 使用httpclient的好处1)、降低延迟：如果不采用连接池，每次连接发起Http请求的时候都会重新建立TCP连接(经历3次握手)，用完就会关闭连接(4次挥手...
HttpClient之连接池
Growing_way的博客
08-27 1144
Http Http协议是无状态的协议，每一次请求都是相互独立的，因此，最开始的设计是，每个htt请求都会打开一个 tcp socket 连接，当交互完毕后关闭这个连接。HTTP协议是全双工协议，所以建立连接与断开连接是要经过三次握手与四次挥手，显然，在这种设计 中，每次发送HTTP请求都会消耗额外资源时间，即连接的建立与销毁。 所以，持久连接的方式进行socket连接复用，是比较好的方式。 ...
HTTPClient 连接池
XHChen的博客
08-05 1329
向Dirud集群写入数据时，采用HTTPClient向集群提交数据，由于数据量大，需要以多线程方式开启多个线程，单个的HTTPClient会出现连接超时，效率低的情况。高并发的情况下，提高HTTP的请求效率，可以使用HTTPClient连接池的方式，减少3次握手的次数。 maven依赖 <dependency> <groupId>org.apache.h...
httpclient连接池管理
爱分享的淘金达人
03-22 524
随着微服务的留下，服务之间的http调用越来越多。在java里面我们可以使用httpclient这个开源工具类来进行处理，但若使用不当，可能性会比较差，尤其是连接池是否能正常使用，接下来会详细分析下httpclient的连接池原理。 （1）使用httpclient的好处 a）降低延迟：如果不采用连接池，每次连接发起http请求的时候都会重新建立tcp链接（经历三次握手），用完就会关闭连接（
HttpClient连接池的使用
weixin_34392435的博客
08-18 889
2019独角兽企业重金招聘Python工程师标准>>> ...
httpclient添加连接池
Yuantao1998的博客
08-27 2876
httpclient连接池相关配置
HttpClient 4.3连接池参数配置及源码解读
每天进步一点点
11-12 910
本文转自https://www.cnblogs.com/trust-freedom/p/6349502.html 目前所在公司使用HttpClient 4.3.3版本发送Rest请求，调用接口。最近出现了调用查询接口服务慢的生产问题，在排查整个调用链可能存在的问题时（从客户端发起Http请求->ESB->服务端处理请求，查询数据并返回），发现原本的HttpClient连接池中的...
深入解析Http持久连接与HttpClient连接池
HttpClient连接池是一种用于管理网络连接的复用策略，它允许多次重复使用已存在的连接，避免频繁地创建和销毁TCP连接，从而提高性能和资源利用率。Apache HttpClient提供了内置的连接池机制，可以通过设置参数（如...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值