贴出一个httpUtils是基于HttpClient连接池的封装

最新推荐文章于 2024-08-15 18:37:29 发布
最新推荐文章于 2024-08-15 18:37:29 发布
阅读量748 收藏 1
点赞数
分类专栏： util java 文章标签： HttpClient
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whb3299065/article/details/100525109
版权
util 同时被 2 个专栏收录
22 篇文章 1 订阅
订阅专栏
java
22 篇文章 2 订阅
订阅专栏

基本上都有注释，调用的时候如果是常规http请求的话直接把参数封装到map里，然后HttpUtils.sendGet(url,para);或HttpUtils.sendPost(url,para)

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.HttpVersion;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
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.conn.HttpClientConnectionManager;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
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 java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @author weihuibin 2019/8/29
 */
public class HttpUtils {

    private static final Logger logger = LoggerFactory.getLogger(HttpUtils.class);
    private static CloseableHttpClient client;
    private static RequestConfig defaultRequestConfig = RequestConfig.custom()
            .setExpectContinueEnabled(false)
            // 禁用重定向
            .setRedirectsEnabled(false)
            .setRelativeRedirectsAllowed(false)
            .build();

    /**
     * 发送简单的Post请求
     *
     * @param url    接口地址
     * @param params 接口参数
     * @return
     */
    public static String sendSimplePost(String url, Map<String, String> params) {
        return sendPost(url, params, null, null, 20000, 20000, "UTF-8");
    }

    /**
     * 发送简单的Json格式的post请求
     *
     * @param url    接口地址
     * @param params 接口参数
     * @return
     */
    public static String sendSimpleJsonPost(String url, Object params) {
        return sendJsonPost(url, params, null, null, 20000, 20000, "UTF-8");
    }

    /**
     * 发送post请求，较为全面
     *
     * @param url            接口地址
     * @param params         接口参数
     * @param headers        请求头信息
     * @param cookies        请求cookies信息
     * @param connectTimeout 连接超时时间
     * @param socketTimeout  会话超时时间
     * @param charset        接口编码默认UTF-8
     * @return
     */
    public static String sendPost(String url, Map<String, String> params, Map<String, String> headers, List<String> cookies,
                                  int connectTimeout, int socketTimeout, String charset) {
        if (StringUtils.isEmpty(url)) {
            return StringUtils.EMPTY;
        }
        HttpPost post = getHttpPost(url, params, headers, cookies, connectTimeout, socketTimeout);
        return send(url, params, connectTimeout, socketTimeout, charset, post);
    }

    public static String sendJsonPost(String url, Object params, Map<String, String> headers, List<String> cookies,
                                      int connectTimeout, int socketTimeout, String charset) {
        if (StringUtils.isEmpty(url)) {
            return StringUtils.EMPTY;
        }
        HttpPost post = getJsonHttpPost(url, params, headers, cookies, connectTimeout, socketTimeout);
        return send(url, params, connectTimeout, socketTimeout, charset, post);
    }

