httpclient 参数详解

最新推荐文章于 2023-02-10 23:26:46 发布
转载 最新推荐文章于 2023-02-10 23:26:46 发布 · 3.7k 阅读 · 0

本文介绍 HttpClient4 的连接池配置方法，包括最大连接数、获取连接的最大等待时间等关键参数，并解释了路由概念及每个路由最大连接数的重要性。

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

  3. <SPAN style="FONT-WEIGHT: normal">package xiaogang.enif.net;  
  4.   
  5.   
  6. import java.io.IOException;  
  7. import java.net.Socket;  
  8. import java.net.UnknownHostException;  
  9. import java.security.KeyManagementException;  
  10. import java.security.KeyStore;  
  11. import java.security.KeyStoreException;  
  12. import java.security.NoSuchAlgorithmException;  
  13. import java.security.UnrecoverableKeyException;  
  14. import java.security.cert.CertificateException;  
  15. import java.security.cert.X509Certificate;  
  16.   
  17.   
  18. import javax.net.ssl.SSLContext;  
  19. import javax.net.ssl.TrustManager;  
  20. import javax.net.ssl.X509TrustManager;  
  21.   
  22.   
  23. import org.apache.http.HttpHost;  
  24. import org.apache.http.HttpResponse;  
  25. import org.apache.http.HttpVersion;  
  26. import org.apache.http.client.methods.HttpGet;  
  27. import org.apache.http.client.methods.HttpHead;  
  28. import org.apache.http.client.methods.HttpPost;  
  29. import org.apache.http.client.methods.HttpUriRequest;  
  30. import org.apache.http.client.params.HttpClientParams;  
  31. import org.apache.http.conn.ClientConnectionManager;  
  32. import org.apache.http.conn.params.ConnManagerParams;  
  33. import org.apache.http.conn.params.ConnPerRouteBean;  
  34. import org.apache.http.conn.params.ConnRouteParams;  
  35. import org.apache.http.conn.scheme.PlainSocketFactory;  
  36. import org.apache.http.conn.scheme.Scheme;  
  37. import org.apache.http.conn.scheme.SchemeRegistry;  
  38. import org.apache.http.conn.ssl.SSLSocketFactory;  
  39. import org.apache.http.impl.client.DefaultHttpClient;  
  40. import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;  
  41. import org.apache.http.params.BasicHttpParams;  
  42. import org.apache.http.params.HttpConnectionParams;  
  43. import org.apache.http.params.HttpParams;  
  44. import org.apache.http.params.HttpProtocolParams;  
  45.   
  46.   
  47. import xiaogang.enif.utils.IOUtils;  
  48.   
  49.   
  50. import android.content.Context;  
  51. import android.net.Proxy;  
  52. import android.text.TextUtils;  
  53.   
  54.   
  55.   
  56.   
  57. public class HttpManager {  
  58.     private static final int DEFAULT_MAX_CONNECTIONS = 30;  
  59.     private static final int DEFAULT_SOCKET_TIMEOUT = 20 * 1000;  
  60.     private static final int DEFAULT_SOCKET_BUFFER_SIZE = 8192;  
  61.   
  62.   
  63.     private static DefaultHttpClient sHttpClient;  
  64.     static {  
  65.         final HttpParams httpParams = new BasicHttpParams();  
  66.   
  67.   
  68.         ConnManagerParams.setTimeout(httpParams, 1000);  
  69.         ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(10));  
  70.         ConnManagerParams.setMaxTotalConnections(httpParams, DEFAULT_MAX_CONNECTIONS);  
  71.   
  72.   
  73.         HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);  
  74.         HttpProtocolParams.setContentCharset(httpParams, "UTF-8");  
  75.         HttpConnectionParams.setStaleCheckingEnabled(httpParams, false);  
  76.         HttpClientParams.setRedirecting(httpParams, false);  
  77.         HttpProtocolParams.setUserAgent(httpParams, "Android client");  
  78.         HttpConnectionParams.setSoTimeout(httpParams, DEFAULT_SOCKET_TIMEOUT);  
  79.         HttpConnectionParams.setConnectionTimeout(httpParams, DEFAULT_SOCKET_TIMEOUT);  
  80.         HttpConnectionParams.setTcpNoDelay(httpParams, true);  
  81.         HttpConnectionParams.setSocketBufferSize(httpParams, DEFAULT_SOCKET_BUFFER_SIZE);  
  82.   
  83.   
  84.         SchemeRegistry schemeRegistry = new SchemeRegistry();  
  85.         schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));  
  86.         try {  
  87.             KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());  
  88.             trustStore.load(null, null);  
  89.             SSLSocketFactory sf = new MySSLSocketFactory(trustStore);  
  90.             sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);  
  91.             schemeRegistry.register(new Scheme("https", sf, 443));  
  92.         } catch (Exception ex) {  
  93.             // do nothing, just keep not crash   
  94.         }  
  95.   
  96.   
  97.         ClientConnectionManager manager = new ThreadSafeClientConnManager(httpParams, schemeRegistry);  
  98.         sHttpClient = new DefaultHttpClient(manager, httpParams);  
  99.     }  
  100.   
  101.   
  102.     private HttpManager() {  
  103.     }  
  104.   
  105.   
  106.     public static HttpResponse execute(HttpHead head) throws IOException {  
  107.         return sHttpClient.execute(head);  
  108.     }  
  109.   
  110.   
  111.     public static HttpResponse execute(HttpHost host, HttpGet get) throws IOException {  
  112.         return sHttpClient.execute(host, get);  
  113.     }  
  114.   
  115.   
  116.     public static HttpResponse execute(Context context, HttpGet get) throws IOException {  
  117.         if (!IOUtils.isWifiAvailable(context) && isWapNetwork()) {  
  118.             setWapProxy();  
  119.             return sHttpClient.execute(get);  
  120.         }  
  121.   
  122.   
  123.         final HttpHost host = (HttpHost)sHttpClient.getParams().getParameter(  
  124.                 ConnRouteParams.DEFAULT_PROXY);  
  125.         if (host != null) {  
  126.             sHttpClient.getParams().removeParameter(ConnRouteParams.DEFAULT_PROXY);  
  127.         }  
  128.   
  129.   
  130.         return sHttpClient.execute(get);  
  131.     }  
  132.   
  133.   
  134.     private static void setSinaWapProxy() {  
  135.         final HttpHost para = (HttpHost)sHttpClient.getParams().getParameter(  
  136.                 ConnRouteParams.DEFAULT_PROXY);  
  137.         if (para != null) {  
  138.             sHttpClient.getParams().removeParameter(ConnRouteParams.DEFAULT_PROXY);  
  139.         }  
  140.         String host = Proxy.getDefaultHost();  
  141.         int port = Proxy.getDefaultPort();  
  142.         HttpHost httpHost = new HttpHost(host, port);  
  143.         HttpParams httpParams = new BasicHttpParams();  
  144.         httpParams.setParameter(ConnRouteParams.DEFAULT_PROXY, httpHost);  
  145.     }  
  146.   
  147.   
  148.     public static HttpResponse execute(Context context, HttpUriRequest post) throws IOException {  
  149.         if (!IOUtils.isWifiAvailable(context) && isWapNetwork()) {  
  150.             setSinaWapProxy();  
  151.         }  
  152.         return sHttpClient.execute(post);  
  153.     }  
  154.   
  155.   
  156.     public static HttpResponse execute(Context context, HttpPost post) throws IOException {  
  157.         if (!IOUtils.isWifiAvailable(context) && isWapNetwork()) {  
  158.             setWapProxy();  
  159.             return sHttpClient.execute(post);  
  160.         }  
  161.   
  162.   
  163.         final HttpHost host = (HttpHost)sHttpClient.getParams().getParameter(  
  164.                 ConnRouteParams.DEFAULT_PROXY);  
  165.         if (host != null) {  
  166.             sHttpClient.getParams().removeParameter(ConnRouteParams.DEFAULT_PROXY);  
  167.         }  
  168.         return sHttpClient.execute(post);  
  169.     }  
  170.   
  171.   
  172.     private static boolean isWapNetwork() {  
  173.         final String proxyHost = android.net.Proxy.getDefaultHost();  
  174.         return !TextUtils.isEmpty(proxyHost);  
  175.     }  
  176.   
  177.   
  178.     private static void setWapProxy() {  
  179.         final HttpHost host = (HttpHost)sHttpClient.getParams().getParameter(  
  180.                 ConnRouteParams.DEFAULT_PROXY);  
  181.         if (host == null) {  
  182.             final String host1 = Proxy.getDefaultHost();  
  183.             int port = Proxy.getDefaultPort();  
  184.             HttpHost httpHost = new HttpHost(host1, port);  
  185.             sHttpClient.getParams().setParameter(ConnRouteParams.DEFAULT_PROXY, httpHost);  
  186.         }  
  187.     }  
  188.   
  189.   
  190.     private static class MySSLSocketFactory extends SSLSocketFactory {  
  191.         SSLContext sslContext = SSLContext.getInstance("TLS");  
  192.   
  193.   
  194.         public MySSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException,  
  195.         KeyManagementException, KeyStoreException, UnrecoverableKeyException {  
  196.             super(truststore);  
  197.   
  198.   
  199.             TrustManager tm = new X509TrustManager() {  
  200.                 @Override  
  201.                 public void checkClientTrusted(X509Certificate[] chain, String authType)  
  202.                         throws CertificateException {  
  203.                 }  
  204.   
  205.   
  206.                 @Override  
  207.                 public void checkServerTrusted(X509Certificate[] chain, String authType)  
  208.                         throws CertificateException {  
  209.                 }  
  210.   
  211.   
  212.                 @Override  
  213.                 public X509Certificate[] getAcceptedIssuers() {  
  214.                     return null;  
  215.                 }  
  216.             };  
  217.   
  218.   
  219.             sslContext.init(null, new TrustManager[] {  
  220.                     tm  
  221.             }, null);  
  222.         }  
  223.   
  224.   
  225.         @Override  
  226.         public Socket createSocket(Socket socket, String host, int port, boolean autoClose)  
  227.                 throws IOException, UnknownHostException {  
  228.             return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);  
  229.         }  
  230.   
  231.   
  232.         @Override  
  233.         public Socket createSocket() throws IOException {  
  234.             return sslContext.getSocketFactory().createSocket();  
  235.         }  
  236.     }  
  237. }</SPAN>  
