httpclient连接池释放异常和多余资源

最新推荐文章于 2025-06-02 18:24:17 发布
最新推荐文章于 2025-06-02 18:24:17 发布
阅读量8.2k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QH_JAVA/article/details/78673960
本文介绍了一个用于监控HTTP请求的实用工具类，支持GET和POST请求，并具备异常链接监控功能。该工具使用了Apache HttpClient进行HTTP通信，提供了丰富的配置选项如连接池大小、超时设置等。

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

请求、异常链接监控代码如下：

import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.ResponseHandler;
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.conn.HttpClientConnectionManager;
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.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;


 public class HttpUtil {
        private final CloseableHttpClient httpclient;
        private static final int SIZE = 1024 * 1024;

        private static final Charset CHARSET_UTF8 = Charset.forName("UTF-8");

        private static class HttpUtilHolder {
            private static final HttpUtil INSTANCE = new HttpUtil();
        }

        public static HttpUtil getIntance() {
            return HttpUtilHolder.INSTANCE;
        }

        private HttpUtil() {
            PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
            // 将最大连接数增加到300
            cm.setMaxTotal(300);
            // 将每个路由基础的连接增加到100
            cm.setDefaultMaxPerRoute(100);
            // 链接超时setConnectTimeout ，读取超时setSocketTimeout
            RequestConfig defaultRequestConfig;
            defaultRequestConfig = RequestConfig.custom().setConnectTimeout(3000).setSocketTimeout(3000).build();

            httpclient = HttpClients.custom().setConnectionManager(cm)
                    .setDefaultRequestConfig(defaultRequestConfig)
                    .setRetryHandler(new DefaultHttpRequestRetryHandler())
                    .build();

            new IdleConnectionMonitorThread(cm).start();
        }

        /**
         * 编码默认UTF-8
         *
         * @param url
         * @return
         */
        public String get(String url) {
            return this.get(url, CHARSET_UTF8.toString());
        }

        /**
         * @param url
         * @param params 请求参数
         * @return
         * @throws Exception
         */
        public String get(String url, Map<String, Object> params) {
            if (params != null) {
                String paramStr = "";
                for (String key : params.keySet()) {
                    if (!paramStr.isEmpty()) {
                        paramStr += '&';
                    }
                    if (null == params.get(key)) {
                        paramStr += key + '=';
                    } else {
                        try {
                            paramStr += key + '=' + URLEncoder.encode(params.get(key) + "", CHARSET_UTF8.toString());
                        } catch (UnsupportedEncodingException e) {
                            logger.error("key=" + key + "," + params.get(key) + " 错误", e);
                        }
                    }
                }

                if (url.indexOf('?') > 0) {
                    url += '&' + paramStr;
                } else {
                    url += '?' + paramStr;
                }
            }
            return this.get(url, CHARSET_UTF8.toString());
        }

        /**
         * @param url
         * @param code
         * @return
         */
        public String get(String url, final String code) {
            String res = null;

            try {
                HttpGet httpget = new HttpGet(url);
                ResponseHandler<String> responseHandler = new ResponseHandler<String>() {
                    @Override
                    public String handleResponse(final HttpResponse response) throws ClientProtocolException, IOException {
                        int status = response.getStatusLine().getStatusCode();
                        if (status >= 200 && status < 300) {
                            HttpEntity entity = response.getEntity();
                            return entity != null ? EntityUtils.toString(entity, code) : null;
                        } else {
                            throw new ClientProtocolException("Unexpected response status: " + status);
                        }
                    }

                };
                res = httpclient.execute(httpget, responseHandler);
                logApiStauts(true);
            } catch (Exception e) {
                logger.error("url:{}", url, e);
                logApiStauts(false);
            }
            return res;
        }

        public List<String> getList(String url) {
            List<String> res = null;
            try {
                HttpGet httpget = new HttpGet(url);
                ResponseHandler<List<String>> responseHandler = new ResponseHandler<List<String>>() {
                    @Override
                    public List<String> handleResponse(final HttpResponse response) throws ClientProtocolException,
                            IOException {
                        int status = response.getStatusLine().getStatusCode();
                        if (status >= 200 && status < 300) {
                            List<String> result = new ArrayList<String>();
                            HttpEntity entity = response.getEntity();
                            if (entity == null) {
                                return result;
                            }
                            BufferedReader in = new BufferedReader(new InputStreamReader(entity.getContent()), SIZE);
                            while (true) {
                                String line = in.readLine();
                                if (line == null) {
                                    break;
                                } else {
                                    result.add(line);
                                }
                            }
                            in.close();
                            return result;
                        } else {
                            throw new ClientProtocolException("Unexpected response status: " + status);
                        }
                    }

                };
                res = httpclient.execute(httpget, responseHandler);
                logApiStauts(true);
            } catch (Exception e) {
                logger.error(url, e);
                logApiStauts(false);
            }
            return res;
        }

        /**
         * @param url, params, code
         * @return java.lang.String
         */
        private String post(String url, List<NameValuePair> params, String code) {
            String res = null;
            CloseableHttpResponse response = null;
            try {
                HttpPost httpPost = new HttpPost(url);
                if (params != null) {
                    httpPost.setEntity(new UrlEncodedFormEntity(params, code));
                }
                response = httpclient.execute(httpPost);
                HttpEntity entity2 = response.getEntity();
                res = EntityUtils.toString(entity2, code);
                EntityUtils.consume(entity2);
                logApiStauts(true);
            } catch (Exception e) {
                logger.error(url, e);
                logApiStauts(false);
            } finally {
                if (response != null) {
                    try {
                        response.close();
                    } catch (IOException e) {
                    }
                }
            }
            return res;
        }

        /**
         * @param url, params, headers, code
         * @return java.lang.String
         */
        private String post(String url, List<NameValuePair> params, Map<String, String> headers, String code) {
            String res = null;
            CloseableHttpResponse response = null;
            try {
                HttpPost httpPost = new HttpPost(url);
                if (headers != null) {
                    for (Map.Entry<String, String> entry : headers.entrySet()) {
                        if (entry != null) {
                            httpPost.addHeader(entry.getKey(), entry.getValue());
                        }
                    }
                }
                if (params != null) {
                    httpPost.setEntity(new UrlEncodedFormEntity(params, code));
                }
                response = httpclient.execute(httpPost);
                HttpEntity entity2 = response.getEntity();
                res = EntityUtils.toString(entity2, code);
                EntityUtils.consume(entity2);
                logApiStauts(true);
            } catch (Exception e) {
                logger.error(url, e);
                logApiStauts(false);
            } finally {
                if (response != null) {
                    try {
                        response.close();
                    } catch (IOException e) {
                    }
                }
            }
            return res;
        }

        /**
         * 记录api调用状态
         *
         * @param isSuccess
         */
        private void logApiStauts(boolean isSuccess) {
            try {
                ApiMonitor monitor = ThreadLocalContext.getLocal();
                if (monitor == null) {
                    return;
                }
                LogUtils.appendApiPath(monitor, isSuccess);
            } catch (Exception e) {
                logger.error("记录api调用状态失败 e.message", e.getMessage(), e);
            } finally {
                ThreadLocalContext.clear();
            }
        }

        private static final String APPLICATION_JSON = "application/json";
        private static final String CONTENT_TYPE_TEXT_JSON = "text/json";

        public String postJSON(String url, String json, String code) {
            String res = null;
            CloseableHttpResponse response = null;
            try {
                HttpPost httpPost = new HttpPost(url);
                httpPost.addHeader(HTTP.CONTENT_TYPE, APPLICATION_JSON);

                StringEntity se = new StringEntity(json);
                se.setContentType(CONTENT_TYPE_TEXT_JSON);
                se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, APPLICATION_JSON));
                httpPost.setEntity(se);
                response = httpclient.execute(httpPost);
                HttpEntity entity2 = response.getEntity();
                res = EntityUtils.toString(entity2, code);
                EntityUtils.consume(entity2);
                logApiStauts(true);
            } catch (Exception e) {
                logger.error(url, e);
                logApiStauts(false);
            } finally {
                if (response != null) {
                    try {
                        response.close();
                    } catch (IOException e) {
                    }
                }
            }
            return res;
        }


        /**
         * 默认UTF-8
         *
         * @param url
         * @param params
         * @return
         */
        public String post(String url, Map<String, ?> params) {
            return this.post(url, params, null, CHARSET_UTF8.toString());
        }

        public String post(String url, Map<String, ?> params, Map<String, String> headers) {
            return this.post(url, params, headers, CHARSET_UTF8.toString());
        }

        /**
         * @param url
         * @param params
         * @param code
         * @return
         */
        public String post(String url, Map<String, ?> params, Map<String, String> headers, String code) {
            List<NameValuePair> nvps = null;
            if (params != null && params.size() > 0) {
                nvps = new ArrayList<>();
                for (Map.Entry<String, ?> entry : params.entrySet()) {
                    String value = entry.getValue() == null ? "" : entry.getValue().toString();
                    nvps.add(new BasicNameValuePair(entry.getKey(), value));
                }
            }
            return this.post(url, nvps, headers, code);
        }

        // 监控有异常的链接
        private static class IdleConnectionMonitorThread extends Thread {

            private final HttpClientConnectionManager connMgr;
            private volatile boolean shutdown;

            public IdleConnectionMonitorThread(HttpClientConnectionManager connMgr) {
                super();
                this.connMgr = connMgr;
            }

            @Override
            public void run() {
                try {
                    while (!shutdown) {
                        synchronized (this) {
                            wait(5000);
                            // 关闭失效的连接
                            connMgr.closeExpiredConnections();
                            // 可选的, 关闭30秒内不活动的连接
                            connMgr.closeIdleConnections(30, TimeUnit.SECONDS);
                        }
                    }
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        }

        public String postBody(String url, String body) {
            String res = null;
            try {
                HttpPost httppost = new HttpPost(url);
                if (StringUtils.isNotBlank(body)) {
                    httppost.setEntity(new StringEntity(body, CHARSET_UTF8));
                }
                CloseableHttpResponse response = httpclient.execute(httppost);
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    res = EntityUtils.toString(resEntity, CHARSET_UTF8);
                    EntityUtils.consume(resEntity);
                    logApiStauts(true);
                }
            } catch (Exception e) {
                logger.error(url, e);
                logApiStauts(false);
            }

            return res;
        }
    }




