当前位置: 欧洲杯竞猜 > 计算机知识 > 正文

java应用集锦9,高并发场景下的httpClient优化利用

时间:2019-07-25 18:03来源:计算机知识
1.背景 转账注明出处: 我们有个业务,会调用其他部门提供的一个基于http的服务,日调用量在千万级别。使用了httpclient来完成业务。之前因为qps上不去,就看了一下业务代码,并做了

1.背景

转账注明出处:

我们有个业务,会调用其他部门提供的一个基于http的服务,日调用量在千万级别。使用了httpclient来完成业务。之前因为qps上不去,就看了一下业务代码,并做了一些优化,记录在这里。

 

先对比前后:优化之前,平均执行时间是250ms;优化之后,平均执行时间是80ms,降低了三分之二的消耗,容器不再动不动就报警线程耗尽了,清爽~

在工作中要用到android,然后进行网络请求的时候,打算使用httpClient。

2.分析

总结一下httpClient的一些基本使用。

项目的原实现比较粗略,就是每次请求时初始化一个httpclient,生成一个httpPost对象,执行,然后从返回结果取出entity,保存成一个字符串,最后显式关闭response和client。我们一点点分析和优化:

版本是4.2.2。

2.1 httpclient反复创建开销

 

httpclient是一个线程安全的类,没有必要由每个线程在每次使用时创建,全局保留一个即可。

使用这个版本的过程中,百度很多,结果都是出现的org.apache.commons.httpclient.这个包名,而不是我这里的org.apache.http.client.HttpClient----------前者版本是 Commons HttpClient 3.x ,不是最新的版本HttpClient 4.×。

2.2 反复创建tcp连接的开销

 

tcp的三次握手与四次挥手两大裹脚布过程,对于高频次的请求来说,消耗实在太大。试想如果每次请求我们需要花费5ms用于协商过程,那么对于qps为100的单系统,1秒钟我们就要花500ms用于握手和挥手。又不是高级领导,我们程序员就不要搞这么大做派了,改成keep alive方式以实现连接复用!

官网上面:

2.3 重复缓存entity的开销

 

原本的逻辑里,使用了如下代码:

Commons HttpClient 3.x codeline is at the end of life. All users of Commons HttpClient 3.x are strongly encouraged to upgrade to HttpClient 4.1.  

HttpEntity entity = httpResponse.getEntity();
String response = EntityUtils.toString(entity);

 

这里我们相当于额外复制了一份content到一个字符串里,而原本的httpResponse仍然保留了一份content,需要被consume掉,在高并发且content非常大的情况下,会消耗大量内存。

 

3.实现

1.基本的get

按上面的分析,我们主要要做三件事:一是单例的client,二是缓存的保活连接,三是更好的处理返回结果。一就不说了,来说说二。

 

提到连接缓存,很容易联想到数据库连接池。httpclient4提供了一个PoolingHttpClientConnectionManager 作为连接池。接下来我们通过以下步骤来优化:

Java代码  图片 1

3.1 定义一个keep alive strategy

  1. public void getUrl(String url, String encoding)  
  2.             throws ClientProtocolException, IOException {  
  3.         // 默认的client类。  
  4.         HttpClient client = new DefaultHttpClient();  
  5.         // 设置为get取连接的方式.  
  6.         HttpGet get = new HttpGet(url);  
  7.         // 得到返回的response.  
  8.         HttpResponse response = client.execute(get);  
  9.         // 得到返回的client里面的实体对象信息.  
  10.         HttpEntity entity = response.getEntity();  
  11.         if (entity != null) {  
  12.             System.out.println("内容编码是:"   entity.getContentEncoding());  
  13.             System.out.println("内容类型是:"   entity.getContentType());  
  14.             // 得到返回的主体内容.  
  15.             InputStream instream = entity.getContent();  
  16.             try {  
  17.                 BufferedReader reader = new BufferedReader(  
  18.                         new InputStreamReader(instream, encoding));  
  19.                 System.out.println(reader.readLine());  
  20.             } catch (Exception e) {  
  21.                 e.printStackTrace();  
  22.             } finally {  
  23.                 instream.close();  
  24.             }  
  25.         }  
  26.   
  27.         // 关闭连接.  
  28.         client.getConnectionManager().shutdown();  
  29.     }  