package xiaogang.enif.net;


import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;


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


import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpHead;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.params.HttpClientParams;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.params.ConnPerRouteBean;
import org.apache.http.conn.params.ConnRouteParams;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;


import xiaogang.enif.utils.IOUtils;


import android.content.Context;
import android.net.Proxy;
import android.text.TextUtils;




public class HttpManager {
    private static final int DEFAULT_MAX_CONNECTIONS = 30;
    private static final int DEFAULT_SOCKET_TIMEOUT = 20 * 1000;
    private static final int DEFAULT_SOCKET_BUFFER_SIZE = 8192;


    private static DefaultHttpClient sHttpClient;
    static {
        final HttpParams httpParams = new BasicHttpParams();


        ConnManagerParams.setTimeout(httpParams, 1000);
        ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(10));
        ConnManagerParams.setMaxTotalConnections(httpParams, DEFAULT_MAX_CONNECTIONS);


        HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(httpParams, "UTF-8");
        HttpConnectionParams.setStaleCheckingEnabled(httpParams, false);
        HttpClientParams.setRedirecting(httpParams, false);
        HttpProtocolParams.setUserAgent(httpParams, "Android client");
        HttpConnectionParams.setSoTimeout(httpParams, DEFAULT_SOCKET_TIMEOUT);
        HttpConnectionParams.setConnectionTimeout(httpParams, DEFAULT_SOCKET_TIMEOUT);
        HttpConnectionParams.setTcpNoDelay(httpParams, true);
        HttpConnectionParams.setSocketBufferSize(httpParams, DEFAULT_SOCKET_BUFFER_SIZE);