[Spark版本更新]--Spark-2.4.0 发布说明
欢迎来到我的博客，一起探索代码里的世界！
11-09 6878
2018-11-02 Apache Spark 官方发布了 2.4.0版本，以下是 Release Notes，供参考：  Sub-task [ SPARK-6236 ] - 支持大于2G的缓存块 [ SPARK-6237 ] - 支持上传块&gt; 2GB作为流 [ SPARK-10884 ] - 支持针对回归和分类相关模型的单实例预测 [ SPARK-11239 ] - 用于ML线性...
2022Java经典面试题总结(附问题和答案)
AlanChen的博客
05-20 4140
 Java基础  面向对象 封装：封装的意义，在于明确标识出允许外部使用的所有成员函数和数据项，内部细节对外部调用透明，外部调用无需修改或者关心内部实现 继承：继承基类的方法，并做出自己的改变和/或扩展，子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的 多态：基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同  JDK、JRE、JVM之间的区别 JDK：Java Develpment Kit java 开发工具 JRE：Java Runt
HttpClient 连接无法释放问题
awesome_learn的博客
06-08 3930
异步使用 httpclient 调用 `abort` 和 `releaseConnection` 后无法释放连接
HttpComponents HttpClient连接池(3)-连接的释放
weixin_46073333的博客
03-19 738
在上一篇文章里我们介绍了 httpclient 连接池中连接的申请，在这里我们主要介绍连接的和释放。http连接的释放httpclient 连接池中连接对象的释放主要涉及了Connect...
【后端】使用 HttpClient 连接池优化 HTTP 请求性能
最新发布
xiezhiyi007的专栏
06-02 789
本文将介绍如何使用 Java 和 Spring 框架中的 httpclient 包来实现高效的 HTTP 请求管理，并通过实际代码示例展示其用法。
Apache HttpClient 资源释放、请求超时，导致线程池用光、内存不足
weixin_34274029的博客
10-17 643
2019独角兽企业重金招聘Python工程师标准>>> ...
页面静态话，释放http连接异常
kkkder的博客
09-20 570
页面静态话，释放http连接异常
java httpclient释放_HttpClient 4.0.1-如何释放连接？
weixin_42298062的博客
02-13 614
我遍历了一堆URL，对于每个URL，我都在执行以下操作：private String doQuery(String url) {HttpGet httpGet = new HttpGet(url);setDefaultHeaders(httpGet); // static methodHttpResponse response = httpClient.execute(httpGet); //...
【性能提升秘诀】：Commons-HttpClient性能优化技巧实用建议
![【性能提升秘诀】：Commons-HttpClient性能...在本章中，我们将了解 Commons-HttpClient 这一在 Java 开发社区中广泛使用的库，它的作用及其在 Web 应用开发中的地位。 Commons-HttpClient 是 Apache 软件基金会开发
基于网络爬虫技术的网络新闻分析
weixin_46879314的博客
07-11 2193
基于网络爬虫技术的网络新闻分析
java httpclient释放_Apache HttpClient4.5从连接池中释放过期和空闲连接
weixin_36089954的博客
02-16 1020
代码案例：packagecom.what21.http.client4_5;importjava.util.concurrent.TimeUnit;importorg.apache.http.client.methods.CloseableHttpResponse;importorg.apache.http.client.methods.HttpGet;importorg.apache....
org.apache.commons.httpclient相关资源包
04-19
commons-codec-1.3.jar；commons-httpclient-3.0.jar；commons-logging.jar
HttpClient示例及资源释放
最初的节奏
09-17 1232
HttpClient请求资源释放 点关注不迷路，欢迎再访！ 精简博客内容，尽量已行业术语来分享。 努力做到对每一位认可自己的读者负责。 帮助别人的同时更是丰富自己的良机。 目录HttpClient请求资源释放一.PostMethod二.GetMethod三.HttpPost 一.PostMethod public class TestHttpclient extends TestCase { public static void main(String args[]) { Strin
Java：CloseableHttpClient处理gzip接口没有释放连接问题
zhibin的程序日记
03-05 2100
CloseableHttpClient使用了连接池，业务上遇到了org.apache.http.conn.ConnectionPoolTimeoutException: Timeout waiting for connection from pool异常，这里显示连接池大小不够了。当时并发并不是很高，为什么遇到这个问题呢？ 后来发现接口使用了gzip压缩，如果对方关闭了gzip就没有问题。这里展...
多线程应用(一)—Http请求阻塞回调处理
云逸 Dean的专栏
11-13 8131
多线程应用(一)—Http请求阻塞回调处理1.需求描述1.1场景说明:由于,微信端的业务需求量越来越大.将业务与微信第三方事件处理耦合在一起的单一项目的结构已经逐渐暴露出,承载能力不足的缺点.所以,需要将与微信的交互从业务逻辑中分离出,单独进行管理和处理. 这样做有以下几点好处: 可以达到业务解耦分离. 可以为业务系统微服务化做准备. 可以在解耦后针对性的对不同业务系统进行优化. 减少业务系统错误
Nginx系列（七）：HTTP请求释放
yang_oh的博客
06-11 1820
upstream资源释放（ngx_http_upstream_finalize_request） 调用u->peer.free释放上游TCP连接，详见upstream文档； 删除上游响应的文件缓存； 发送r->out中缓存的内容。 无论是non_buffer或pipe进行上游响应的发送，都使用r->pool分配的内存（u->buffer/u->pipe->...
python geventhttpclient测试
laputa73的专栏
01-22 1340
计划移植一个无阻塞python的服务框架. 首先要解决http client的使用. Gcurl已经多年无人维护. geventhttpclient这个号称比urllib2+gevent monkey快一倍. 先简单试试. #!/bin/env python # -*- coding: gbk -*- #使用pool import gevent import gevent.pool
HttpClient连接池使用不当问题分析解决
冰魂
05-07 1686
不正确使用第三方库HttpClient导致问题，在使用第三方库的时候一定要注意接口说明或者查看对应的源码以避免使用不当而出现故障。
HttpclientUtils的实现(重发，post)
qq_43009316的博客
11-13 700
文章目录 最近开发的项目需要使用http请求调用其他接口，所以需要使用到apache的httpclient，本人使用的是4.4.10版本 首先引入依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpc...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值