彻底掌握网络通信（七）ConnectionReuseStrategy，ConnectionKeepAliveStrategy解析

网络通信系列文章序

彻底掌握网络通信（一）Http协议基础知识
彻底掌握网络通信（二）Apache的HttpClient基础知识
彻底掌握网络通信（三）Android源码中HttpClient的在不同版本的使用
彻底掌握网络通信（四）Android源码中HttpClient的发送框架解析
彻底掌握网络通信（五）DefaultRequestDirector解析
彻底掌握网络通信（六）HttpRequestRetryHandler解析
彻底掌握网络通信（七）ConnectionReuseStrategy，ConnectionKeepAliveStrategy解析
彻底掌握网络通信（八）AsyncHttpClient源码解读
彻底掌握网络通信（九）AsyncHttpClient为什么无法用Fiddler来抓包
彻底掌握网络通信（十）AsyncHttpClient如何发送JSON解析JSON,以及一些其他用法

---

前面简单说了下HttpRequestRetryHandler，这篇主要分析下ConnectionReuseStrategy，ConnectionKeepAliveStrategy，连接的重用和长连接

---

1：基础介绍
1.1）Keep-Alive解析
http协议作为上层应用层协议，其是基于TCP/IP协议，UDP协议传输层上进行的；http协议通过socket这个套接字完成客户端和服务端的通信；
http协议目前主要有两个版本HTTP 1.0和HTTP 1.1，他们都是无状态协议

在HTTP 1.0中，每一次请求响应之后，下一次的请求需要断开之前的连接，再重新开始；

在HTTP 1.1中，使用keep-alive在一次TCP连接中可以持续发送多份数据而不会断开连接。通过使用keep-alive机制，可以减少tcp连接建立次数，也意味着可以减少TIME_WAIT状态连接，以此提高性能和提高httpd服务器的吞吐率(更少的tcp连接意味着更少的系统内核调用,socket的accept()和close()调用)。

因此便出现了Connection: keep-alive的设置，用于建立长连接，即我们所说的Keep-Alive模式；

如上图，左图是HTTP 1.0 ; 右图是HTTP 1.1

http 1.0中默认是关闭的，需要在http头加入”Connection: Keep-Alive”，才能启用Keep-Alive；
在1.0中，如果客户端浏览器支持Keep-Alive，那么就在HTTP请求头中添加一个字段 Connection: Keep-Alive，当服务器收到附带有Connection: Keep-Alive的请求时，它也会在响应头中添加一个同样的字段来使用Keep-Alive。这样一来，客户端和服务器之间的HTTP连接就会被保持，不会断开（超过Keep-Alive规定的时间，意外断电等情况除外），当客户端发送另外一个请求时，就使用这条已经建立的连接

http 1.1中默认启用Keep-Alive，如果加入”Connection: close “，才关闭。
Keep-Alive不会永久保持连接，它有一个保持时间，可以在不同的服务器软件（如Apache）中设定这个时间；
一次完成的http请求是否能够保持，同时也要靠服务端是否具备Keep-Alive能力；

1.2）如何判断客户端已经完整的接收到服务端的数据，针对HTTP 1.0和HTTP 1.1
在java中，使用socket编程的时候，我们经常看到如下代码

Socket socket = new Socket("localhost",10086);
InputStream is = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String info = null;
while((info=br.readLine()) != -1){

}

所以在普通的socket编程中，我们可以使用EOF（-1）来判断是否完整的接收到服务端的返回的数据；这是因为在一次普通的http请求中，即没有添加Connection: Keep-Alive属性的http请求中，服务端响应之后，会断开连接，顾使用EOF判断是准确的；

但是这种方式针对添加Connection: Keep-Alive属性的http请求来说，就无法生效了；
我们可以通过头消息中的Conent-Length字段来判断；但是对于动态页面或者zip格式的内容，服务端一般会采用Transfer-Encoding: chunked”这样的方式来代替Content-Length；

因此
在Http 1.0及之前版本中，content-length字段可有可无。
在http1.1及之后版本。如果是keep alive，则content-length和chunk必然是二选一。若是非keep alive，则和http1.0一样。content-length可有可无。

2：在DefaultRequestDirector.execute方法中有如下代码

// The connection is in or can be brought to a re-usable state.
    reuse = reuseStrategy.keepAlive(response, context);
if(reuse) {
   // Set the idle duration of this connection
    long duration = keepAliveStrategy.getKeepAliveDuration(response, context);
              managedConn.setIdleDuration(duration,  TimeUnit.MILLISECONDS);
 }

从这段代码可以看出，当完成一次http请求之后，并没有立即关闭这个tcp连接和释放资源；而是通过可重用策略来判断这个连接能否被保持，以及保持多长时间；