        SchemeRegistry schemeRegistry = new SchemeRegistry();
        schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
        try {
            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            trustStore.load(null, null);
            SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
            sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            schemeRegistry.register(new Scheme("https", sf, 443));
        } catch (Exception ex) {
            // do nothing, just keep not crash
        }


        ClientConnectionManager manager = new ThreadSafeClientConnManager(httpParams, schemeRegistry);
        sHttpClient = new DefaultHttpClient(manager, httpParams);
    }


    private HttpManager() {
    }


    public static HttpResponse execute(HttpHead head) throws IOException {
        return sHttpClient.execute(head);
    }


    public static HttpResponse execute(HttpHost host, HttpGet get) throws IOException {
        return sHttpClient.execute(host, get);
    }


    public static HttpResponse execute(Context context, HttpGet get) throws IOException {
        if (!IOUtils.isWifiAvailable(context) && isWapNetwork()) {
            setWapProxy();
            return sHttpClient.execute(get);
        }


        final HttpHost host = (HttpHost)sHttpClient.getParams().getParameter(
                ConnRouteParams.DEFAULT_PROXY);
        if (host != null) {
            sHttpClient.getParams().removeParameter(ConnRouteParams.DEFAULT_PROXY);
        }


        return sHttpClient.execute(get);
    }


    private static void setSinaWapProxy() {
        final HttpHost para = (HttpHost)sHttpClient.getParams().getParameter(
                ConnRouteParams.DEFAULT_PROXY);
        if (para != null) {
            sHttpClient.getParams().removeParameter(ConnRouteParams.DEFAULT_PROXY);
        }
        String host = Proxy.getDefaultHost();
        int port = Proxy.getDefaultPort();
        HttpHost httpHost = new HttpHost(host, port);
        HttpParams httpParams = new BasicHttpParams();
        httpParams.setParameter(ConnRouteParams.DEFAULT_PROXY, httpHost);
    }


    public static HttpResponse execute(Context context, HttpUriRequest post) throws IOException {
        if (!IOUtils.isWifiAvailable(context) && isWapNetwork()) {
            setSinaWapProxy();
        }
        return sHttpClient.execute(post);
    }


    public static HttpResponse execute(Context context, HttpPost post) throws IOException {
        if (!IOUtils.isWifiAvailable(context) && isWapNetwork()) {
            setWapProxy();
            return sHttpClient.execute(post);
        }


        final HttpHost host = (HttpHost)sHttpClient.getParams().getParameter(
                ConnRouteParams.DEFAULT_PROXY);
        if (host != null) {
            sHttpClient.getParams().removeParameter(ConnRouteParams.DEFAULT_PROXY);
        }
        return sHttpClient.execute(post);
    }


    private static boolean isWapNetwork() {
        final String proxyHost = android.net.Proxy.getDefaultHost();
        return !TextUtils.isEmpty(proxyHost);
    }


    private static void setWapProxy() {
        final HttpHost host = (HttpHost)sHttpClient.getParams().getParameter(
                ConnRouteParams.DEFAULT_PROXY);
        if (host == null) {
            final String host1 = Proxy.getDefaultHost();
            int port = Proxy.getDefaultPort();
            HttpHost httpHost = new HttpHost(host1, port);
            sHttpClient.getParams().setParameter(ConnRouteParams.DEFAULT_PROXY, httpHost);
        }
    }


    private static class MySSLSocketFactory extends SSLSocketFactory {
        SSLContext sslContext = SSLContext.getInstance("TLS");


        public MySSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException,
        KeyManagementException, KeyStoreException, UnrecoverableKeyException {
            super(truststore);


            TrustManager tm = new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] chain, String authType)
                        throws CertificateException {
                }


                @Override
                public void checkServerTrusted(X509Certificate[] chain, String authType)
                        throws CertificateException {
                }


                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
            };


            sslContext.init(null, new TrustManager[] {
                    tm
            }, null);
        }


        @Override
        public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
                throws IOException, UnknownHostException {
            return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
        }


        @Override
        public Socket createSocket() throws IOException {
            return sslContext.getSocketFactory().createSocket();
        }
    }
}