关于keep-alive,本文不展开说明,只提一点,是否使用keep-alive要根据业务情况来定,它并不是灵丹妙药。还有一点,keep-alive和time_wait/close_wait之间也有不少故事。

 

在本业务场景里,我们相当于有少数固定客户端,长时间极高频次的访问服务器,启用keep-alive非常合适

2.基本的Post

再多提一嘴,http的keep-alive 和tcp的KEEPALIVE不是一个东西。回到正文,定义一个strategy如下:

   下面的params参数,是在表单里面提交的参数。

ConnectionKeepAliveStrategy myStrategy = new ConnectionKeepAliveStrategy() {
    @Override
    public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
        HeaderElementIterator it = new BasicHeaderElementIterator
            (response.headerIterator(HTTP.CONN_KEEP_ALIVE));
        while (it.hasNext()) {
            HeaderElement he = it.nextElement();
            String param = he.getName();
            String value = he.getValue();
            if (value != null && param.equalsIgnoreCase
              ("timeout")) {
                return Long.parseLong(value) * 1000;
            }
        }
        return 60 * 1000;//如果没有约定,则默认定义时长为60s
    }
};

 

3.2 配置一个PoolingHttpClientConnectionManager

Java代码  图片 2

PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
connectionManager.setMaxTotal(500);
connectionManager.setDefaultMaxPerRoute(50);//例如默认每路由最高50并发,具体依据业务来定

  1. public void postUrlWithParams(String url, Map params, String encoding)  
  2.             throws Exception {  
  3.         DefaultHttpClient httpclient = new DefaultHttpClient();  
  4.         try {  
  5.   
  6.             HttpPost httpost = new HttpPost(url);  
  7.             // 添加参数  
  8.             List<NameValuePair> nvps = new ArrayList<NameValuePair>();  
  9.             if (params != null && params.keySet().size() > 0) {  
  10.                 Iterator iterator = params.entrySet().iterator();  
  11.                 while (iterator.hasNext()) {  
  12.                     Map.Entry entry = (Entry) iterator.next();  
  13.                     nvps.add(new BasicNameValuePair((String) entry.getKey(),  
  14.                             (String) entry.getValue()));  
  15.                 }  
  16.             }  
  17.   
  18.             httpost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));  
  19.   
  20.             HttpResponse response = httpclient.execute(httpost);  
  21.             HttpEntity entity = response.getEntity();  
  22.   
  23.             System.out.println("Login form get: "   response.getStatusLine()  
  24.                       entity.getContent());  
  25.             dump(entity, encoding);  
  26.             System.out.println("Post logon cookies:");  
  27.             List<Cookie> cookies = httpclient.getCookieStore().getCookies();  
  28.             if (cookies.isEmpty()) {  
  29.                 System.out.println("None");  
  30.             } else {  
  31.                 for (int i = 0; i < cookies.size(); i ) {  
  32.                     System.out.println("- "   cookies.get(i).toString());  
  33.                 }  
  34.             }  
  35.   
  36.         } finally {  
  37.             // 关闭请求  
  38.             httpclient.getConnectionManager().shutdown();  
  39.         }  
  40.     }  

也可以针对每个路由设置并发数。

 

3.3 生成httpclient

3。打印页面输出的小代码片段

httpClient = HttpClients.custom()
                .setConnectionManager(connectionManager)
                .setKeepAliveStrategy(kaStrategy)
                .setDefaultRequestConfig(RequestConfig.custom().setStaleConnectionCheckEnabled(true).build())
                .build();

 

