HttpUtils带连接池

已于 2023-09-14 14:23:16 修改
阅读量764 收藏 2
点赞数
文章标签： python java 开发语言
于 2023-09-14 11:47:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JGMa_TiMo/article/details/132873129
版权

准备祖传了，有问题欢迎大家指正。

HttpUtil


import com.txlc.cloud.commons.exception.ServiceException;
import com.txlc.dwh.common.constants.MyErrorCode;
import org.ssssssss.script.annotation.Comment;

import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;

/**
 * @author 
 *
 */
public class HttpUtil {
	public static final String UTF_8 = "UTF-8";
	private static final PooledHttpClientAdaptor adaptor = new PooledHttpClientAdaptor();

	@Comment("http get")
	public static String doGet(@Comment("url")String apiUrl, @Comment("请求头，没有请传null")Map<String, String> headers, @Comment("url参数")Map<String, Object> params) {
		return adaptor.doGet(apiUrl, headers, params);
	}
	public static String doFormPost(@Comment("url")String apiUrl, @Comment("请求头，没有请传null")Map<String, String> headers, @Comment("form参数")Map<String, Object> params) {
		return adaptor.doPost(apiUrl, headers, params);
	}
	public static String doJsonPost(@Comment("url")String apiUrl,@Comment("请求头，没有请传null") Map<String, String> headers, @Comment("json参数")String jsonParam) {
		try {
			return adaptor.doPost(apiUrl, headers, jsonParam);
		} catch (UnsupportedEncodingException e) {
			throw new ServiceException(MyErrorCode.HTTP_PARAM_JSON.getStatus(),MyErrorCode.HTTP_PARAM_JSON.getMsg());
		}
	}

	public static String doDelete(String url, Map<String, String> headers, HashMap<String, Object> params) {
		return adaptor.doDelete(url, headers, params);
	}
	
	public static String getUrlWithParams(String url, Map<String, Object> params) {
        boolean first = true;
        StringBuilder sb = new StringBuilder(url);
        for (String key : params.keySet()) {
            char ch = '&';
            if (first == true) {
                ch = '?';
                first = false;
            }
            String value = params.get(key).toString();
            try {
                String sval = URLEncoder.encode(value, UTF_8);
                sb.append(ch).append(key).append("=").append(sval);
            } catch (UnsupportedEncodingException e) {
            }
        }
        return sb.toString();
    }
	
	public static Map<String, Object> convent2Map(Object b) {
		Map<String, Object> params = new HashMap<>();
		for(Field field: b.getClass().getDeclaredFields()) {
			field.setAccessible(true);
			Object val = null;
			try {
				val = field.get(b);
			} catch (IllegalArgumentException | IllegalAccessException e) {
			}
			if(val != null) {
				params.put(field.getName(), val);
			}
		}
		return params;
	}

}

PooledHttpClientAdaptor


import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import javax.net.ssl.SSLContext;

import cn.hutool.core.util.StrUtil;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpStatus;
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.HttpDelete;
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.HttpClientConnectionManager;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
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.HttpClientBuilder;
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 com.alibaba.fastjson.JSON;

/**
 * @author JGMa
 *
 */
public class PooledHttpClientAdaptor {
	private static final Logger logger = LoggerFactory.getLogger(PooledHttpClientAdaptor.class);
	 
    private static final int DEFAULT_POOL_MAX_TOTAL = 200;
    private static final int DEFAULT_POOL_MAX_PER_ROUTE = 200;
 
    private static final int DEFAULT_CONNECT_TIMEOUT = 10000;
    private static final int DEFAULT_CONNECT_REQUEST_TIMEOUT = 10000;
    private static final int DEFAULT_SOCKET_TIMEOUT = 60000;
    
    private PoolingHttpClientConnectionManager gcm = null;
 
    private CloseableHttpClient httpClient = null;
 
    private IdleConnectionMonitorThread idleThread = null;
 
    // 连接池的最大连接数
    private final int maxTotal;
    // 连接池按route配置的最大连接数
    private final int maxPerRoute;
 