在一次服务器异常的排查过程当中（服务器异常排查的过程我会另起文章），我们决定使用HttpClient4.X替代HttpClient3.X或者HttpConnection。

为什么使用HttpClient4？主要是HttpConnection没有连接池的概念，多少次请求就会建立多少个IO，在访问量巨大的情况下服务器的IO可能会耗尽。

HttpClient3也有连接池的东西在里头，使用MultiThreadedHttpConnectionManager，大致过程如下：

view plainprint?

MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();  

HttpClient client = new HttpClient(connectionManager);...// 在某个线程中。  

GetMethod get = new GetMethod("http://jakarta.apache.org/");  

try {  

client.executeMethod(get);// print response to stdout  

System.out.println(get.getResponseBodyAsStream());  

} finally {  

// be sure the connection is released back to the connection   

managerget.releaseConnection();  

}  

 

可以看出来，它的方式与jdbc连接池的使用方式相近，我觉得比较不爽的就是需要手动调用releaseConnection去释放连接。对每一个HttpClient.executeMethod须有一个method.releaseConnection()与之匹配。

 

HttpClient4在这点上做了改进，使用我们常用的InputStream.close()来确认连接关闭（4.1版本之前使用entity.consumeContent()来确认内容已经被消耗关闭连接）。具体方式如下：