注意:使用setStaleConnectionCheckEnabled方法来逐出已被关闭的链接不被推荐。更好的方式是手动启用一个线程,定时运行closeExpiredConnections 和closeIdleConnections方法,如下所示。

Java代码  图片 3

public static class IdleConnectionMonitorThread extends Thread {
   
    private final HttpClientConnectionManager connMgr;
    private volatile boolean shutdown;
   
    public IdleConnectionMonitorThread(HttpClientConnectionManager connMgr) {
        super();
        this.connMgr = connMgr;
    }

  1. private static void dump(HttpEntity entity, String encoding)  
  2.             throws IOException {  
  3.         BufferedReader br = new BufferedReader(new InputStreamReader(  
  4.                 entity.getContent(), encoding));  
  5.         System.out.println(br.readLine());  
  6.     }  

    @Override
    public void run() {
        try {
            while (!shutdown) {
                synchronized (this) {
                    wait(5000);
                    // Close expired connections
                    connMgr.closeExpiredConnections();
                    // Optionally, close connections
                    // that have been idle longer than 30 sec
                    connMgr.closeIdleConnections(30, TimeUnit.SECONDS);
                }
            }
        } catch (InterruptedException ex) {
            // terminate
        }
    }
   
    public void shutdown() {
        shutdown = true;
        synchronized (this) {
            notifyAll();
        }
    }
   
}

 

3.4 使用httpclient执行method时降低开销

4.常见的登录session问题,需求:使用账户,密码登录系统之后,然后再访问页面不出错。

这里要注意的是,不要关闭connection。

 

一种可行的获取内容的方式类似于,把entity里的东西复制一份:

特别注意,下面的httpclient对象要使用一个,而不要在第二次访问的时候,重新new一个。至于如何保存这个第一步经过了验证的 httpclient,有很多种方法实现。单例,系统全局变量(android 下面的Application),ThreadLocal变量等等。

res = EntityUtils.toString(response.getEntity(),"UTF-8");
EntityUtils.consume(response1.getEntity());

 

但是,更推荐的方式是定义一个ResponseHandler,方便你我他,不再自己catch异常和关闭流。在此我们可以看一下相关的源码:

       以及下面创建的httpClient要使用ThreadSafeClientConnManager对象!

public <T> T execute(final HttpHost target, final HttpRequest request,
            final ResponseHandler<? extends T> responseHandler, final HttpContext context)
            throws IOException, ClientProtocolException {
        Args.notNull(responseHandler, "Response handler");

 

        final HttpResponse response = execute(target, request, context);

   public String getSessionId(String url, Map params, String encoding,

        final T result;
        try {
            result = responseHandler.handleResponse(response);
        } catch (final Exception t) {
            final HttpEntity entity = response.getEntity();
            try {
                EntityUtils.consume(entity);
            } catch (final Exception t2) {
                // Log this exception. The original exception is more
                // important and will be thrown to the caller.
                this.log.warn("Error consuming content after an exception.", t2);
            }
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            }
            if (t instanceof IOException) {
                throw (IOException) t;
            }
            throw new UndeclaredThrowableException(t);
        }

Java代码  图片 4

        // Handling the response was successful. Ensure that the content has
        // been fully consumed.
        final HttpEntity entity = response.getEntity();
        EntityUtils.consume(entity);//看这里看这里
        return result;
    }

  1.         String url2) throws Exception {  
  2.     DefaultHttpClient httpclient = new DefaultHttpClient(  
  3.             new ThreadSafeClientConnManager());  
  4.     try {  
  5.   
  6.         HttpPost httpost = new HttpPost(url);  
  7.         // 添加参数  
  8.         List<NameValuePair> nvps = new ArrayList<NameValuePair>();  
  9.         if (params != null && params.keySet().size() > 0) {  
  10.             Iterator iterator = params.entrySet().iterator();  
  11.             while (iterator.hasNext()) {  
  12.                 Map.Entry entry = (Entry) iterator.next();  
  13.                 nvps.add(new BasicNameValuePair((String) entry.getKey(),  
  14.                         (String) entry.getValue()));  
  15.             }  
  16.         }  
  17.         // 设置请求的编码格式  
  18.         httpost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));  
  19.         // 登录一遍  
  20.         httpclient.execute(httpost);  
  21.         // 然后再第二次请求普通的url即可。  
  22.         httpost = new HttpPost(url2);  
  23.         BasicResponseHandler responseHandler = new BasicResponseHandler();  
  24.         System.out.println(httpclient.execute(httpost, responseHandler));  
  25.     } finally {  
  26.         // 关闭请求  
  27.         httpclient.getConnectionManager().shutdown();  
  28.     }  
  29.     return "";  
  30. }  