    // tcp connect的超时时间
    private final int connectTimeout;
    // 从连接池获取连接的超时时间
    private final int connectRequestTimeout;
    // tcp io的读写超时时间
    private final int socketTimeout;
 
    public PooledHttpClientAdaptor() {
        this(
                PooledHttpClientAdaptor.DEFAULT_POOL_MAX_TOTAL,
                PooledHttpClientAdaptor.DEFAULT_POOL_MAX_PER_ROUTE,
                PooledHttpClientAdaptor.DEFAULT_CONNECT_TIMEOUT,
                PooledHttpClientAdaptor.DEFAULT_CONNECT_REQUEST_TIMEOUT,
                PooledHttpClientAdaptor.DEFAULT_SOCKET_TIMEOUT
        );
    }
 
    public PooledHttpClientAdaptor(int maxTotal, int maxPerRoute, int connectTimeout, int connectRequestTimeout, int socketTimeout ) {
        this.maxTotal = maxTotal;
        this.maxPerRoute = maxPerRoute;
        this.connectTimeout = connectTimeout;
        this.connectRequestTimeout = connectRequestTimeout;
        this.socketTimeout = socketTimeout;
        
        final SSLConnectionSocketFactory sslsf;
        try {
            sslsf = new SSLConnectionSocketFactory(SSLContext.getDefault(),
                    NoopHostnameVerifier.INSTANCE);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
 
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.getSocketFactory())
                .register("https", sslsf)
                .build();
 
        this.gcm = new PoolingHttpClientConnectionManager(registry);
        this.gcm.setMaxTotal(this.maxTotal);
        this.gcm.setDefaultMaxPerRoute(this.maxPerRoute);
 
		RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(this.connectTimeout)                     // 设置连接超时
                .setSocketTimeout(this.socketTimeout)                       // 设置读取超时
                .setConnectionRequestTimeout(this.connectRequestTimeout)    // 设置从连接池获取连接实例的超时
                .build();
 
        HttpClientBuilder httpClientBuilder = HttpClients.custom();
        httpClient = httpClientBuilder
                .setConnectionManager(this.gcm)
                .setDefaultRequestConfig(requestConfig)
                .build();
 
        idleThread = new IdleConnectionMonitorThread(this.gcm);
        idleThread.start();
 
    }
 
    public String doGet(String url) {
        return this.doGet(url, Collections.emptyMap(), Collections.emptyMap());
    }
 
    public String doGet(String url, Map<String, Object> params) {
        return this.doGet(url, Collections.emptyMap(), params);
    }
 