    /**
     * HttpPost对象生成器
     *
     * @param url            接口地址
     * @param params         参数
     * @param headers        请求报头
     * @param cookies        请求Cookie
     * @param connectTimeout 请求超时时间
     * @param socketTimeout  等待数据超时时间
     * @return HttpPost
     */
    private static HttpPost getHttpPost(String url, Map<String, String> params, Map<String, String> headers, List<String> cookies,
                                        int connectTimeout, int socketTimeout) {
        try {
            HttpPost post = getDefHttpPost(url, cookies, connectTimeout, socketTimeout);
            addHeaders(post, headers, cookies, "");
            if (MapUtils.isNotEmpty(params)) {
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramsToNameValuePairs(params));
                post.setEntity(entity);
            }
            return post;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * json格式post生成器
     *
     * @param url            接口地址
     * @param params         接口参数
     * @param headers        请求头信息
     * @param cookies        请求cookies信息
     * @param connectTimeout 连接超时时间
     * @param socketTimeout  会话超时时间
     * @return
     */
    private static HttpPost getJsonHttpPost(String url, Object params, Map<String, String> headers, List<String> cookies,
                                            int connectTimeout, int socketTimeout) {
        try {
            HttpPost post = getDefHttpPost(url, cookies, connectTimeout, socketTimeout);
            addHeaders(post, headers, cookies, ContentType.APPLICATION_JSON.getMimeType());
            if (params != null) {
                StringEntity entity = new StringEntity(JsonUtils.toJson(params));
                post.setEntity(entity);
            }
            return post;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 生成默认的Post信息
     *
     * @param url            接口地址
     * @param cookies        请求cookies信息
     * @param connectTimeout 连接超时时间
     * @param socketTimeout  会话超时时间
     * @return
     */
    private static HttpPost getDefHttpPost(String url, List<String> cookies,
                                           int connectTimeout, int socketTimeout) {
        HttpPost post = new HttpPost(url);
        post.setProtocolVersion(HttpVersion.HTTP_1_1);
        RequestConfig requestConfig = generateRequestConfig(connectTimeout, socketTimeout);
        post.setConfig(requestConfig);
        return post;
    }

    /**
     * 发送简单的GET请求
     *
     * @param url    接口地址
     * @param params 请求参数
     * @return
     */
    public static String sendSimpleGet(String url, Map<String, String> params) {
        return sendGet(url, params, null, null, 20000, 10000, "UTF-8");

    }

    /**
     * 发送详细的GET请求
     *
     * @param url            接口地址
     * @param params         接口参数
     * @param headers        请求头信息
     * @param cookies        请求cookies信息
     * @param connectTimeout 连接超时时间
     * @param socketTimeout  会话超时时间
     * @param charset        接口编码默认UTF-8
     * @return
     */
    public static String sendGet(String url, Map<String, String> params, Map<String, String> headers, List<String> cookies,
                                 int connectTimeout, int socketTimeout, String charset) {
        if (StringUtils.isEmpty(url)) {
            return StringUtils.EMPTY;
        }

        HttpGet httpGet = getHttpGet(url, params, headers, cookies, connectTimeout, socketTimeout);
        if (httpGet == null) {
            return StringUtils.EMPTY;
        }
        return send(url, params, connectTimeout, socketTimeout, charset, httpGet);
    }

    /**
     * 用于将数据进行发送并将响应解析为字符串
     *
     * @param url            接口地址
     * @param params         接口参数
     * @param connectTimeout 连接超时时间
     * @param socketTimeout  会话超时时间
     * @param charset        接口编码默认UTF-8
     * @return
     */
    private static String send(String url, Object params, int connectTimeout, int socketTimeout, String charset, HttpRequestBase requestBase) {
        HttpResponse response = null;
        try {
            response = getClient().execute(requestBase);
            if (response == null) {
                logger.error("HttpClientUtil.sendHttpGetRequest error >>>>>> response is null, url:{}, params:{}, connectTimeout:{}, socketTimeout:{}",
                        url, params, connectTimeout, socketTimeout);
                return StringUtils.EMPTY;
            }
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode != HttpStatus.SC_OK) {
                logger.error("HttpClientUtil.sendHttpGetRequest error >>>>>> method failed:{}, url:{}, params:{}, connectTimeout:{}, socketTimeout:{}",
                        response.getStatusLine(), url, params, connectTimeout, socketTimeout);
                /* 当状态码不是200时，默认返回空字符串 */
                return StringUtils.EMPTY;
            }
            if (StringUtils.isEmpty(charset)) {
                charset = "UTF-8";
            }
            return EntityUtils.toString(response.getEntity(), charset);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    // 会自动释放连接
                    EntityUtils.consume(response.getEntity());
                    requestBase.releaseConnection();
                }
            } catch (IOException e) {
                logger.error("HttpClientUtil.sendHttpPostRequest error, stream connection close failure, url:{}, params:{}, connectTimeout:{}, socketTimeout:{}",
                        url, params, connectTimeout, socketTimeout, e);
            } catch (Exception e) {
                logger.error("HttpClientUtil.sendHttpPostRequest error, url:{}, params:{}, connectTimeout:{}, socketTimeout:{}",
                        url, params, connectTimeout, socketTimeout, e);
            }
        }
        return StringUtils.EMPTY;
    }