可以看到,如果我们使用resultHandler执行execute方法,会最终自动调用consume方法,而这个consume方法如下所示:

 

public static void consume(final HttpEntity entity) throws IOException {
        if (entity == null) {
            return;
        }
        if (entity.isStreaming()) {
            final InputStream instream = entity.getContent();
            if (instream != null) {
                instream.close();
            }
        }
    }

5.下载文件,例如mp3等等。

可以看到最终它关闭了输入流。

 

4.其他

Java代码  图片 5

通过以上步骤,基本就完成了一个支持高并发的httpclient的写法,下面是一些额外的配置和提醒:

  1. //第一个参数,网络连接;第二个参数,保存到本地文件的地址  
  2. public void getFile(String url, String fileName) {  
  3.         HttpClient httpClient = new DefaultHttpClient();  
  4.         HttpGet get = new HttpGet(url);  
  5.         try {  
  6.             ResponseHandler<byte[]> handler = new ResponseHandler<byte[]>() {  
  7.                 public byte[] handleResponse(HttpResponse response)  
  8.                         throws ClientProtocolException, IOException {  
  9.                     HttpEntity entity = response.getEntity();  
  10.                     if (entity != null) {  
  11.                         return EntityUtils.toByteArray(entity);  
  12.                     } else {  
  13.                         return null;  
  14.                     }  
  15.                 }  
  16.             };  
  17.   
  18.             byte[] charts = httpClient.execute(get, handler);  
  19.             FileOutputStream out = new FileOutputStream(fileName);  
  20.             out.write(charts);  
  21.             out.close();  
  22.   
  23.         } catch (Exception e) {  
  24.             e.printStackTrace();  
  25.         } finally {  
  26.             httpClient.getConnectionManager().shutdown();  
  27.         }  
  28.     }  

4.1 httpclient的一些超时配置

 

CONNECTION_TIMEOUT是连接超时时间,SO_TIMEOUT是socket超时时间,这两者是不同的。连接超时时间是发起请求前的等待时间;socket超时时间是等待数据的超时时间。

6.创建一个多线程环境下面可用的httpClient

HttpParams params = new BasicHttpParams();
//设置连接超时时间
Integer CONNECTION_TIMEOUT = 2 * 1000; //设置请求超时2秒钟 根据业务调整
Integer SO_TIMEOUT = 2 * 1000; //设置等待数据超时时间2秒钟 根据业务调整

(原文:)

//定义了当从ClientConnectionManager中检索ManagedClientConnection实例时使用的毫秒级的超时时间
//这个参数期望得到一个java.lang.Long类型的值。如果这个参数没有被设置,默认等于CONNECTION_TIMEOUT,因此一定要设置。
Long CONN_MANAGER_TIMEOUT = 500L; //在httpclient4.2.3中我记得它被改成了一个对象导致直接用long会报错,后来又改回来了
 
params.setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, CONNECTION_TIMEOUT);
params.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, SO_TIMEOUT);
params.setLongParameter(ClientPNames.CONN_MANAGER_TIMEOUT, CONN_MANAGER_TIMEOUT);
//在提交请求之前 测试连接是否可用
params.setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, true);
 