    public String doGet(String url, Map<String, String> headers,Map<String, Object> params) {
 
    	logger.debug("doGet url:" + url + ". headers :" + JSON.toJSONString(headers) + ". params :" + JSON.toJSONString(params));
        // *) 构建GET请求头
        String apiUrl = HttpUtil.getUrlWithParams(url, params);
        HttpGet httpGet = new HttpGet(apiUrl);
 
        // *) 设置header信息
        if ( headers != null && headers.size() > 0 ) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpGet.addHeader(entry.getKey(), entry.getValue());
            }
        }
 
        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(httpGet);
            if (response == null || response.getStatusLine() == null) {
                return null;
            }
 
            int statusCode = response.getStatusLine().getStatusCode();
            if ( statusCode == HttpStatus.SC_OK ) {
                HttpEntity entityRes = response.getEntity();
                if (entityRes != null) {
                	return EntityUtils.toString(entityRes, HttpUtil.UTF_8);
                }
            }
            return null;
        } catch (IOException e) {
        	logger.error(e.getMessage(), e);
        } finally {
            if ( response != null ) {
                try {
                    response.close();
                } catch (IOException e) {
                }
            }
        }
        return null;
    }
 
    public String doPost(String apiUrl, Map<String, Object> params) {
        return this.doPost(apiUrl, Collections.emptyMap(), params);
    }

    public String doPost(String apiUrl,Map<String, String> headers,String jsonParam) throws UnsupportedEncodingException {
        logger.debug("doPost url:" + apiUrl + ". headers :" + JSON.toJSONString(headers) + ". jsonParam :" + jsonParam);
        HttpPost httpPost = new HttpPost(apiUrl);

        // 配置请求headers
        if ( headers != null && headers.size() > 0 ) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpPost.addHeader(entry.getKey(), entry.getValue());
            }
        }

        // 配置请求参数
        if ( StrUtil.isNotBlank(jsonParam)) {
            StringEntity jsonEntity = new StringEntity(jsonParam);
            httpPost.setEntity(jsonEntity);
            httpPost.setHeader(HttpHeaders.CONTENT_TYPE, "application/json");
        }

        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(httpPost);
            if (response == null || response.getStatusLine() == null) {
                return null;
            }

            int statusCode = response.getStatusLine().getStatusCode();
            if ( statusCode == HttpStatus.SC_OK ) {
                HttpEntity entityRes = response.getEntity();
                if ( entityRes != null ) {
                    return EntityUtils.toString(entityRes, HttpUtil.UTF_8);
                }
            }
            return null;
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                }
            }
        }
        return null;

    }
 
    public String doPost(String apiUrl,  Map<String, String> headers, Map<String, Object> params) {
    	logger.debug("doPost url:" + apiUrl + ". headers :" + JSON.toJSONString(headers) + ". params :" + JSON.toJSONString(params));
        HttpPost httpPost = new HttpPost(apiUrl);
 
        // 配置请求headers
        if ( headers != null && headers.size() > 0 ) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpPost.addHeader(entry.getKey(), entry.getValue());
            }
        }
 
        // 配置请求参数
        if ( params != null && params.size() > 0 ) {
            HttpEntity entityReq = getUrlEncodedFormEntity(params);
            httpPost.setEntity(entityReq);
        }

        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(httpPost);
            if (response == null || response.getStatusLine() == null) {
                return null;
            }
 
            int statusCode = response.getStatusLine().getStatusCode();
            if ( statusCode == HttpStatus.SC_OK ) {
                HttpEntity entityRes = response.getEntity();
                if ( entityRes != null ) {
                    return EntityUtils.toString(entityRes, HttpUtil.UTF_8);
                }
            }
            return null;
        } catch (IOException e) {
        	logger.error(e.getMessage(), e);
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                }
            }
        }
        return null;
 
    }
    
    public String doDelete(String url,  Map<String, String> headers, Map<String, Object> params) {
    	logger.info("doDelete url:" + url + ". headers :" + JSON.toJSONString(headers) + ". params :" + JSON.toJSONString(params));
    	
        HttpDelete httpDelete = new HttpDelete(url);
 
        // *) 设置header信息
        if ( headers != null && headers.size() > 0 ) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
            	httpDelete.addHeader(entry.getKey(), entry.getValue());
            }
        }
 
        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(httpDelete);
            if (response == null || response.getStatusLine() == null) {
                return null;
            }
 
            int statusCode = response.getStatusLine().getStatusCode();
            if ( statusCode == HttpStatus.SC_OK ) {
                HttpEntity entityRes = response.getEntity();
                if (entityRes != null) {
                	return EntityUtils.toString(entityRes, HttpUtil.UTF_8);
                }
            }
            return null;
        } catch (IOException e) {
        	logger.error(e.getMessage(), e);
        } finally {
            if ( response != null ) {
                try {
                    response.close();
                } catch (IOException e) {
                }
            }
        }
        return null;
    }
 
    private HttpEntity getUrlEncodedFormEntity(Map<String, Object> params) {
        List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue().toString());
            pairList.add(pair);
        }
        return new UrlEncodedFormEntity(pairList, Charset.forName(HttpUtil.UTF_8));
    }
 
    public void shutdown() {
        idleThread.shutdown();
    }
 
    // 监控有异常的链接
    private class IdleConnectionMonitorThread extends Thread {
 
        private final HttpClientConnectionManager connMgr;
        private volatile boolean exitFlag = false;
 
        public IdleConnectionMonitorThread(HttpClientConnectionManager connMgr) {
            this.connMgr = connMgr;
            setDaemon(true);
        }
 
        @Override
        public void run() {
            while (!this.exitFlag) {
                synchronized (this) {
                    try {
                        this.wait(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 关闭失效的连接
                connMgr.closeExpiredConnections();
                // 可选的, 关闭30秒内不活动的连接
                connMgr.closeIdleConnections(30, TimeUnit.SECONDS);
            }
        }
 
        public void shutdown() {
            this.exitFlag = true;
            synchronized (this) {
                notify();
            }
        }
 
    }
 
}
BUG FIXER
关注
Http连接池PoolingHttpClientConnectionManager的应用
weixin_39417722的博客
05-26 9992
前言 Http连接需要的三次握手开销很大, 传统的HttpURLConnection并不支持连接池, HTTP1.1以上默认开启keepalive, 对于现在springcloud横行的社会, feign可以配置好http连接池, 不过总会有某些个别的接口不在服务中, 还有一些非springboot的老旧项目也要加入cloud大家族中, 对于内部频繁访问的url地址, 这就需要一款量身定做的工具类了. 讲解 先来看看测试效果, 两种工具类的时间消耗对比. 这个是测试用的方法, 前后分别调用了某一接口100
HttpClient的连接池
MyHerux的博客
08-16 1938
写在前面HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性，它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。一、为什么要用Http连接池1、降低延迟：如果不采用连接池，每次连接发起Http请求的时候都会重新建立TCP连接(经历3次握手)，用完就会关闭连接(4次挥手)。2、支持
hutool的HttpUtil没有使用连接池，为此看了一下apache的httpclient是怎么实现连接池的
白白胖胖充满希望
08-14 8819
之前有篇文章介绍过这个甜甜的java工具类库hutool，也用过它导出excel，对它印象还不错。 今天需要开发一个小工具jar，小工具的目的简单来说就是要去疯狂的远程调用几个http接口，开发之前首先就想到了用hutool试一下它里面的HttpUtil，因为小工具去调用远程http接口是要大量循环地进行的，是疯狂的，所以http连接池是必不可少的，为此特意去看了一下hutool的HttpUtil有没有应用连接池。 打开了hutool的HttpUtil类，有很多重载的get()和post()方法，想知道
HttpUtil学习笔记
最新发布
qq_41924536的博客
09-19 906
例如，如果服务器返回的是 JSON 数据，可以使用 JSON 解析库将字符串解析为 Java 对象进行业务逻辑处理。当发送多个 HTTP 请求时，通过复用已有的连接而不是每次都重新建立连接，可以大大提高效率。是一个非常实用的工具。可以简化这个过程，通过发送 GET 请求获取网页的 HTML 内容，然后再利用 HTML 解析库（如。可以用于微服务之间的请求发送和响应接收，方便在各个微服务之间传递数据、调用服务接口等操作。会自动处理连接建立、发送请求、接收响应等操作，并将服务器的响应以字符串形式返回。
HttpUtils工具类（一）常见的HttpUtils工具类及如何自定义java的http连接池
m0_52767002的博客
08-15 1420
一、几种常见的Http调用方式一、几种常见的Http调用方式OKhttp是一个功能强大的 HTTP 客户端库，支持同步和异步请求。它适用于处理更加复杂的场景，如认证、连接池、多线程、上传文件等。
贴出一个httpUtils是基于HttpClient连接池的封装
whb3299065的博客
09-03 761
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.ap...
http工具类（支持https,连接池和失败重试）
马春林的专栏
06-17 695
在实际项目中，经常会遇到调用外部（第三方）的接口，如果调用量较大的话，可能需要考虑连接池、失败重试、SSL证书等问题，以提升性能和稳定性。 以下代码是封装的小组件，供大家参考。 maven依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId>
OkHttp3 的连接池 httpUtils 源码
02-21
OkHttp3 的连接池 httpUtils 源码经过精心优化，可以提供快速、稳定、可靠的网络连接。它具有良好的缓存机制，可以有效地减少网络请求次数，提高网络性能。它还支持异步调用，可以有效地提高应用程序的响应速度。
HttpUtils.zip
04-07
- 连接池复用：如果`HttpUtils`使用了HttpClient，应考虑开启连接池复用，以减少建立新连接的开销。 - 安全性：对于涉及敏感信息的请求，确保使用HTTPS进行加密传输。 总的来说，`HttpUtils.zip`提供了一个便捷的...
HttpUtils 发送http请求工具类(实例讲解)
08-30
1. `init()` 方法：该方法用于初始化连接池，设置最大连接数和每路由最大连接数。 2. `getHttpClient()` 方法：该方法用于获取 HttpClient 对象，用于发送 HTTP 请求。 3. `httpGetRequest()` 方法：该方法用于发送 ...
HttpUtils.7z
07-24
`OkHttp`是一个高效的HTTP客户端库，它通过连接池、响应缓存、HTTP/2协议支持等特性，显著提高了网络请求的性能。虽然这个示例是仿照OkHttp写的，但我们可以从中学习到如何设计一个高效的网络请求库，比如如何实现...
HTTP连接池
mangzilu的博客
05-31 4580
前言 最早接触HTTP连接池，是在HTTP传输数据过程中，或因网络节点问题，或因网络波动，或因Tomcat连接爆棚等等，导致数据传输失败。想通过HTTP链接池，优化性能，但是因为公司项目架构的问题，最后使用了RocketMQ。下面是早前写的Demo。 正文 HTTP连接池优势 1.复用http连接,省去了tcp的3次握手和4次挥手的时间,极大降低请求响应的时间 2.自动管理tcp连接,不用人为地释放/创建连接 注意点 不要多个应用创建连接池去对应一个应用。嗯，大抵没记错的话，会使被请求方连接数的不到释放，最
http连接池
weixin_40035328的博客
04-21 860
项目场景： 最近项目中有个新需求，涉及海量数据批量入库。 问题描述： 因为各种原因，技术经理选择使用接口的方式进行数据录入，最终在使用接口录数据的时候频繁的报连接超时、连接打满的问题。 经过半天分析，发现是服务器文件句柄数跑满，修改成最大65535后，跑了一段时间又跑满。查看端口连接情况，发现很多连接没有被释放，最终导致跑满报错。 原因分析： 找到问题后，对连接设置了超时时间，运行一段时间后还是报错，没有从根本上解决问题，在高并发的场景下，没等着释放连接就满了。 解决方案： 使用http连接
Http请求连接池 - HttpClient 连接池
weixin_33739541的博客
12-24 374
两个主机建立连接的过程是很复杂的一个过程，涉及到多个数据包的交换，并且也很耗时间。Http连接需要的三次握手开销很大，这一开销对于比较小的http消息来说更大。但是如果我们直接使用已经建立好的http连接，这样花费就比较小，吞吐率更大。传统的HttpURLConnection并不支持连接池，如果要实现连接池的机制，还需要自己来管理连接对象。对于网络请求这...
工具类——HttpClientUtil带连接池的实现
weixin_40805079的博客
08-21 4046
为什么要使用连接池： 1、降低延迟：如果不采用连接池，每次连接发起Http请求的时候都会重新建立TCP连接(经历3次握手)，用完就会关闭连接(4次挥手)，如果采用连接池则减少了这部分时间损耗。 2、支持更大的并发：如果不采用连接池，每次连接都会打开一个端口，在大并发的情况下系统的端口资源很快就会被用完，导致无法建立新的连接。 话不多说，直接上代码，就是个工具类，之前提供了代码，这次是加入了连...
HttpClient之连接池
Growing_way的博客
08-27 1041
Http Http协议是无状态的协议，每一次请求都是相互独立的，因此，最开始的设计是，每个htt请求都会打开一个 tcp socket 连接，当交互完毕后关闭这个连接。HTTP协议是全双工协议，所以建立连接与断开连接是要经过三次握手与四次挥手，显然，在这种设计 中，每次发送HTTP请求都会消耗额外资源时间，即连接的建立与销毁。 所以，持久连接的方式进行socket连接复用，是比较好的方式。 ...
httpUtil
weixin_41996755的博客
08-16 820
需要在maven中导入的依赖： <!--http通讯依赖--> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId&...
hutool 的HttpUtil研究
Wewon_real的博客
01-25 4951
hutool 的HttpUtil没有连接池
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值