    /**
     * HttpGet对象生成器
     *
     * @param url            接口地址
     * @param params         参数
     * @param headers        请求报头
     * @param cookies        请求Cookie
     * @param connectTimeout 请求超时时间
     * @param socketTimeout  等待数据超时时间
     * @return HttpGet
     */
    private static HttpGet getHttpGet(String url, Map<String, String> params, Map<String, String> headers, List<String> cookies,
                                      int connectTimeout, int socketTimeout) {
        try {
            //生成URLBuilder用于构建url以及参数请求连接
            URIBuilder builder = new URIBuilder(url);
            if (MapUtils.isNotEmpty(params)) {
                builder.addParameters(paramsToNameValuePairs(params));
            }
            HttpGet httpGet = new HttpGet(builder.build());
            //设置HTTP协议版本
            httpGet.setProtocolVersion(HttpVersion.HTTP_1_1);
            //添加消息头
            addHeaders(httpGet, headers, cookies, "");
            //添加请求设施参数
            httpGet.setConfig(generateRequestConfig(connectTimeout, socketTimeout));
            return httpGet;
        } catch (URISyntaxException e) {
            logger.error("HttpClientUtil.generateHttpGet error, url:{}, params:{}, connectTimeout:{}, socketTimeout:{}",
                    url, params, connectTimeout, socketTimeout, e);
        }
        return null;
    }

    /**
     * 将Map参数解析为list参数
     *
     * @param params 参数
     * @return
     */
    private static List paramsToNameValuePairs(Map<String, String> params) {
        List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
        if (MapUtils.isNotEmpty(params)) {
            for (String key : params.keySet()) {
                nameValuePairs.add(new BasicNameValuePair(key, params.get(key)));
            }
        }
        return nameValuePairs;
    }

    /**
     * 单例方式获取Client实例
     *
     * @return
     */
    private static HttpClient getClient() {
        if (client == null) {
            synchronized (HttpUtils.class) {
                if (client == null) {
                    client = makeClient();
                }
            }
        }
        return client;
    }

    /**
     * http header
     *
     * @param httpRequest
     * @param headers     请求报头
     * @param cookies     通过httpRequest.addHeader方法设置Cookie
     * @param contentType 发送信息编码类型，默认application/x-www-form-urlencoded
     */
    private static void addHeaders(HttpRequestBase httpRequest, Map<String, String> headers, List<String> cookies, String contentType) {
        if (StringUtils.isEmpty(contentType)) {
            contentType = ContentType.APPLICATION_FORM_URLENCODED.getMimeType();
        }
        httpRequest.addHeader("Content-type", contentType);
        // 设置HTTP短连接, 在一次请求/响应之后, 就会关闭连接
        httpRequest.addHeader("Connection", "close");
        if (MapUtils.isNotEmpty(headers)) {
            for (String key : headers.keySet()) {
                httpRequest.addHeader(key, headers.get(key));
            }
        }
        if (CollectionUtils.isNotEmpty(cookies)) {
            for (String cookie : cookies) {
                if (StringUtils.isNotBlank(cookie)) {
                    httpRequest.addHeader("Cookie", cookie);
                }
            }
        }
    }

    /**
     * RequestConfig对象生成器
     *
     * @param connectTimeout 请求超时时间
     * @param socketTimeout  等待数据超时时间
     * @return RequestConfig
     */
    private static RequestConfig generateRequestConfig(int connectTimeout, int socketTimeout) {
        return RequestConfig.copy(defaultRequestConfig)
                // 设置从Connect Manager获取Connection的超时时间, 即连接不够用的时候的等待超时时间, 一定要设置, 而且不能太大
                .setConnectionRequestTimeout(connectTimeout / 2)
                // 设置请求超时时间
                .setConnectTimeout(connectTimeout)
                // 设置等待数据超时时间
                .setSocketTimeout(socketTimeout)
                .build();
    }

    /**
     * 生成cilent
     *
     * @return
     */
    private static CloseableHttpClient makeClient() {
        CloseableHttpClient httpClient = HttpClients.custom()
                .setRetryHandler(new DefaultHttpRequestRetryHandler(0, false))
                .setDefaultRequestConfig(getDefaultRequestConfig())
                .setConnectionManager(getConnectionManager()).build();
        return httpClient;
    }