//另外设置http client的重试次数,默认是3次;当前是禁用掉(如果项目量不到,这个默认即可)
httpClient.setHttpRequestRetryHandler(new DefaultHttpRequestRetryHandler(0, false));

 

4.2 如果配置了nginx的话,nginx也要设置面向两端的keep-alive

Java代码  图片 6

现在的业务里,没有nginx的情况反而比较稀少。nginx默认和client端打开长连接而和server端使用短链接。注意client端的keepalive_timeout和keepalive_requests参数,以及upstream端的keepalive参数设置,这三个参数的意义在此也不再赘述。

  1.               HttpParams params = new BasicHttpParams();  
  2. //设置允许链接的做多链接数目  
  3. ConnManagerParams.setMaxTotalConnections(params, 200);  
  4. //设置超时时间.  
  5. ConnManagerParams.setTimeout(params, 10000);  
  6. //设置每个路由的最多链接数量是20  
  7. ConnPerRouteBean connPerRoute = new ConnPerRouteBean(20);  
  8. //设置到指定主机的路由的最多数量是50  
  9. HttpHost localhost = new HttpHost("127.0.0.1",80);  
  10. connPerRoute.setMaxForRoute(new HttpRoute(localhost), 50);  
  11. ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);  
  12. //设置链接使用的版本  
  13. HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);  
  14. //设置链接使用的内容的编码  
  15. HttpProtocolParams.setContentCharset(params,  
  16.         HTTP.DEFAULT_CONTENT_CHARSET);  
  17. //是否希望可以继续使用.  
  18. HttpProtocolParams.setUseExpectContinue(params, true);  
  19.   
  20. SchemeRegistry schemeRegistry = new SchemeRegistry();  
  21. schemeRegistry.register(new Scheme("http",PlainSocketFactory.getSocketFactory(),80));  
  22. schemeRegistry.register(new Scheme("https",SSLSocketFactory.getSocketFactory(),443));  
  23. ClientConnectionManager cm = new ThreadSafeClientConnManager(params,schemeRegistry);  
  24. httpClient = new DefaultHttpClient(cm, params);   

以上就是我的全部设置。通过这些设置,成功地将原本每次请求250ms的耗时降低到了80左右,效果显著。

 

本文永久更新链接地址

7.实用的一个对象,http上下文,可以从这个对象里面取到一次请求相关的信息,例如request,response,代理主机等。

图片 7

 

Java代码  图片 8

  1. public static void getUrl(String url, String encoding)  
  2.             throws ClientProtocolException, IOException {  
  3.         // 设置为get取连接的方式.  
  4.         HttpGet get = new HttpGet(url);  
  5.         HttpContext localContext = new BasicHttpContext();  
  6.         // 得到返回的response.第二个参数,是上下文,很好的一个参数!  
  7.         httpclient.execute(get, localContext);  
  8.   
  9.         // 从上下文中得到HttpConnection对象  
  10.         HttpConnection con = (HttpConnection) localContext  
  11.                 .getAttribute(ExecutionContext.HTTP_CONNECTION);  
  12.         System.out.println("socket超时时间:"   con.getSocketTimeout());  
  13.   
  14.         // 从上下文中得到HttpHost对象  
  15.         HttpHost target = (HttpHost) localContext  
  16.                 .getAttribute(ExecutionContext.HTTP_TARGET_HOST);  
  17.         System.out.println("最终请求的目标:"   target.getHostName()   ":"  
  18.                   target.getPort());  
  19.   
  20.         // 从上下文中得到代理相关信息.  
  21.         HttpHost proxy = (HttpHost) localContext  
  22.                 .getAttribute(ExecutionContext.HTTP_PROXY_HOST);  
  23.         if (proxy != null)  
  24.             System.out.println("代理主机的目标:"   proxy.getHostName()   ":"  
  25.                       proxy.getPort());  
  26.   
  27.         System.out.println("是否发送完毕:"  
  28.                   localContext.getAttribute(ExecutionContext.HTTP_REQ_SENT));  
  29.   
  30.         // 从上下文中得到HttpRequest对象  
  31.         HttpRequest request = (HttpRequest) localContext  
  32.                 .getAttribute(ExecutionContext.HTTP_REQUEST);  
  33.         System.out.println("请求的版本:"   request.getProtocolVersion());  
  34.         Header[] headers = request.getAllHeaders();  
  35.         System.out.println("请求的头信息: ");  
  36.         for (Header h : headers) {  
  37.             System.out.println(h.getName()   "--"   h.getValue());  
  38.         }  
  39.         System.out.println("请求的链接:"   request.getRequestLine().getUri());  
  40.   
  41.         // 从上下文中得到HttpResponse对象  
  42.         HttpResponse response = (HttpResponse) localContext  
  43.                 .getAttribute(ExecutionContext.HTTP_RESPONSE);  
  44.         HttpEntity entity = response.getEntity();  
  45.         if (entity != null) {  
  46.             System.out.println("返回结果内容编码是:"   entity.getContentEncoding());  
  47.             System.out.println("返回结果内容类型是:"   entity.getContentType());  
  48.             dump(entity, encoding);  
  49.         }  
  50.     }  

 输出结果大致如下:

 