view plainprint?

...HttpClient client = null;InputStream in = null;  

try{  

client = HttpConnectionManager.getHttpClient();  

HttpGet get = new HttpGet();  

get.setURI(new URI(urlPath));  

HttpResponse response = client.execute(get);  

HttpEntity entity =response.getEntity();  

if( entity != null ){   

 in = entity.getContent();  

 ....  

}catch (Exception e){  

....  

}finally{  

if (in != null){  

try{in.close ();}catch (IOException e){  

e.printStackTrace ();  

}  

}  

}  

 

好说完了连接池的使用流程，现在来说一说连接池在使用时最重要的几个参数。我用4.1的版本实现了一个简单的HttpConnectionManager，代码如下：

view plainprint?

public class HttpConnectionManager {   

  

    private static HttpParams httpParams;  

    private static ClientConnectionManager connectionManager;  

  

    /** 

     * 最大连接数 

     */  

    public final static int MAX_TOTAL_CONNECTIONS = 800;  

    /** 

     * 获取连接的最大等待时间 

     */  

    public final static int WAIT_TIMEOUT = 60000;  

    /** 

     * 每个路由最大连接数 

     */  

    public final static int MAX_ROUTE_CONNECTIONS = 400;  

    /** 

     * 连接超时时间 

     */  

    public final static int CONNECT_TIMEOUT = 10000;  

    /** 

     * 读取超时时间 

     */  

    public final static int READ_TIMEOUT = 10000;  

  

    static {  

        httpParams = new BasicHttpParams();  

        // 设置最大连接数  

        ConnManagerParams.setMaxTotalConnections(httpParams, MAX_TOTAL_CONNECTIONS);  

        // 设置获取连接的最大等待时间  

        ConnManagerParams.setTimeout(httpParams, WAIT_TIMEOUT);  

        // 设置每个路由最大连接数  

        ConnPerRouteBean connPerRoute = new ConnPerRouteBean(MAX_ROUTE_CONNECTIONS);  

        ConnManagerParams.setMaxConnectionsPerRoute(httpParams,connPerRoute);  

        // 设置连接超时时间  

        HttpConnectionParams.setConnectionTimeout(httpParams, CONNECT_TIMEOUT);  

        // 设置读取超时时间  

        HttpConnectionParams.setSoTimeout(httpParams, READ_TIMEOUT);  

  

        SchemeRegistry registry = new SchemeRegistry();  

        registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));  

        registry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));  

  

        connectionManager = new ThreadSafeClientConnManager(httpParams, registry);  

    }  

  

    public static HttpClient getHttpClient() {  

        return new DefaultHttpClient(connectionManager, httpParams);  

    }  

  

}  

 

最大连接数、获取连接的最大等待时间、读取超时时间 这些配置应该比较容易理解，一般的连接池都会有这些配置，比较特别的是 每个路由(route)最大连接数 。

 

什么是一个route？

 

这里route的概念可以理解为 运行环境机器 到 目标机器的一条线路。举例来说，我们使用HttpClient的实现来分别请求 www.baidu.com 的资源和 www.bing.com 的资源那么他就会产生两个route。

 

这 里为什么要特别提到route最大连接数这个参数呢，因为这个参数的默认值为2，如果不设置这个参数值默认情况下对于同一个目标机器的最大并发连接只有2 个！这意味着如果你正在执行一个针对某一台目标机器的抓取任务的时候，哪怕你设置连接池的最大连接数为200，但是实际上还是只有2个连接在工作，其他剩 余的198个连接都在等待，都是为别的目标机器服务的。

 

怎么样蛋疼吧，我是已经有过血的教训了，在切换到HttpClient4.1的起初没有注意到这个配置，最后使得服务承受的压力反而不如从前了，所以在这里特别提醒大家注意。

 

HttpClient4.X 教程下载：

http://svn.apache.org/repos/asf/httpcomponents/httpclient/trunk/httpclient-contrib/docs/translated-tutorial/httpclient-tutorial-simplified-chinese.pdf

 

关于版本的补充：

网友w2449008821提醒之后我才发现在HttpClient4.1+的版本ConnManagerParams已经被Deprecated了。

我在写这篇日志的时候时候的httpclient 版本是4.0.3，从4.0版本之后ConnManagerParams被Deprecated，没想到一个小版本升级会有这么大变化。