    /**
     * 获取连接管理器
     *
     * @return
     */
    private static HttpClientConnectionManager getConnectionManager() {
        PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager();
        //最大连接数
        manager.setMaxTotal(10);
        //每个路由最大连接数
        manager.setDefaultMaxPerRoute(100);
        //设置到某个路由的最大连接数，会覆盖defaultMaxPerRoute
        //manager.setMaxPerRoute(new HttpRoute(new HttpHost()));
        return manager;
    }

    /**
     * 获取默认连接设置
     *
     * @return
     */
    private static RequestConfig getDefaultRequestConfig() {
        RequestConfig defaultRequestConfig = RequestConfig.custom()
                .setExpectContinueEnabled(false)
                // 禁用重定向
                .setRedirectsEnabled(false)
                .setRelativeRedirectsAllowed(false)
                .build();
        return defaultRequestConfig;
    }

}

用了如下jar

    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>

        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <!--<scope>test</scope>-->
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>
    </dependencies>
huibinwei
关注
专栏目录
Http连接池工具类
04-25
两个主机建立连接的过程是很复杂的一个过程，涉及到多个数据包的交换，并且也很耗时间。Http连接需要的三次握手开销很大，这一开销对于比较小的http消息来说更大。但是如果我们直接使用已经建立好的http连接，这样花费就比较小，吞吐率更大。 传统的HttpURLConnection并不支持连接池，如果要实现连接池的机制，还需要自己来管理连接对象。对于网络请求这种底层相对复杂的操作，个人以为如果有可用的其他方案，也没有必要自己去管理连接对象。 除了HttpURLConnection，大家肯定还知道HttpClient。一般情况下，普通使用HttpClient已经能满足我们的需求，不过有时候，在我们需要高并发大量的请求网络的时候，还是用“连接池”这样的概念能提升吞吐量。
带连接池的httpclient的使用小例
liu518的博客
12-06 167
jar包取自于httpclient-4.1.1.jar 1》：设置带连接池的HttpClient public class HttpClientUtils { private static final Log log = LogFactory.getLog(HttpClientUtils.class); private s...
HttpUtils工具类（一）常见的HttpUtils工具类及如何自定义java的http连接池
最新发布
m0_52767002的博客
08-15 762
一、几种常见的Http调用方式一、几种常见的Http调用方式OKhttp是一个功能强大的 HTTP 客户端库，支持同步和异步请求。它适用于处理更加复杂的场景，如认证、连接池、多线程、上传文件等。
工具类——HttpClientUtil带连接池的实现
weixin_40805079的博客
08-21 4008
为什么要使用连接池： 1、降低延迟：如果不采用连接池，每次连接发起Http请求的时候都会重新建立TCP连接(经历3次握手)，用完就会关闭连接(4次挥手)，如果采用连接池则减少了这部分时间损耗。 2、支持更大的并发：如果不采用连接池，每次连接都会打开一个端口，在大并发的情况下系统的端口资源很快就会被用完，导致无法建立新的连接。 话不多说，直接上代码，就是个工具类，之前提供了代码，这次是加入了连...
HttpUtils带连接池
高性价比服务器就选：蓝易云
04-05 256
是一个常用的HTTP请求工具类，主要用于发送HTTP请求和处理HTTP响应。在高并发的情况下，如果每次请求都新建一个连接，会导致系统资源的浪费，同时也会降低系统的性能。因此，我们需要使用连接池来管理HTTP连接，提高系统的性能。连接池的主要作用是重用已经建立的HTTP连接，避免了每次请求都需要创建和销毁连接的开销。连接池中的连接在使用后不会立即被关闭，而是返回到连接池中，供下一次请求使用。的实例，并设置了连接池的最大连接数和每个路由的最大连接数。带连接池的实现方式，希望对你有所帮助。
基于HttpClient的HttpUtils(后台访问URL)
03-16
基于HttpClient的HttpUtils是开发者自定义封装的工具类，方便在后台程序中高效、便捷地访问远程URL。本篇将详细介绍HttpUtils的实现原理及其核心功能。 首先，HttpClient是由Apache软件基金会提供的一个开源项目，...
httpUtil httpclient 登陆携带cookie访问下一个连接
10-24
可以使用`HttpClientBuilder`来定制各种设置，如超时时间、重试策略、连接池等。 3. **执行请求**：调用`HttpClient`的`execute`方法，传入`HttpPost`对象，得到`HttpResponse`。这将返回服务器的响应，包括状态码...
HttpUtils.zip
04-07
3. **HttpUtils**：`HttpUtils`通常是一个封装了HttpClient或OkHttp的工具类，目的是为了简化网络请求的操作。在`HttpUtils.zip`中，这个工具类可能已经预设了常用的配置，如连接超时、读取超时等，并提供了简单易用...
HttpClientUtil工具类发送get和post请求，支持http和https，支持发送文件
04-07
HttpClientUtil可能需要配置连接池的大小、超时时间等参数，以适应不同的应用场景。 综上所述，HttpClientUtil工具类在IT应用中扮演着关键角色，简化了HTTP和HTTPS请求的实现，特别是发送文件这样的复杂操作。通过...
httpClient.zip
06-19
"httputils"可能是一个封装了HttpClient常用操作的工具类，简化了HTTP请求的调用方式。通常，这样的工具类会提供静态方法，如`get(String url)`、`post(String url, Map, String> params)`等，以便开发者只需传入...
HttpUtils 发送http请求工具类(实例讲解)
08-30
下面小编就为大家带来一篇HttpUtils 发送http请求工具类(实例讲解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
带有连接池的Http客户端工具类HttpClientUtil
weixin_38170829的博客
09-19 738
一、背景 业务开发中，经常会遇到通过http/https向下游服务发送请求。每次都要重复造轮子写HttpClient的逻辑，而且性能、功能参差不齐。这里分享一个高性能的、带连接池的通用Http客户端工具。 请尊重作者劳动成果，转载请标明原文链接：https://www.cnblogs.com/waterystone/p/11551280.html 二、特点 基于apache的...
httpUtils封装
二蛋兄的专栏
04-30 222
public static HttpEntity getHttpEntity(int request, List nameValuePairLists, String url) throws Exception { HttpClient httpClient = new DefaultHttpClient(); httpClient.getParams().setParameter( C
支持https和http连接池的HttpClientUtil
你看我像菜鸟吗？
04-25 813
import java.io.UnsupportedEncodingException; import java.security.KeyManagementException; import java.security.KeyStoreException; import java.security.NoSuchAlgorithmException; import java.securi...
httpUtil
weixin_41996755的博客
08-16 794
需要在maven中导入的依赖： <!--http通讯依赖--> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId&...
http工具类（支持https,连接池和失败重试）
马春林的专栏
06-17 674
在实际项目中，经常会遇到调用外部（第三方）的接口，如果调用量较大的话，可能需要考虑连接池、失败重试、SSL证书等问题，以提升性能和稳定性。 以下代码是封装的小组件，供大家参考。 maven依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId>
HTTP连接池
mangzilu的博客
05-31 4541
前言 最早接触HTTP连接池，是在HTTP传输数据过程中，或因网络节点问题，或因网络波动，或因Tomcat连接爆棚等等，导致数据传输失败。想通过HTTP链接池，优化性能，但是因为公司项目架构的问题，最后使用了RocketMQ。下面是早前写的Demo。 正文 HTTP连接池优势 1.复用http连接,省去了tcp的3次握手和4次挥手的时间,极大降低请求响应的时间 2.自动管理tcp连接,不用人为地释放/创建连接 注意点 不要多个应用创建连接池去对应一个应用。嗯，大抵没记错的话，会使被请求方连接数的不到释放，最
http连接池
weixin_40035328的博客
04-21 839
项目场景： 最近项目中有个新需求，涉及海量数据批量入库。 问题描述： 因为各种原因，技术经理选择使用接口的方式进行数据录入，最终在使用接口录数据的时候频繁的报连接超时、连接打满的问题。 经过半天分析，发现是服务器文件句柄数跑满，修改成最大65535后，跑了一段时间又跑满。查看端口连接情况，发现很多连接没有被释放，最终导致跑满报错。 原因分析： 找到问题后，对连接设置了超时时间，运行一段时间后还是报错，没有从根本上解决问题，在高并发的场景下，没等着释放连接就满了。 解决方案： 使用http连接
java httpclient 连接池 代码
04-26
以下是一个简单的Java HTTPClient连接池代码示例： ``` import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.client.config.RequestConfig; import org.apache....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值