httpclient pool使用工具类

最新推荐文章于 2024-04-05 04:24:22 发布
最新推荐文章于 2024-04-05 04:24:22 发布
阅读量274 收藏
点赞数
文章标签： json java
原文链接：https://my.oschina.net/u/3177897/blog/811919
版权

package com.aisino.common.util;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.CodingErrorAction;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.CookieSpecs;
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.ConnectionConfig;
import org.apache.http.config.MessageConstraints;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
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.util.EntityUtils;
import org.apache.log4j.Logger;

import com.alibaba.fastjson.JSON;

public class HttpClientUtil {
     
    private final static Logger logger = Logger.getLogger(HttpClientUtil.class);
     
    private static PoolingHttpClientConnectionManager connManager = null;
    private static CloseableHttpClient httpclient = null;
    private static RequestConfig globalConfig = null;
     
    static {
        try {
            globalConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.BEST_MATCH).build();
            SSLContext sslContext = SSLContexts.custom().useTLS().build();
            sslContext.init(null,
                    new TrustManager[] { new X509TrustManager() {
                        public X509Certificate[] getAcceptedIssuers() {
                            return null;
                        }
                        public void checkClientTrusted(
                                X509Certificate[] certs, String authType) {
                        }
                        public void checkServerTrusted(
                                X509Certificate[] certs, String authType) {
                        }
                    }}, null);
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.INSTANCE)
                    .register("https", new SSLConnectionSocketFactory(sslContext))
                    .build();
             
            connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            httpclient = HttpClients.custom().setConnectionManager(connManager).build();
            // Create socket configuration
            SocketConfig socketConfig = SocketConfig.custom().setTcpNoDelay(true).build();
            connManager.setDefaultSocketConfig(socketConfig);
            // Create message constraints
            MessageConstraints messageConstraints = MessageConstraints.custom()
                .setMaxHeaderCount(200)
                .setMaxLineLength(2000)
                .build();
            // Create connection configuration
            ConnectionConfig connectionConfig = ConnectionConfig.custom()
                .setMalformedInputAction(CodingErrorAction.IGNORE)
                .setUnmappableInputAction(CodingErrorAction.IGNORE)
                .setCharset(Consts.UTF_8)
                .setMessageConstraints(messageConstraints)
                .build();
            connManager.setDefaultConnectionConfig(connectionConfig);
            connManager.setMaxTotal(200);
            connManager.setDefaultMaxPerRoute(20);
        } catch (KeyManagementException e) {
            logger.error("KeyManagementException", e);
        } catch (NoSuchAlgorithmException e) {
            logger.error("NoSuchAlgorithmException", e);
        }
    }
     
    public static String postMapBody(String url, int timeout, Map<String, Object> map){
        HttpPost post = new HttpPost(url);
        try {
            post.setHeader("Content-type", "application/json");
            RequestConfig requestConfig = RequestConfig.custom()
                    .setSocketTimeout(timeout)
                    .setConnectTimeout(timeout)
                    .setConnectionRequestTimeout(timeout)
                    .setExpectContinueEnabled(false).build();
            post.setConfig(requestConfig);
             
            //String str1 = JsonUtil.objectToJson(map).replace("\\", "");
            String str1 = JSON.toJSONString(map,false);
            post.setEntity(new StringEntity(str1, Consts.UTF_8));
            //logger.info("[HttpUtils Post] begin invoke url:" + url + " , params:"+str1);
            CloseableHttpResponse response = httpclient.execute(post);
            try {
                HttpEntity entity = response.getEntity();
                try {
                    if(entity != null){
                        String str = EntityUtils.toString(entity, Consts.UTF_8);
                        return str;
                    }
                } finally {
                    if(entity != null){
                        entity.getContent().close();
                    }
                }
            } finally {
                if(response != null){
                    response.close();
                }
            }
        }catch (Exception e) {
            //logger.error("Exception", e);
            logger.error("[HttpUtils postMapBody], url :" + url+","+e.getClass().getName());
        } finally {
            post.releaseConnection();
        }
        return "";
    }
    
    public static String postJsonBody(String url, int timeout, String json){
        HttpPost post = new HttpPost(url);
        try {
            post.setHeader("Content-type", "application/json");
            RequestConfig requestConfig = RequestConfig.custom()
                    .setSocketTimeout(timeout)
                    .setConnectTimeout(timeout)
                    .setConnectionRequestTimeout(timeout)
                    .setExpectContinueEnabled(false).build();
            post.setConfig(requestConfig);
             
            //String str1 = JsonUtil.objectToJson(map).replace("\\", "");
            post.setEntity(new StringEntity(json, Consts.UTF_8));
            CloseableHttpResponse response = httpclient.execute(post);
            try {
                HttpEntity entity = response.getEntity();
                try {
                    if(entity != null){
                        String str = EntityUtils.toString(entity, Consts.UTF_8);
                        return str;
                    }
                } finally {
                    if(entity != null){
                        entity.getContent().close();
                    }
                }
            } finally {
                if(response != null){
                    response.close();
                }
            }
        }catch (Exception e) {
            //logger.error("Exception", e);
            logger.error("[HttpUtils postMapBody], url :" + url+","+e.getClass().getName());
        } finally {
            post.releaseConnection();
        }
        return "";
    }
    
    public static String executeGet(String url,int connectTimeout, int soTimeout) {
        String responseString = null;
        RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(connectTimeout).setConnectTimeout(connectTimeout).setConnectionRequestTimeout(connectTimeout).build();
        //logger.info("[HttpUtils Get] begin invoke:" + url);
        HttpGet get = new HttpGet(url);
        get.setConfig(requestConfig);
        try {
            CloseableHttpResponse response = httpclient.execute(get);
            try {
                HttpEntity entity = response.getEntity();
                try {
                    if(entity != null){
                        responseString = EntityUtils.toString(entity, Consts.UTF_8);
                        return responseString;
                    }
                } finally {
                    if(entity != null){
                        entity.getContent().close();
                    }
                }
            } catch (Exception e) {
                //logger.error(String.format("[HttpUtils Get]get response error, url:%s", url), e);
                //logger.error("[HttpUtils Get] begin invoke url:" + url);
                logger.error("[HttpUtils executeGet], url :" + url+","+e.getClass().getName());
            } finally {
                if(response != null){
                    response.close();
                }
            }
            //logger.info(String.format("[HttpUtils Get]Debug url:%s , response string %s:", sb.toString(), responseString));
        }catch (Exception e) {
            //logger.error(String.format("[HttpUtils Get]invoke get error, url:%s", url), e);
            logger.error("[HttpUtils executeGet], url :" + url+","+e.getClass().getName());
        } finally {
            get.releaseConnection();
        }
        return "";
    }
    
    public static String cookieGet(String url) {
        String responseString = null;
        RequestConfig requestConfig = RequestConfig
                .copy(globalConfig)
                .setSocketTimeout(connectTimeout)
                .setConnectTimeout(connectTimeout)
                .setConnectionRequestTimeout(connectTimeout)
                .setCookieSpec(CookieSpecs.BROWSER_COMPATIBILITY)
                .build();
        //logger.info("[HttpUtils Get] begin invoke:" + url);
        HttpGet get = new HttpGet(url);
        get.setConfig(requestConfig);
        try {
            CloseableHttpResponse response = httpclient.execute(get);
            try {
                HttpEntity entity = response.getEntity();
                try {
                    if(entity != null){
                        responseString = EntityUtils.toString(entity, Consts.UTF_8);
                        return responseString;
                    }
                } finally {
                    if(entity != null){
                        entity.getContent().close();
                    }
                }
            } catch (Exception e) {
                logger.error("[HttpUtils cookieGet], url :" + url+","+e.getClass().getName());
                //logger.error(String.format("[HttpUtils Get]get response error, url:%s", url), e);
            } finally {
                if(response != null){
                    response.close();
                }
            }
            //logger.info(String.format("[HttpUtils Get]Debug url:%s , response string %s:", sb.toString(), responseString));
        } catch (Exception e) {
            logger.error("[HttpUtils cookieGet], url :" + url+","+e.getClass().getName());
        } finally {
            get.releaseConnection();
        }
        return "";
    }
    
    @SuppressWarnings("deprecation")
    public static String invokeGet(String url, Map<String, String> params, int connectTimeout, int soTimeout) {
        String responseString = null;
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(connectTimeout)
                .setConnectTimeout(connectTimeout)
                .setConnectionRequestTimeout(connectTimeout).build();
         
        StringBuilder sb = new StringBuilder();
        sb.append(url);
        int i = 0;
        for (Entry<String, String> entry : params.entrySet()) {
            String value = entry.getValue();
            if (value==null){
                continue;
            }
            if (i == 0 && !url.contains("?")) {
                sb.append("?");
            } else {
                sb.append("&");
            }
            sb.append(entry.getKey());
            sb.append("=");
            try {
                sb.append(URLEncoder.encode(value, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                logger.warn("encode http get params error, value is "+value, e);
                sb.append(URLEncoder.encode(value));
            }
            i++;
        }
        //logger.info("[HttpUtils Get] begin invoke:" + sb.toString());
        HttpGet get = new HttpGet(sb.toString());
        get.setConfig(requestConfig);
         
        try {
            CloseableHttpResponse response = httpclient.execute(get);
            try {
                HttpEntity entity = response.getEntity();
                try {
                    if(entity != null){
                        responseString = EntityUtils.toString(entity, Consts.UTF_8);
                        return responseString;
                    }
                } finally {
                    if(entity != null){
                        entity.getContent().close();
                    }
                }
            } catch (Exception e) {
                logger.error("[HttpUtils invokeGet], url :" + url+","+e.getClass().getName());
            } finally {
                if(response != null){
                    response.close();
                }
            }
            //logger.info(String.format("[HttpUtils Get]Debug url:%s , response string %s:", sb.toString(), responseString));
        } catch (Exception e) {
            logger.error("[HttpUtils invokeGet], url :" + url+","+e.getClass().getName());
        } finally {
            get.releaseConnection();
        }
        return "";
    }
     
    public final static int connectTimeout = 5000;
    /**
     * HTTPS请求，默认超时为5S
     * @param reqURL
     * @param params
     * @return
     */
    public static String connectPostHttps(String reqURL, Map<String, String> params) {
 
        String responseContent = null;
         
        HttpPost httpPost = new HttpPost(reqURL); 
        try {
            RequestConfig requestConfig = RequestConfig.custom()
                    .setSocketTimeout(connectTimeout)
                    .setConnectTimeout(connectTimeout)
                    .setConnectionRequestTimeout(connectTimeout).build();
             
            List<NameValuePair> formParams = new ArrayList<NameValuePair>(); 
            // 绑定到请求 Entry
            for (Map.Entry<String, String> entry : params.entrySet()) {
                formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            httpPost.setEntity(new UrlEncodedFormEntity(formParams, Consts.UTF_8));
            httpPost.setConfig(requestConfig);
            CloseableHttpResponse response = httpclient.execute(httpPost);
             try {
                // 执行POST请求
                HttpEntity entity = response.getEntity(); // 获取响应实体
                try {
                    if (null != entity) {
                        responseContent = EntityUtils.toString(entity, Consts.UTF_8);
                        return responseContent;
                    }
                } finally {
                    if(entity != null){
                        entity.getContent().close();
                    }
                }
            } finally {
                if(response != null){
                    response.close();
                }
            }
            //logger.info("requestURI : "+httpPost.getURI()+", responseContent: " + responseContent);
        } catch (Exception e) {
            logger.error("[HttpUtils connectPostHttps], url :" + reqURL+","+e.getClass().getName());
        } finally {
            httpPost.releaseConnection();
        }
        return "";
    }
}
 

转载于:https://my.oschina.net/u/3177897/blog/811919

chuiyanzhe3581
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
TinyHttpClientPool：一个HttpClient管理器，它允许发生很酷的事情
02-06
TinyHttpClientPool 一个HttpClient池，通过确保您在使用HttpClient时拥有对HttpClient的完全且唯一的访问权限，从而可以重用HTTP客户端。 它很小，只有几节课大。 建造状态 为什么要使用它？ 调用时对HttpClient的独占访问 重用HttpClient时允许每个请求自定义标头 游泳池很酷 为什么创建 它是在Xamarin的基础上创建的，这就是我们使用它的地方。 用法 获取池管理器的实例 有几种获取实例的方法。 // A) Just create a new instance var pool = new TinyHttpClientPoo
HttpClientHelper 工具类
08-13
C# HttpClientHelper（HttpClient工具类） 包含 同步/异步请求 返回 string/泛型类型/Xml 及一个单例模式 的 SingleHelper 适合做爬虫
HttpClientPool demo
TrigonKing的博客
11-27 174
private PoolingHttpClientConnectionManager poolConnManager; private RequestConfig requestConfig; private CloseableHttpClient httpClient; /** * 配置http * @param httpRequestBase */ private static void config(HttpRequest...
HttpUtils带连接池
最新发布
高性价比服务器就选：蓝易云
04-05 221
是一个常用的HTTP请求工具类，主要用于发送HTTP请求和处理HTTP响应。在高并发的情况下，如果每次请求都新建一个连接，会导致系统资源的浪费，同时也会降低系统的性能。因此，我们需要使用连接池来管理HTTP连接，提高系统的性能。连接池的主要作用是重用已经建立的HTTP连接，避免了每次请求都需要创建和销毁连接的开销。连接池中的连接在使用后不会立即被关闭，而是返回到连接池中，供下一次请求使用。的实例，并设置了连接池的最大连接数和每个路由的最大连接数。带连接池的实现方式，希望对你有所帮助。
HttpClient工具类的使用
zhongyuan_p的博客
06-20 279
依赖注入 <!--起步依赖注意放外面--> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-parent</artifactId> <version>2.1.4.RELEASE</version> </parent> &
httpclient工具类,使用连接池实现，原理同数据库连接池。
Mr lebron的博客
11-15 3750
使用httpclient4.5实现。 注意事项: 1.user-agent最好不要乱写，百度一些放到文件，每次请求随机读取最好。 2.最好设置请求停顿时间，防止访问过快被封。 3.返回结果乱码请设置返回的数据的编码格式,默认utf8. 代码: package com.common.util; import java.io.IOException; import java.io
HttpClient Util 工具
weixin_33672400的博客
02-11 91
2019独角兽企业重金招聘Python工程师标准>>> ...
HttpClient接口调用工具类(附带demo)
11-28
HttpClient接口调用工具类 (Post请求 get请求 put请求 delete请求 下载就可以用 )
httpClientUtil工具类
01-31
httpClientUtil工具类
httpclient.java 工具类
04-23
httpclient.java 工具类
HttpClient工具类
05-23
HttpClient的工具类，用于发送get和post请求的工具类，数据类型可以使XML，JSON
httpclient4.3、httppool远程调用
goodlook0123的专栏
11-22 947
概述 http http客户端调用apachehttp工具包，基于httpclient4.3(org.apache.http.impl.client)开发，针对http请求相关业务需求进行封装。         在网络协议中，http协议属于应用层协议，主要聚焦在规范数据层面，定义报文规则，使接收方能正确解析和响应，而在应用层下面的传输层，主要聚焦数据传输层面，包括tcp、ftp协议。http...
HttpPoolUtils 连接池管理的GET POST请求
dianmenju7110的博客
07-04 374
1 package com.nextjoy.projects.usercenter.util.http; 2 3 import org.apache.http.Consts; 4 import org.apache.http.HttpEntity; 5 import org.apache.http.HttpHeaders; 6 import org...
最新Httpclient工具类
longtime的博客
09-24 332
最近找到一个比较完善且api比较新的一个工具类,可以试试用着 import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.NameValuePair; import org.apache.http.client.ClientProtocolException; im...
HttpClient pool连接池
qing_mei_xiu的博客
05-11 7134
场景： 高并发情况下，为了提高http请求效率，加入http 连接池，减少3次握手次数，提高请求效率 import org.apache.http.*; import org.apache.http.client.HttpRequestRetryHandler; import org.apache.http.client.config.RequestConfig; import org....
HttpClient连接池管理
zhaokuner的专栏
12-20 1020
@Configuration @EnableConfigurationProperties(HttpClientProperties.class) @ConditionalOnProperty(prefix = "myserver.httpclient", value = "enabled", havingValue = "true") public class HttpClientConfig { @Autowired HttpClientProperties httpClientPro
httpclientPool连接池
谢萌新
10-28 880
自定义HttpClientPool
HttpClient高并发-httpClient连接池
热门推荐
半路凉亭
05-23 1万+
我们项目中有一功能是用于加载静态考试问卷文件，以前一直使用的是用ajax加载静态文件方式，此方式使用的好处是比较简单，服务器也没太大的运行压力，但是也有明显的不足，例如存在跨域问题，还有文件的路径会在代码中明文显示，虽然可以加密，但是由于是前端的，对于技术人员破译也没什么难度，安全性很低。 最近就想把问卷文件加载方式给成后台获取，然后返回给前台显示，方式还是通过AJAX异步加载，这样修改后，至少...
使用HttpClient发起请求调用接口
qq_34288595的博客
03-28 298
使用HttpClient发起请求调用接口
httpclient 文件上传工具类
05-17
以下是一个示例的 HttpClient 文件上传工具类，可以帮助你上传文件： ```java import java.io.File; import java.io.IOException; import java.nio.charset.StandardCharsets; import org.apache.commons.io....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值