httpclient的使用

柔光的暖阳◎ 2022-02-01 07:09 273阅读 0赞

HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和协议。  
官方站点：[http://hc.apache.org/][http_hc.apache.org]  
最新版本4.5 [http://hc.apache.org/httpcomponents-client-4.5.x/][http_hc.apache.org_httpcomponents-client-4.5.x]  
官方文档： [http://hc.apache.org/httpcomponents-client-4.5.x/tutorial/html/index.html][http_hc.apache.org_httpcomponents-client-4.5.x_tutorial_html_index.html]  
1 依赖jar包

<dependency>
          <groupId>org.apache.httpcomponents</groupId>
          <artifactId>httpclient</artifactId>
          <version>4.5.3</version>
        </dependency>
        <dependency>
          <groupId>org.apache.httpcomponents</groupId>
          <artifactId>httpcore</artifactId>
          <version>4.4.6</version>
        </dependency>
        <dependency>
          <groupId>org.apache.httpcomponents</groupId>
          <artifactId>httpmime</artifactId>
          <version>4.5.3</version>
        </dependency>

2 程序配置

import org.apache.http.HttpEntityEnclosingRequest;
    import org.apache.http.HttpHost;
    import org.apache.http.HttpRequest;
    import org.apache.http.NoHttpResponseException;
    import org.apache.http.client.HttpRequestRetryHandler;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.client.protocol.HttpClientContext;
    import org.apache.http.config.Registry;
    import org.apache.http.config.RegistryBuilder;
    import org.apache.http.conn.ConnectTimeoutException;
    import org.apache.http.conn.routing.HttpRoute;
    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.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    import org.apache.http.protocol.HttpContext;
    
    import javax.net.ssl.SSLException;
    import javax.net.ssl.SSLHandshakeException;
    import java.io.IOException;
    import java.io.InterruptedIOException;
    import java.net.UnknownHostException;
    
    /**
     * org.apache.http.impl.client.CloseableHttpClient链接池生成工具
     * @reference http://www.cnblogs.com/whatlonelytear/articles/4835538.html
     * @author King
     * @date 20170601
     */
    public class HttpClientConfig {
    
        // org.apache.http.impl.client.CloseableHttpClient
        private static CloseableHttpClient httpclient = null;
    
        // 这里就直接默认固定了,因为以下三个参数在新建的method中仍然可以重新配置并被覆盖.
        static final int connectionRequestTimeout = 5000;// ms毫秒,从池中获取链接超时时间
        static final int connectTimeout = 5000;// ms毫秒,建立链接超时时间
        static final int socketTimeout = 30000;// ms毫秒,读取超时时间
    
        // 总配置,主要涉及是以下两个参数,如果要作调整没有用到properties会比较后麻烦,但鉴于一经粘贴,随处可用的特点,就不再做依赖性配置化处理了.
        // 而且这个参数同一家公司基本不会变动.
        static final int maxTotal = 500;// 最大总并发,很重要的参数
        static final int maxPerRoute = 100;// 每路并发,很重要的参数
    
        // 正常情况这里应该配成MAP或LIST
        // 细化配置参数,用来对每路参数做精细化处理,可以管控各ip的流量,比如默认配置请求baidu:80端口最大100个并发链接,
        static final String detailHostName = "http://www.baidu.com";// 每个细化配置之ip(不重要,在特殊场景很有用)
        static final int detailPort = 80;// 每个细化配置之port(不重要,在特殊场景很有用)
        static final int detailMaxPerRoute = 100;// 每个细化配置之最大并发数(不重要,在特殊场景很有用)
    
        public static CloseableHttpClient getHttpClient() {
            if (null == httpclient) {
                synchronized (HttpClientConfig.class) {
                    if (null == httpclient) {
                        httpclient = init();
                    }
                }
            }
            return httpclient;
        }
    
        /**
         * 链接池初始化 这里最重要的一点理解就是. 让CloseableHttpClient 一直活在池的世界里, 但是HttpPost却一直用完就消掉.
         * 这样可以让链接一直保持着.
         *
         * @return
         */
        private static CloseableHttpClient init() {
            CloseableHttpClient newHttpclient = null;
    
            // 设置连接池
            ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
            LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create().register("http", plainsf).register("https", sslsf).build();
            PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
            // 将最大连接数增加
            cm.setMaxTotal(maxTotal);
            // 将每个路由基础的连接增加
            cm.setDefaultMaxPerRoute(maxPerRoute);
    
            // 细化配置开始,其实这里用Map或List的for循环来配置每个链接,在特殊场景很有用.
            // 将每个路由基础的连接做特殊化配置,一般用不着
            HttpHost httpHost = new HttpHost(detailHostName, detailPort);
            // 将目标主机的最大连接数增加
            cm.setMaxPerRoute(new HttpRoute(httpHost), detailMaxPerRoute);
            // cm.setMaxPerRoute(new HttpRoute(httpHost2),
            // detailMaxPerRoute2);//可以有细化配置2
            // cm.setMaxPerRoute(new HttpRoute(httpHost3),
            // detailMaxPerRoute3);//可以有细化配置3
            // 细化配置结束
    
            // 请求重试处理
            HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {
                public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
                    if (executionCount >= 2) {// 如果已经重试了2次，就放弃
                        return false;
                    }
                    if (exception instanceof NoHttpResponseException) {// 如果服务器丢掉了连接，那么就重试
                        return true;
                    }
                    if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常
                        return false;
                    }
                    if (exception instanceof InterruptedIOException) {// 超时
                        return false;
                    }
                    if (exception instanceof UnknownHostException) {// 目标服务器不可达
                        return false;
                    }
                    if (exception instanceof ConnectTimeoutException) {// 连接被拒绝
                        return false;
                    }
                    if (exception instanceof SSLException) {// SSL握手异常
                        return false;
                    }
    
                    HttpClientContext clientContext = HttpClientContext.adapt(context);
                    HttpRequest request = clientContext.getRequest();
                    // 如果请求是幂等的，就再次尝试
                    if (!(request instanceof HttpEntityEnclosingRequest)) {
                        return true;
                    }
                    return false;
                }
            };
    
            // 配置请求的超时设置
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectionRequestTimeout).setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout).build();
            newHttpclient = HttpClients.custom().setConnectionManager(cm).setDefaultRequestConfig(requestConfig).setRetryHandler(httpRequestRetryHandler).build();
            return newHttpclient;
        }
    }