Txt代码  图片 9

  1. socket超时时间:0  
  2. 最终请求的目标:money.finance.sina.com.cn:-1  
  3. 是否发送完毕:true  
  4. 请求的版本:HTTP/1.1  
  5. 请求的头信息:   
  6. Host--money.finance.sina.com.cn  
  7. Connection--Keep-Alive  
  8. User-Agent--Apache-HttpClient/4.2.2 (java 1.5)  
  9. 请求的链接:/corp/go.php/vFD_BalanceSheet/stockid/600031/ctrl/part/displaytype/4.phtml  
  10. 返回结果内容编码是:null  
  11. 返回结果内容类型是:Content-Type: text/html  

 

8.设置代理

 

Java代码  图片 10

  1.              //String  hostIp代理主机ip,int port  代理端口  
  2. tpHost proxy = new HttpHost(hostIp, port);  
  3. // 设置代理主机.  
  4. tpclient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,  
  5. proxy);  

 

9.设置保持链接时间

 

Java代码  图片 11

  1. //在服务端设置一个保持持久连接的特性.  
  2.         //HTTP服务器配置了会取消在一定时间内没有活动的链接,以节省系统的持久性链接资源.  
  3.         httpClient.setKeepAliveStrategy(new ConnectionKeepAliveStrategy() {  
  4.             public long getKeepAliveDuration(HttpResponse response,  
  5.                     HttpContext context) {  
  6.                 HeaderElementIterator it = new BasicHeaderElementIterator(  
  7.                         response.headerIterator(HTTP.CONN_KEEP_ALIVE));  
  8.                 while (it.hasNext()) {  
  9.                     HeaderElement he = it.nextElement();  
  10.                     String param = he.getName();  
  11.                     String value = he.getValue();  
  12.                     if (value != null && param.equalsIgnoreCase("timeout")) {  
  13.                         try {  
  14.                             return Long.parseLong(value) * 1000;  
  15.                         } catch (Exception e) {  
  16.   
  17.                         }  
  18.                     }  
  19.                 }  
  20.                 HttpHost target = (HttpHost)context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);  
  21.                 if("www.baidu.com".equalsIgnoreCase(target.getHostName())){  
  22.                     return 5*1000;  
  23.                 }  
  24.                 else  
  25.                     return 30*1000;   
  26.             }   
  27.         });  

 

转账注明出处:

编辑:计算机知识 本文来源:java应用集锦9,高并发场景下的httpClient优化利用

关键词: 欧洲杯竞猜