官网教程举例了新的连接池设置：

view plainprint?

SchemeRegistry schemeRegistry = new SchemeRegistry();  

schemeRegistry.register(  

         new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));  

schemeRegistry.register(  

         new Scheme("https", 443, SSLSocketFactory.getSocketFactory()));  

  

ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(schemeRegistry);  

// Increase max total connection to 200  

cm.setMaxTotalConnections(200);  

// Increase default max connection per route to 20  

cm.setDefaultMaxPerRoute(20);  

// Increase max connections for localhost:80 to 50  

HttpHost localhost = new HttpHost("locahost", 80);  

cm.setMaxForRoute(new HttpRoute(localhost), 50);  

   

HttpClient httpClient = new DefaultHttpClient(cm);  

ConnManagerParams的功能被挪到了 ThreadSafeClientConnManager 和 HttpConnectionParams两个类：

static ConnPerRoutegetMaxConnectionsPerRoute(HttpParams params) 

          Deprecated. use ThreadSafeClientConnManager.getMaxForRoute(org.apache.http.conn.routing.HttpRoute)

static intgetMaxTotalConnections(HttpParams params) 

          Deprecated. use ThreadSafeClientConnManager.getMaxTotal()

static longgetTimeout(HttpParams params) 

          Deprecated. use HttpConnectionParams.getConnectionTimeout(HttpParams)

static voidsetMaxConnectionsPerRoute(HttpParams params, ConnPerRoute connPerRoute) 

          Deprecated. use ThreadSafeClientConnManager.setMaxForRoute(org.apache.http.conn.routing.HttpRoute, int)

static voidsetMaxTotalConnections(HttpParams params, int maxTotalConnections) 

          Deprecated. use ThreadSafeClientConnManager.setMaxTotal(int)

static voidsetTimeout(HttpParams params, long timeout) 

          Deprecated. use HttpConnectionParams.setConnectionTimeout(HttpParams, int)



 


 


 


 


 

HttpClient 4：

连接超时：

?
httpclient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 60000 );
// 或者
HttpConnectionParams.setConnectionTimeout(params, 6000 );

读取超时：

?
httpclient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 60000 );
// 或者
HttpConnectionParams.setSoTimeout(params, 60000 );

HttpClient 3：

连接超时：

?
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout( 60000 );

读取超时：