我们先分析下如何判断这个连接是否是可重用的，我们可以通过上面的keepAlive方法来进行具体分析，reuseStrategy的默认实现者为DefaultConnectionReuseStrategy，我们看一下keepAlive方法

    //该方法的作用就是在一次请求之后,这个连接能够被保持
    //如果返回false,则调用者应该立即关闭连接
    //如果返回true,则调用者应该保持这个连接从而可以应用于其他请求
    public boolean keepAlive(final HttpResponse response,
                             final HttpContext context) {
        if (response == null) {
            throw new IllegalArgumentException
                ("HTTP response may not be null.");
        }
        if (context == null) {
            throw new IllegalArgumentException
                ("HTTP context may not be null.");
        }

        HttpConnection conn = (HttpConnection)
            context.getAttribute(ExecutionContext.HTTP_CONNECTION);

        //当一个连接没有建立的时候,当然是不可重用的,返回false
        if (conn != null && !conn.isOpen())
            return false;
        // do NOT check for stale connection, that is an expensive operation

        // Check for a self-terminating entity. If the end of the entity will
        // be indicated by closing the connection, there is no keep-alive.
        HttpEntity entity = response.getEntity();
        ProtocolVersion ver = response.getStatusLine().getProtocolVersion();
        //当返回的entity的长度小于0,并且http协议版本号小于1.0,返回false
        if (entity != null) {
            if (entity.getContentLength() < 0) {
                if (!entity.isChunked() ||
                    ver.lessEquals(HttpVersion.HTTP_1_0)) {
                    // if the content length is not known and is not chunk
                    // encoded, the connection cannot be reused
                    return false;
                }
            }
        }

        // Check for the "Connection" header. If that is absent, check for
        // the "Proxy-Connection" header. The latter is an unspecified and
        // broken but unfortunately common extension of HTTP.
        //HTTP.CONN_DIRECTIVE的值为Connection,即获取响应头信息中的Connection字段的内容
        HeaderIterator hit = response.headerIterator(HTTP.CONN_DIRECTIVE);
        //如果没有这个头信息,则寻找Proxy-Connection的头信息
        if (!hit.hasNext()){
            //Proxy-Connection是http1.0 时代的产物。老旧的代理，如果设置 connection: keepalive，
            //代理原样转发给服务器，服务器会以为要建立长久连接，但是代理并不支持，这样就出问题了。 
            //所以改为设置 proxy-connection: keepalive，如果是新的代理，
            //支持 keepalive，它会认得这个头，并改成 connection: keepalive 转发给服务器，
            //顺利建立持久连接；如果是老的代理，它不认识，会原样转发，这时候服务器也不会建立持久连接
            hit = response.headerIterator("Proxy-Connection");
        }

        if (hit.hasNext()) {
            try {
                TokenIterator ti = createTokenIterator(hit);
                boolean keepalive = false;
                while (ti.hasNext()) {
                    final String token = ti.nextToken();
                    //如果Connection:close则返回false
                    if (HTTP.CONN_CLOSE.equalsIgnoreCase(token)) {
                        return false;
                    }//如果Connection:Keep-Alive则返回true 
                    else if (HTTP.CONN_KEEP_ALIVE.equalsIgnoreCase(token)) {
                        // continue the loop, there may be a "close" afterwards
                        keepalive = true;
                    }
                }
                if (keepalive)
                    return true;
                // neither "close" nor "keep-alive", use default policy

            } catch (ParseException px) {
                // invalid connection header means no persistent connection
                // we don't have logging in HttpCore, so the exception is lost
                return false;
            }
        }

        // default since HTTP/1.1 is persistent, before it was non-persistent
        return !ver.lessEquals(HttpVersion.HTTP_1_0);
    }

总结
1：该方法的作用就是在一次请求之后,这个连接能否被保持,如果返回false,则调用者应该立即关闭连接;如果返回true,则调用者应该保持这个连接从而可以应用于其他请求
2：由于HTTP 1.0时代，还不能有效支持connection，顾多了一个Proxy-Connection头信息，该字段的出现的原因是: 在HTTP 1.0中老旧的代理，如果设置 connection: keepalive，代理原样转发给服务器，服务器会以为要建立长久连接，但是代理并不支持，这样就出问题了。所以改为设置 proxy-connection: keepalive，如果是新的代理，支持 keepalive，它会认得这个头，并改成 connection: keepalive 转发给服务器，顺利建立持久连接；如果是老的代理，它不认识，会原样转发，这时候服务器也不会建立持久连接

---

当一个请求视为可重用之后，即keepAlive返回true，那这么链接能一直保持链接状态？会不会超过一定时间，连接就断开？
答案是会的，当链接超过预设时间，会自动断开；

当一个链接是可重用的，我们就可以通过如下代码获得这个链接可以存活的时间

keepAliveStrategy.getKeepAliveDuration

keepAliveStrategy的实现为DefaultConnectionKeepAliveStrategy

public class DefaultConnectionKeepAliveStrategy implements ConnectionKeepAliveStrategy {

    public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
        if (response == null) {
            throw new IllegalArgumentException("HTTP response may not be null");
        }
        HeaderElementIterator it = new BasicHeaderElementIterator(
                //HTTP.CONN_KEEP_ALIVE的为“Keep-Alive”
                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")) {
                try {
                    return Long.parseLong(value) * 1000;
                } catch(NumberFormatException ignore) {
                }
            }
        }
        return -1;
    }

}

代码很简单，就是通过Keep-Alive头信息中，获得timeout的值，作为超时时间；单位毫秒；

如请求头中 Keep-Alive: timeout=5, max=100