3 工具类

import org.apache.http.HttpEntity;
    import org.apache.http.NameValuePair;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.client.methods.HttpUriRequest;
    import org.apache.http.client.methods.RequestBuilder;
    import org.apache.http.entity.ContentType;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.entity.mime.MultipartEntityBuilder;
    import org.apache.http.entity.mime.content.FileBody;
    import org.apache.http.entity.mime.content.StringBody;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    
    import java.io.File;
    import java.io.IOException;
    import java.nio.charset.Charset;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    public class HttpClientUtil {
    
        public static CloseableHttpClient getConnection() {
             // 默认的Http客户端连接
            // CloseableHttpClient httpClient = HttpClients.createDefault();
            // 从连接池中获取
            CloseableHttpClient httpClient = HttpClientConfig.getHttpClient();
            return httpClient;
        }
    
        public static CloseableHttpResponse getOrPostRequest(Map<String, String> map, String url, String method) throws IOException {
            List<NameValuePair> params = new ArrayList<NameValuePair>();
            Set<Map.Entry<String, String>> entrySet = map.entrySet();
            for (Map.Entry<String, String> e : entrySet) {
                String name = e.getKey();
                String value = e.getValue();
                NameValuePair pair = new BasicNameValuePair(name, value);
                params.add(pair);
            }
            UrlEncodedFormEntity uefEntity = new UrlEncodedFormEntity(params, "UTF-8");
            HttpUriRequest reqMethod = null;
            if ("post".equals(method)) {
                reqMethod = RequestBuilder.post().setUri(url)
                        .setEntity(uefEntity)
                        .build();
            } else if ("get".equals(method)) {
                reqMethod = RequestBuilder.get().setUri(url)
                        .setEntity(uefEntity)
                        .build();
            }
            CloseableHttpClient client = getConnection();
            CloseableHttpResponse response = client.execute(reqMethod);
            response.close();
            client.close();
            return response;
        }
    
        public static CloseableHttpResponse soapRequest(String url,String sRequest) throws IOException {
            StringBuffer soapRequestData = new StringBuffer();
            soapRequestData.append("<soapenv:Envelope");
            soapRequestData.append("  xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" ");
            soapRequestData.append("  xmlns:prov=\"http://provider.webservice.zsins.dtt.com/\">");
            soapRequestData.append(" <soapenv:Header/> ");
            soapRequestData.append("<soapenv:Body>");
            soapRequestData.append("<prov:executePrvPricing>");
            soapRequestData.append("<arg0>");
            soapRequestData.append("<![CDATA[" + sRequest + "]]>");
            soapRequestData.append("</arg0>");
            soapRequestData.append("</prov:executePrvPricing>");
            soapRequestData.append(" </soapenv:Body>");
            soapRequestData.append("</soapenv:Envelope>");
    
            CloseableHttpClient client = getConnection();
            HttpPost httppost = new HttpPost(url);
            StringEntity content =new StringEntity(soapRequestData.toString(), Charset.forName("UTF-8"));// 第二个参数，设置后才会对，内容进行编码
            content.setContentType("application/soap+xml; charset=UTF-8");
            content.setContentEncoding("UTF-8");
            httppost.setEntity(content);
            CloseableHttpResponse response = client.execute(httppost);
            response.close();
            client.close();
            return response;
        }
    
        public static CloseableHttpResponse uploadRequest(String url,String filePath) throws IOException {
            HttpPost httppost = new HttpPost(url);
            FileBody bin = new FileBody(new File(filePath));
            StringBody comment = new StringBody("A binary file of some kind", ContentType.TEXT_PLAIN);
            HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("bin", bin).addPart("comment", comment).build();
            httppost.setEntity(reqEntity);
            CloseableHttpClient client = getConnection();
            CloseableHttpResponse response = client.execute(httppost);
            response.close();
            client.close();
            return response;
        }
    
        public static void main(String args[]) throws IOException {
            Map<String, String> map = new HashMap<String, String>();
            map.put("account", "");
            map.put("password", "");
            CloseableHttpResponse response = getOrPostRequest(map, "http://cnivi.com.cn/login", "post");
            if (response.getStatusLine().getStatusCode() == 200) {
                HttpEntity entity = response.getEntity();
                String message = EntityUtils.toString(entity, "utf-8");
                System.out.println(message);
            } else {
                System.out.println("请求失败");
            }
        }
    }

文章来源:  
[https://blog.csdn.net/zhuwukai/article/details/78644484][https_blog.csdn.net_zhuwukai_article_details_78644484]

[http_hc.apache.org]: http://hc.apache.org/
[http_hc.apache.org_httpcomponents-client-4.5.x]: http://hc.apache.org/httpcomponents-client-4.5.x/
[http_hc.apache.org_httpcomponents-client-4.5.x_tutorial_html_index.html]: http://hc.apache.org/httpcomponents-client-4.5.x/tutorial/html/index.html
[https_blog.csdn.net_zhuwukai_article_details_78644484]: https://blog.csdn.net/zhuwukai/article/details/78644484