?
httpClient.getHttpConnectionManager().getParams().setSoTimeout( 60000 );
HttpClient使用详解
jdk_wangtaida的博客
03-08 1893
前言： 在工作中我们会经常碰到调用别的系统接口的问题，如果是http接口的话，我们一般会选择使用HttpClient的来进行接口的调用。这篇文章就讲解下如何使用HttpClient调用别人的接口，主要从两个方面，第一种参数是map格式(post,get请求)，第二种参数是json格式（psot,get请求）来展开讲解。 正文： 一、什么是HttpClient? 百度百科解释：HttpCli...
HttpClient完整实例(普通参数、JSON格式参数)
08-09
使用HttpClient发送POST请求，并解析响应，发送参数可以是普通参数或JSON格式参数。
httpclient参数配置
weixin_34383618的博客
08-21 1134
序 这里简单解释一下httpclient一些关键参数的配置 超时时间 final RequestConfig requestConfig = RequestConfig.custom() .setSocketTimeout(SOCKET_TIMEOUT) .setConnec...
Httpclient 参数
艾瑞克同学
10-24 321
来自: http://jinnianshilongnian.iteye.com/blog/2089792单一目标最大线程数:
HttpClient之参数设置
热门推荐
Haiwi-Song
05-20 1万+
HttpClient中的参数设置主要包括：请求头Header，响应头Header、主机配置信息、及管理连接的参数设置。     包org.apache.commons.httpclient.params中的各个类用于HttpClient整个调用过程中参数的设置，开发者直接调用使用的包括HttpConnectionManagerParams、HttpClientParams、HostParams。
HttpClient 4.3连接池参数配置及源码解读
每天进步一点点
11-12 910
本文转自https://www.cnblogs.com/trust-freedom/p/6349502.html 目前所在公司使用HttpClient 4.3.3版本发送Rest请求，调用接口。最近出现了调用查询接口服务慢的生产问题，在排查整个调用链可能存在的问题时（从客户端发起Http请求->ESB->服务端处理请求，查询数据并返回），发现原本的HttpClient连接池中的...
HttpClient基础解析
08-29
例如，我们可以通过以下方式发送一个GET请求： CloseableHttpClient httpclient = HttpClients.createDefault(); HttpGet httpget = new HttpGet("https://example.com/"); CloseableHttpResponse response = ...
httpclient使用详解共8页.pdf.zip
10-29
《HttpClient使用详解》 HttpClient是Apache软件基金会的 HttpClient项目提供的一款强大的HTTP客户端工具，它允许开发者在Java应用程序中实现复杂的HTTP通信。这份8页的PDF文档深入解析了HttpClient的使用方法，...
httpclient 连接参数
weixin_34409741的博客
04-14 796
http.socket.timeout(读取超时) 套接字毫秒级超时时间(SO_TIMEOUT),这就是等待数据，换句话说，在两个连续的数据包之间最大的闲置时间。 如果超时是0表示无限大的超时时间，即这个参数没有设置或为0表示读取超时时间为无限大 http.tcp.nodelay 决定了是否使用Nagle算法。该算法通过最小发送的分组数量来节省带宽。 当应用程序希望降低网络延迟并提高性能时，他们可...
HttpClient使用方法及基本参数含义
飞火龙在天的博客
08-24 1807
一、方法 使用HttpClient发送请求、接收响应很简单，一般需要如下几步即可。 1. 创建HttpClient对象。 2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。 3. 如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HetpParams params...
HttpClient详细解释
tian5753的博客
12-01 372
HttpClient详细解释
apache HttpClient参数说明
shuxiaohua的博客
07-04 2998
正文 HttpClient组件使用的地方较多，很多HTTP客户端都是封装的HTTPClient(spring restTempalte就是基于HTTPClient构建的);HTTPClient可以设置的参数较多，部分参数的设置堆系统影响较大，需要对各个参数有个透彻的了解。 以下是基于使用PoolingHttpClientConnectionManager 项目 说明 默认值 备注 maxConnTotal HTTPClient能够创建的最大连接数 20 达到上线后，需要等待其他连接销毁后才能
HttpClient详解（一）
哈哈Boy的专栏
12-25 2037
http://www.cnblogs.com/anee/p/3269982.html HttpClient详解（一） 作者：namehybin更新于 08月15日 16:30访问（219）评论（0） HttpClient是一个客户端的HTTP通信实现库。HttpClient的目标是发送和接收HTTP报文。 HTTP请求 HttpClient 支持所有定
httpClient入门到精通-------配置参数
12-16 1378
package cn.itcast.httpclient;import org.apache.http.client.config.RequestConfig; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.HttpGet; import org.a
HttpClient请求地址并携带参数
QDY5945的博客
10-17 1430
废话不多，直接上代码！ 1 /** 2 * 3 * @param httpUrl 4 * @param reqInfo 5 * @return 6 */ 7 publi...
HttpClient用法详解
qq_41815361的博客
09-13 489
HttpClient请求 # 引入所需要的jar包 # 直接上代码 # 代码测试 目录HttpClient请求前言一、引入所需要的jar包二、代码三、代码测试四、总结 前言 本人最近刚开始想写博客，记录一下平常所需要的技术，才艺不精，写的有什么不对或者不明白的地方，还请读者多多包涵，可以直接评论出来，本人虚心请教。希望读者可以给个关注，谢谢.如果有不全的可以联系我 提示：以下是本篇文章正文内容，下面案例可供参考 一、引入所需要的jar包 这个项目是SpringBoot项目，在pom.xml中
HttpClient中配置HTTP参数
zhangzuanqian
09-22 517
copy from :http://hi.baidu.com/nickshen3/blog/item/c56528a4bbf8bffe9152ee71.html   关于HttpClient不多说，可以到apache网站下载，网上文档的也多如牛毛。针对HttpClient-3.1，我认为比较重要的一部分就是配置HTTP的参数。实际上，按HttpClient默认的参数配置也可以做简单的应用，其中...
HttpClient传输Json及Param数据
qq_43680114的博客
02-10 1114
【代码】HttpClient传输Json及Param数据。
掌握HttpClient实例：处理普通及JSON参数
在深入理解HttpClient实现发送POST请求的不同参数类型的完整实例前，首先需要明确几个基础概念和知识点，这些包括HttpClient的定义、POST请求的特点以及JSON和普通参数的处理方式。接下来将一一介绍这些内容。 ### ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值