OkHttp深入学习

最新推荐文章于 2021-12-01 00:12:02 发布

知道分子

最新推荐文章于 2021-12-01 00:12:02 发布

阅读量466

点赞数

分类专栏： android

android 专栏收录该内容

168 篇文章 1 订阅

订阅专栏

转自：http://blog.csdn.net/evan_man/article/details/51173810

Android 4.4之后，HttpURLConnection底层实现已被OkHttp替换。可以见得OkHttp的性能已经被Google所认同。对于为何会想深入了解该库的原因：因为它的最底层走到了java的Socket；利用向Socket写入特定的Http协议数据包，实现网络通信。学习该开源项目，对于网络的学历大有益处，除此之外OkHttp使用了缓存和线程池概念。总之个人觉得OkHttp开源项目可以作为学习网络通信一篇很好的教科书。

OkHttp的特点：

支持HTTP2/SPDY黑科技
socket自动选择最好路线，并支持自动重连
拥有自动维护的socket连接池，减少握手次数
拥有队列线程池，轻松写并发
拥有Interceptors轻松处理请求与响应（比如透明GZIP压缩,LOGGING）
实现基于Headers的缓存策略

OkHttp的使用：

创建OkHttpClient对象：OkHttpClient client = new OkHttpClient();
创建网络请求：Request request = new Request.Builder() .url("http://sethfeng.github.io/index.html") .build();
得到Call对象：Call call = client.newCall(request); //实际创建的是一个RealCall对象，RealCall中有一个对client对象的引用
发送同步请求：Response response = call.excute();
发送异步请求：
- [java] view plain copy
  1. call.enqueue(new Callback() {
  2. @Override
  3. public void onFailure(Request request, IOException e) {
  4. ...
  5. }
  6. @Override
  7. public void onResponse(Response response) throws IOException {
  8. ...
  9. }
  10. });

更多使用方法参考官方说明文档

OkHttpClient工作原理初步分析

RealCall.class

先来看一下通过 client.newCall(request)得到的Call对象

newCall(request)@OkHttpClient.class

[java]view plaincopy 
    
 Call newCall(Request request) {  
     return new RealCall(this, request);  
 }  

方法很简单就是利用调用newCall方法的OkHttpClient对象和newCall的输入参数构造一个RealCall对象。接下来看一下RealCall的构造器。

RealCall()@RealCall.class

[java]view plaincopy 
    
 protected RealCall(OkHttpClient client, Request originalRequest) {  
     this.client = client;  
     this.originalRequest = originalRequest;  
   }  

构造器也很简单，就是对RealCall中的OkHttpClient和Request域进行赋值。接下来看一下RealCall类中的execute和enqueue方法

execute@RealCall.class

[java]view plaincopy 
    
 public Response execute() throws IOException      
 {  
 try {  
             this.client.getDispatcher().executed(this); //同步请求不排队  
              //方法内部会执行synchronized void executed(Call call) {   this.executedCalls.add(call);  }  即把这次请求加入到分发器里  
             Response result = this.getResponseWithInterceptorChain(false);  
             if(result == null) {  
                 throw new IOException("Canceled");  
             }  
             var2 = result;  
  } finally {this.client.getDispatcher().finished(this); }  
     ...  
     return var2;  
 }  

该方法完成一个同步请求，首先将这次的同步请求call添加到Dispatcher的工作队列中，随后调用getResponseWithInterceptorChain方法获取request对应的response。最后返回得到的response。

enqueue@RealCall.class

[java]view plaincopy 
    
 public void enqueue(Callback responseCallback) {  
     enqueue(responseCallback, false);  
  }  
 实际调用下面方法  
 void enqueue(Callback responseCallback, boolean forWebSocket) {  
     synchronized (this) {  
       if (executed) throw new IllegalStateException("Already Executed");  
       executed = true;  
     }  
     client.dispatcher().enqueue(new AsyncCall(responseCallback, forWebSocket)); //异步请求会排队！  
 }  
 内部类AsyncCall@RealCall.class  
 final class AsyncCall extends NamedRunnable{  
 protected void execute() {  
         Response response = getResponseWithInterceptorChain(forWebSocket);  
         if (canceled) {  
           signalledCallback = true;  
           responseCallback.onFailure(RealCall.this, new IOException("Canceled"));  
         } else {  
           signalledCallback = true;  
           responseCallback.onResponse(RealCall.this, response);  
         }  
        this.client.getDispatcher().finished(this);    
     }  
 }  

enqueue则是将请求包装成一个异步请求，异步请求继承自Runnable的子接口，实现了一个execute异步方法，Dispatcher会在合适的时间调用该方法，注意这里的execute方法和前面的execute不是同一个方法。在execute方法内部会调用 getResponseWithInterceptorChain方法获得网络请求的返回值，随后利用回调方法，将结果发送给客户。

Dispatcher负责对客户请求进行处理，因此接下来分析一下Dispatcher的execute和enqueue方法。将在下一节分析getResponseWithInterceptorChain方法的底层实现。

Dispatcher.class

OkHttpClient中有一个Dispatcher类型的域，在构造OkHttpClient的时候会调用new Dispatcher()方法获得一个Dispatcher对象，因此我们直接看Dispatcher的源码。

Dispatcher()@Dispatcher.class

public Dispatcher() {

}

看到这个方法一脸的懵逼。什么也没做？不要方，既然这里没有做任何工作，那么有两种可能，Dispatcher的相关域要么在类加载时或者声明时就进行了初始化，要么就会在使用的时候再临时进行初始化，即延迟初始化，这也是一种优化。那我们直接看execute方法和enqueue方法

executed@Dispatcher.class

[java]view plaincopy 
    
 synchronized void executed(RealCall call) {  
     runningSyncCalls.add(call);   
 }  

该方法很简单，就是将Recall请求添加到runningSyncCalls集合中。该集合在构造Dispatcher的时候就初始化好了Deque<RealCall> runningSyncCalls = new ArrayDeque<>();该集合代表着当前正在线程中运行的请求。有的童鞋是不是已经方了？这就完了？我们的请求在哪执行！！？？不要忘了我们调用的RealCall的execute方法中，在this.client.getDispatcher().executed(this);语句后面继续调用Response result = this.getResponseWithInterceptorChain(false);方法，而实际的网络请求是在这里进行的。可以说Dispatch主要负责对客户的请求进行管理，留存，备份；重点在于利用线程池对异步请求的处理，同步请求它基本不干活。下面接着看enqueue方法。

enqueue()@Dispatcher.class

[java]view plaincopy 
    
 synchronized void enqueue(AsyncCall call) {  
     if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {  
       // maxRequestsPerHost默认为5 maxRequests默认64  
       runningAsyncCalls.add(call);  
       executorService().execute(call); //交给线程池去执行 call中的execute方法  
     } else {  
       readyAsyncCalls.add(call);    
       //存入等待队列  
       //对于存入这里的请求，在方法promoteCalls()中会被取出，进行执行；  
       //任务执行完成后,调用finished的promoteCalls()函数,不管是异步还是同步请求，它们在执行完execute方法过后都会调用Dispatcher的finished方法  
     }  
   }  

这个方法代码相对于execute就多了一些代码，不过逻辑很简单，首先判断集合runningSyncCalls的大小，即当前运行的请求数是否小于maxRequest；同时判断该请求的hostname对应的的请求个数是否小于maxRequestsPerHost。如果条件全为真，则直接将该请求加入到集合runningSyncCalls中，随后调用executorService().execute(call);对异步任务进行处理。否则将异步请求加入到等待异步执行队列readyAsyncCalls中。下面看看executorService方法

executorService()@Dispatcher.class

[java]view plaincopy 
    
 public synchronized ExecutorService executorService() {  
     if (executorService == null) {  
       executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,  
           new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));  
     }  
     return executorService;  
 }  

该方法返回了一个线程池，很熟悉吧；类似通过Executors.newCachedThreadPool()方法得到一个线程池。那么调用executorService().execute(call);方法最终会执行异步请求的execute方法，而异步请求的execute方法内部会调用getResponseWithInterceptorChain(）方法获得response。

那么到此为止对于execute方法和enqueue方法的介绍就结束了。如果好奇点的童鞋，可能会问，如果异步请求被添加到readyAsyncCalls集合中，那么它何时会被执行呢？注意到，在RealCall的execute和enqueue方法执行完后都会执行this.client.getDispatcher().finished(this); 这样一条语句。那么我们来看下Dispatcher的finished方法。

finished()@Dispatcher.class

[java]view plaincopy 
    
 synchronized void finished(AsyncCall call) {  
     if (!runningAsyncCalls.remove(call)) throw new AssertionError("AsyncCall wasn't running!");  
     promoteCalls();  
 }  

方法很简单，将请求从runningAsyncCalls中移除出去，随后执行 promoteCalls()方法，接着看该方法源码

finished()@Dispatcher.class

[java]view plaincopy 
    
 private void promoteCalls() {  
     if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity.  
     if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote.  
   
     for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {  
       AsyncCall call = i.next();  
   
       if (runningCallsForHost(call) < maxRequestsPerHost) {  
         i.remove();  
         runningAsyncCalls.add(call);  
         executorService().execute(call);  
       }  
   
       if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity.  
     }  
   }  

在当前运行任务数大于maxRequests和等待执行异步任务数为空的两种情况下直接返回不进行任何操作。否则从等待执行异步请求集合中获取到请求，判断该请求的hostname对应的的请求个数是否小于maxRequestsPerHost，为真则将该任务从等待执行异步请求集合中移出，存入runningAsyncCalls集合中，最后调用线程池执行器执行该异步请求的execute方法。到此为止我们对于Dispatcher的介绍就到此为止了。

对Dispatcher的总结如下：

该类中有两个集合分别为：runningAsyncCalls、readyAsyncCalls前者存放正在执行的请求，后者存放等待执行的请求
该类中有一个newCachedThreadPool线程执行器，利用该执行器来执行异步请求的execute方法。也就是说异步请求发送在非当前工作线程，即创建异步请求的线程，而是从线程池中获取一条线程执行网络请求。同步请求则直接是在当前工作线程中执行。
该类对异步请求的管理是通过maxRequests、maxRequestsPerHost进行控制的，前者控制线程池中同时运行的最大请求数，防止同时运行线程过多，造成OOM。后者限制了同一hostname下的请求数，防止一个应用占用的网络资源过多，优化用户体验。

文章的最后我们对okhttp中使用过程中遇到的Request、Response、OkHttpClient这几个类进行一下介绍。

Request.class

该类中有如下域

[java]view plaincopy 
        
 private final HttpUrl url;  //目标地址  
 private final String method; //方法  
 private final Headers headers; //请求头，Headers.class里面维护了一个private final String[] namesAndValues;数据集  
 private final RequestBody body; //请求表单  
 private final Object tag; //标签  
 private volatile URI javaNetUri; // Lazily initialized.  
 private volatile CacheControl cacheControl; // Lazily initialized.  

只能通过Builder方法构建Request对象。

Builder()@Builder.class@Request.class

[java]view plaincopy 
        
 public Builder() {  
       this.method = "GET";  
       this.headers = new Headers.Builder();  
 }  

默认创建的是Get方法

Build()@Builder.class@Request.class

[java]view plaincopy 
        
 public Request build() {  
       if (url == null) throw new IllegalStateException("url == null");  
       return new Request(this);  
 }  

调用Request构造器，创建Request对象。

Response.class

类中有如下域

[java]view plaincopy 
        
 private final Request request;  //对应的request  
 private final Protocol protocol; //对应的Http协议  
 private final int code; //返回状态码  
 private final String message; //Http状态对应的消息  
 private final Handshake handshake; //TLS握手协议Transport Layer Security  
 private final Headers headers; //返回响应头  
 private final ResponseBody body; //Http表单  
 private Response networkResponse; //来源于网络的Response，如果响应来自缓存，则该值为null  
 private Response cacheResponse; //来自缓存的响应  
 private final Response priorResponse;  //在redirect或者授权改变的时候，该结果不为空  
 private volatile CacheControl cacheControl; // Lazily initialized.  

Okhttp中有client.internalCache()和client.connectionPool()两个重要的概念，前者管理网络访问的缓存信息，后者用于存储已链接的RealConnection（该RealConnection已经跟对应的hostname完成了三次握手）。下面我们看一下创建Cache和ConnectionPool这两个对象的OkHttpClient对象。

OkHttpClient.class

Internal.instance@OkHttpClient.class

[java]view plaincopy 
      
 static {  
     Internal.instance = new Internal() {  
       @Override public void addLenient(Headers.Builder builder, String line) {  
         builder.addLenient(line);  
       }  
   
       @Override public void addLenient(Headers.Builder builder, String name, String value) {  
         builder.addLenient(name, value);  
       }  
   
       @Override public void setCache(OkHttpClient.Builder builder, InternalCache internalCache) {  
         builder.setInternalCache(internalCache);  
       }  
   
       @Override public InternalCache internalCache(OkHttpClient client) {  
         return client.internalCache();  
       }  
   
       @Override public boolean connectionBecameIdle(  
           ConnectionPool pool, RealConnection connection) {  
         return pool.connectionBecameIdle(connection);  
       }  
   
       @Override public RealConnection get(  
           ConnectionPool pool, Address address, StreamAllocation streamAllocation) {  
         return pool.get(address, streamAllocation);  
       }  
   
       @Override public void put(ConnectionPool pool, RealConnection connection) {  
         pool.put(connection);  
       }  
   
       @Override public RouteDatabase routeDatabase(ConnectionPool connectionPool) {  
         return connectionPool.routeDatabase;  
       }  
   
       @Override  
       public void callEnqueue(Call call, Callback responseCallback, boolean forWebSocket) {  
         ((RealCall) call).enqueue(responseCallback, forWebSocket);  
       }  
   
       @Override public StreamAllocation callEngineGetStreamAllocation(Call call) {  
         return ((RealCall) call).engine.streamAllocation;  
       }  
   
       @Override  
       public void apply(ConnectionSpec tlsConfiguration, SSLSocket sslSocket, boolean isFallback) {  
         tlsConfiguration.apply(sslSocket, isFallback);  
       }  
   
       @Override public HttpUrl getHttpUrlChecked(String url)  
           throws MalformedURLException, UnknownHostException {  
         return HttpUrl.getChecked(url);  
       }  
     };  
   }  

这一段代码用static修饰，表明在加载OkHttpClient类时就会对Internal.instance进行初始化操作。

internalCache() @OkHttpClient.class

[java]view plaincopy 
      
 InternalCache internalCache() {  
     return cache != null ? cache.internalCache : internalCache;  
 }  

cache域在我们构造OkHttpClient的时候是没有被初始化的，因此如果我们没有通过调用Builder的cache方法设置cache值的话，该方法返回的对象实际上是一个不支持任何缓存操作的对象，说着说该对象的所有方法为空。因此如果需要OkHttpClient支持缓存，需要我们写一个Cache对象并在构造OkHttpClient的时候将其传给OkHttpClient。

cache()@Builder.class@OkHttpClient.class

[java]view plaincopy 
      
 public Builder cache(Cache cache) {  
       this.cache = cache;  
       this.internalCache = null;  
       return this;  
 }  

完成cache的初始化，如果不调用该方法那么OkHttpClient默认不提供Cache功能。对于Cahce更为详细的介绍在后面的章节我们会进行详细介绍。《OkHttp深入学习（三）——Cache》

connectionPool()@OkHttpClient.class

[java]view plaincopy 
      
 public ConnectionPool connectionPool() {  
     return connectionPool;   
 }  

connectionPool的初始化是在构建OkHttpClient时创建的，调用的构造器为new ConnectionPool()。

RealCall.class

首先直接看getResponseWithInterceptorChain()的源码。

getResponseWithInterceptorChain()@RealCall.class

[java]view plaincopy 
         
 private Response getResponseWithInterceptorChain(boolean forWebSocket) throws IOException {  
     Interceptor.Chain chain = new ApplicationInterceptorChain(0, originalRequest, forWebSocket); //是我们传进来的Request  
     return chain.proceed(originalRequest);  
 }  

方法真是简单的一逼啊。利用客户请求构造一个ApplicationInterceptorChain对象，随后调用其proceed方法。我们接着往下走

ApplicationInterceptorChain.class@RealCall.class

[java]view plaincopy 
        
 class ApplicationInterceptorChain implements Interceptor.Chain{  
     private final int index;  
     private final Request request;  
     private final boolean forWebSocket;  
     ApplicationInterceptorChain(int index, Request request, boolean forWebSocket) {  
       this.index = index;  
       this.request = request;  
       this.forWebSocket = forWebSocket;  
     }  
     public Response proceed(Request request) throws IOException {  
       if (index < client.interceptors().size()) {  
         Interceptor.Chain chain = new ApplicationInterceptorChain(index + 1, request, forWebSocket);  
         Interceptor interceptor = client.interceptors().get(index);  
         Response interceptedResponse = interceptor.intercept(chain); //该方法内部会出现chain.proceed语句，即实现递归调用  
         return interceptedResponse; //最终上面的所有  
      }  
      return getResponse(request, forWebSocket);//当递归到最内层时，才会调用到该方法，完成实际的网络请求  
     }  
 }  

ApplicationInterceptorChain内部类还算简单，里面有一个index和一个request对象。proceed方法使用了递归，将用户的请求通过拦截器一层一层的包装最后得到一个全新的请求，在递归的最底层即所有的拦截器已经执行完毕后，则调用getResponse方法获取response，通过该请求得到的请求结果最后又利用拦截器一层层的包装最终得到一个全新的网络请求结果。直接这样说可能不太好理解，下面给出一个普通的拦截器使用例子：

[java]view plaincopy 
        
 class LoggingInterceptor implements Interceptor {  
   @Override public Response intercept(Interceptor.Chain chain) throws IOException {  
     Request request = chain.request();  
     long t1 = System.nanoTime();  
     logger.info(String.format("Sending request %s on %s%n%s",  
         request.url(), chain.connection(), request.headers()));  
     Response response = chain.proceed(request);  
     long t2 = System.nanoTime();  
     logger.info(String.format("Received response for %s in %.1fms%n%s",  
         response.request().url(), (t2 - t1) / 1e6d, response.headers()));  
     return response;  
   }  
 }  

这个拦截器很简单就是在请求发送前记录时间，并在结果返回之后记录时间，中间最重要的就是调用了chain.proceed(request)方法和返回一个Response对象，使得递归功能得以实现，否则加了该拦截器，请求将无法继续被执行。因此任何一个正常的迭代器都会出现Response response = chain.proceed(request); return response;这两行语句的。

ApplicationInterceptorChain拦截器的效果图如下。

chain.proceed方法的最底层是通过调用getResponse方法获得对应的response，接着看看该部分的源码。

getResponse()@RealCall.class

[java]view plaincopy 
        
 Response getResponse(Request request, boolean forWebSocket) throws IOException {  
     //step1 根据request的body设置request的http报头  
     RequestBody body = request.body();  
     if (body != null) {  
       Request.Builder requestBuilder = request.newBuilder();  
       MediaType contentType = body.contentType();  
       if (contentType != null) {  
         requestBuilder.header("Content-Type", contentType.toString());  
       }  
       long contentLength = body.contentLength();  
       if (contentLength != -1) {  
         requestBuilder.header("Content-Length", Long.toString(contentLength));  
         requestBuilder.removeHeader("Transfer-Encoding");  
       } else {  
         requestBuilder.header("Transfer-Encoding", "chunked");  
         requestBuilder.removeHeader("Content-Length");  
       }  
       request = requestBuilder.build();  
     }  
   
     //step2 给每个request创建一个HttpEngine，由该引擎负责网络请求  
     engine = new HttpEngine(client, request, false, false, forWebSocket, null, null, null);  
     int followUpCount = 0;  
     while (true) {  
       if (canceled) {  
         engine.releaseStreamAllocation();  
         throw new IOException("Canceled");  
       }  
   
       boolean releaseConnection = true;  
       try {  
         engine.sendRequest();  
         engine.readResponse();  
         releaseConnection = false;  
       } catch (RequestException e) {  
         // The attempt to interpret the request failed. Give up.  
         throw e.getCause();  
       } catch (RouteException e) {  
         // The attempt to connect via a route failed. The request will not have been sent.  
         HttpEngine retryEngine = engine.recover(e.getLastConnectException(), null);  
         if (retryEngine != null) {  
           releaseConnection = false;  
           engine = retryEngine;  
           continue;  
         }  
         // Give up; recovery is not possible.  
         throw e.getLastConnectException();  
       } catch (IOException e) {  
         // An attempt to communicate with a server failed. The request may have been sent.  
         HttpEngine retryEngine = engine.recover(e, null);  
         if (retryEngine != null) {  
           releaseConnection = false;  
           engine = retryEngine;  
           continue;  
         }  
         // Give up; recovery is not possible.  
         throw e;  
       } finally {  
         // We're throwing an unchecked exception. Release any resources.  
         if (releaseConnection) {  
           StreamAllocation streamAllocation = engine.close();  
           streamAllocation.release();  
         }  
       }  
       //正常情况下，前面已经正常执行了engine.sendRequest();  engine.readResponse();   
       Response response = engine.getResponse();  
       if (followUp == null) {  
         if (!forWebSocket) {  
           engine.releaseStreamAllocation();//成功获取到链接时将StreamAllocation和Connection解绑  
         }  
         return response;  
       }  
       //step3 正常情况下上面已经返回response，下面是一些异常情况的处理  
       ........  
     } //end of while(true)  
   }  

该方法首先设置request的head，随后由该request构建一个HttpEngine对象，并依次调用engine.sendRequest()、engine.readResponse()和engine.getResponse()方法。最后将得到的response结果，进行返回。下面我们就依次来分析一下HttpEngine的sendRequest()、readResponse()、getResponse()方法

HttpEngine.class

首先看一下该类的构造器

HttpEngine()@HttpEngine.class

[java]view plaincopy 
        
 public HttpEngine(OkHttpClient client, Request request, boolean bufferRequestBody,  
       boolean callerWritesRequestBody, boolean forWebSocket, StreamAllocation streamAllocation,  
       RetryableSink requestBodyOut, Response priorResponse) {  
     this.client = client;  
     this.userRequest = request;  
     this.bufferRequestBody = bufferRequestBody;  
     this.callerWritesRequestBody = callerWritesRequestBody;  
     this.forWebSocket = forWebSocket;  
     this.streamAllocation = streamAllocation != null  
         ? streamAllocation  
         : new StreamAllocation(client.connectionPool(), createAddress(client, request));  
     this.requestBodyOut = requestBodyOut;  
     this.priorResponse = priorResponse;  
   }  

这里我们主要关注的是传入的OkHttpClient client, Request request两个参数，这两个参数在HttpEngine中的命名分别为client和userRequest。此外还注意到构造器中对this.streamAllocation = streamAllocation != null ? streamAllocation : new StreamAllocation(client.connectionPool(), createAddress(client, request));的初始化。默认都是通过调用new StreamAllocation(client.connectionPool(), createAddress(client, request))获得StreamAllocation对象的。对StreamAllocation它主要负责对RealConnection的管理，我们先不看其源码，后面再讲。先看sendRequest()方法。

sendRequest()@HttpEngine.class

[java]view plaincopy 
        
 public void sendRequest() throws RequestException, RouteException, IOException {  
     ....  
     Request request = networkRequest(userRequest); //note1  
     InternalCache responseCache = Internal.instance.internalCache(client); //note2  
     Response cacheCandidate = responseCache != null? responseCache.get(request) : null;  
   
     long now = System.currentTimeMillis();  
     cacheStrategy = new CacheStrategy.Factory(now, request, cacheCandidate).get(); //note3  
     networkRequest = cacheStrategy.networkRequest;  
     cacheResponse = cacheStrategy.cacheResponse;  
     if (responseCache != null) { //OkHttpClient具备缓存功能  
       responseCache.trackResponse(cacheStrategy);  
     }  
     if (cacheCandidate != null && cacheResponse == null) { //在OkHttpClient缓存中得到response当时经过缓存策略分析该response无效  
       closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.  
     }  
     // 网络请求为空，且本地命中的缓存也为空，则返回错误的504http报文  
     if (networkRequest == null && cacheResponse == null) {  
       userResponse = new Response.Builder()  
           .request(userRequest)  
           .priorResponse(stripBody(priorResponse))  
           .protocol(Protocol.HTTP_1_1)  
           .code(504)  
           .message("Unsatisfiable Request (only-if-cached)")  
           .body(EMPTY_BODY)  
           .build();  
       return;  
     }  
     //网络请求为空，本地命中的缓存也不为空，返回本地命中的response  
     if (networkRequest == null) {  
       userResponse = cacheResponse.newBuilder()  
           .request(userRequest)  
           .priorResponse(stripBody(priorResponse))  
           .cacheResponse(stripBody(cacheResponse))  
           .build();  
       userResponse = unzip(userResponse);  
       return;  
     }  
   
     //note4  
     boolean success = false;  
     try {  
       httpStream = connect();  
       httpStream.setHttpEngine(this);  
   
       if (writeRequestHeadersEagerly()) {  
         long contentLength = OkHeaders.contentLength(request);  
         if (bufferRequestBody) {  
           if (contentLength > Integer.MAX_VALUE) {  
             throw new IllegalStateException("Use setFixedLengthStreamingMode() or "  
                 + "setChunkedStreamingMode() for requests larger than 2 GiB.");  
           }  
   
           if (contentLength != -1) {  
             // Buffer a request body of a known length.  
             httpStream.writeRequestHeaders(networkRequest);  
             requestBodyOut = new RetryableSink((int) contentLength);  
           } else {  
             // Buffer a request body of an unknown length. Don't write request headers until the  
             // entire body is ready; otherwise we can't set the Content-Length header correctly.  
             requestBodyOut = new RetryableSink();  
           }  
         } else {  
           httpStream.writeRequestHeaders(networkRequest);  
           requestBodyOut = httpStream.createRequestBody(networkRequest, contentLength);  
         }  
       }  
       success = true;  
     } finally {  
       // If we're crashing on I/O or otherwise, don't leak the cache body.  
       if (!success && cacheCandidate != null) {  
         closeQuietly(cacheCandidate.body());  
       }  
     }  
   }  

1、该方法很长，我们慢慢消化。networkRequest(userRequest);方法功能上是对request中的http报头进行相应修改，如cookies，使其符合Http数据报的协议规范。

2、对于InternalCache responseCache = Internal.instance.internalCache(client)，一脸的懵逼，之前从来没有见过，不过不要方，它在我们构建OkHttpClient的时候被初始化的！让我们回头撸一把OkHttpClient，果然发现有下面的一段内容， Internal.instance = new Internal() { .....}。这下我们就知道Internal.instance对象在构造OkHttpClient的时候就创建好了。实际上Internal.instance.internalCache(client)等价于 client.internalCache();即得到一个缓存操作符。随后调用缓存操作符的get方法得到对应的缓存结果。

3、cacheStrategy = new CacheStrategy.Factory(now, request, cacheCandidate).get();利用一定的缓存策略对request和cacheCandidate进行处理，并对HttpEngine中的networkRequest和cacheResponse对象进行赋值。如果得到的networkRequest==null,表明缓存策略认为该请求不需要访问网络，如果cacheResponse==null表明该请求在缓存中没有找到想要的结果。可能有童鞋不太懂为何要这样做，其实举个栗子就懂了，就是比如我们本地有缓存内容，但是可能该内容存放时间太长已经过期了，系统不能再使用该缓存，需要重新去网上下载。如果对该部分比较感兴趣参考下一篇博客《OkHttp深入学习（三）——Cache》，本节不对其进行详细说明。

4、经过上面的分析如果没有从缓存中得到预期的结果，那么需要通过网络得到预期的response。首先执行的是 httpStream = connect(); 该方法内部调用streamAllocation.newStream()方法；骚年你还记得吗？streamAllocation是在构造HttpEngine时创建的对象。调用的构造器为new StreamAllocation(client.connectionPool(), createAddress(client, request)); 对于OkHttpClient的链接池connectionPool部分参考后面的OkHttpClient.class部分的分析。构造完StreamAllocation之后调用其newStream方法。得到一个HttpStream对象，该对象是一个已经跟服务器端进行了三次握手的链接，通过该对象就能向服务器发送接收Http报文数据。对于connect()后面的内容，一般情况我们不太会遇到，下面直接开始分析readResponse()方法

readResponse()@HttpEngine.class

[java]view plaincopy 
        
 public void readResponse() throws IOException {  
     if (userResponse != null) {  
       return; // 已经通过缓存获取到了响应  
     }  
     if (networkRequest == null && cacheResponse == null) {  
       throw new IllegalStateException("call sendRequest() first!");  
     }  
     if (networkRequest == null) {  
       return; // No network response to read.  
     }  
     //note1  
     Response networkResponse;  
     if (forWebSocket) {  
       httpStream.writeRequestHeaders(networkRequest);  
       networkResponse = readNetworkResponse();  
     } else if (!callerWritesRequestBody) {  
       networkResponse = new NetworkInterceptorChain(0, networkRequest).proceed(networkRequest);  
     } else {  
       // Emit the request body's buffer so that everything is in requestBodyOut.  
       if (bufferedRequestBody != null && bufferedRequestBody.buffer().size() > 0) {  
         bufferedRequestBody.emit();  
       }  
   
       // Emit the request headers if we haven't yet. We might have just learned the Content-Length.  
       if (sentRequestMillis == -1) {  
         if (OkHeaders.contentLength(networkRequest) == -1  
             && requestBodyOut instanceof RetryableSink) {  
           long contentLength = ((RetryableSink) requestBodyOut).contentLength();  
           networkRequest = networkRequest.newBuilder()  
               .header("Content-Length", Long.toString(contentLength))  
               .build();  
         }  
         httpStream.writeRequestHeaders(networkRequest);  
       }  
   
       // Write the request body to the socket.  
       if (requestBodyOut != null) {  
         if (bufferedRequestBody != null) {  
           // This also closes the wrapped requestBodyOut.  
           bufferedRequestBody.close();  
         } else {  
           requestBodyOut.close();  
         }  
         if (requestBodyOut instanceof RetryableSink) {  
           httpStream.writeRequestBody((RetryableSink) requestBodyOut);  
         }  
       }  
   
       networkResponse = readNetworkResponse();  
     }  
     //note 2  
     receiveHeaders(networkResponse.headers());  
     //note 3  
     // If we have a cache response too, then we're doing a conditional get.  
     if (cacheResponse != null) {  
       if (validate(cacheResponse, networkResponse)) {  
         userResponse = cacheResponse.newBuilder()  
             .request(userRequest)  
             .priorResponse(stripBody(priorResponse))  
             .headers(combine(cacheResponse.headers(), networkResponse.headers()))  
             .cacheResponse(stripBody(cacheResponse))  
             .networkResponse(stripBody(networkResponse))  
             .build();  
         networkResponse.body().close();  
         releaseStreamAllocation();//调用streamAllocation.release();方法，作用就是将StreamAllocation和内部的connection脱离关系  
   
         // Update the cache after combining headers but before stripping the  
         // Content-Encoding header (as performed by initContentStream()).  
         InternalCache responseCache = Internal.instance.internalCache(client);  
         responseCache.trackConditionalCacheHit();  
         responseCache.update(cacheResponse, stripBody(userResponse));  
         userResponse = unzip(userResponse);  
         return;  
       } else {  
         closeQuietly(cacheResponse.body());  
       }  
     }  
     //note 4  
     userResponse = networkResponse.newBuilder()  
         .request(userRequest)  
         .priorResponse(stripBody(priorResponse))  
         .cacheResponse(stripBody(cacheResponse))  
         .networkResponse(stripBody(networkResponse))  
         .build();  
     //note 5  
     if (hasBody(userResponse)) {  
       maybeCache();  
       userResponse = unzip(cacheWritingResponse(storeRequest, userResponse));  
     }  
   }  

1、对于一般情况我们会执行networkResponse = new NetworkInterceptorChain(0, networkRequest).proceed(networkRequest)方法，与ApplicationInterceptorChain的功能类似，这里是在向网络服务器发送数据前嵌套几层拦截器，采用递归方法实现。递归方法的最底层会调用Response response = readNetworkResponse();方法得到网络返回数据，之后又通过拦截器进行相应处理。不过无论通过哪条路径最终都是通过调用readNetworkResponse()方法获得Response的。这里给出NetWorkInterceptorChain的工作原理图

2、将得到的networkResponse中的cookies存入OkHttpClient中的cookieJar对象中，该对象默认是空的，即不能存入任何url的cookie，如果我们在构造OkHttpClient的时候给予它一个CookieJar那么OkHttpClient就会将每次获得的cookie都存入我们定义的CookieJar中。一般是把url作为key，cookies作为value。

3、如果该Request在OkHttpC中的缓存中存在对应的Response，则更新该缓存

4、利用获得的networkResponse给userResponse赋值

5、根据得到的Response判断是否存入缓存

因为上面得到的Response来自于方法readNetworkResponse()，那么接下来我们来分析一下该方法是如何工作的。

readNetworkResponse()@HttpEngine.class

[java]view plaincopy 
        
 private Response readNetworkResponse() throws IOException {  
     httpStream.finishRequest();  
     Response networkResponse = httpStream.readResponseHeaders()  
         .request(networkRequest)  
         .handshake(streamAllocation.connection().handshake())  
         .header(OkHeaders.SENT_MILLIS, Long.toString(sentRequestMillis))  
         .header(OkHeaders.RECEIVED_MILLIS, Long.toString(System.currentTimeMillis()))  
         .build();  
     if (!forWebSocket) {  
       networkResponse = networkResponse.newBuilder()  
           .body(httpStream.openResponseBody(networkResponse))  
           .build();  
     }  
     if ("close".equalsIgnoreCase(networkResponse.request().header("Connection"))  
         || "close".equalsIgnoreCase(networkResponse.header("Connection"))) {  
       streamAllocation.noNewStreams();  
     }  
     return networkResponse;  
   }  

该方法逻辑很简单就是调用httpStream.readResponseHeaders()方法和httpStream.openResponseBody方法获取到Response。那么我们继续看HttpStream的readResponseHeaders方法和httpStream.openResponseBody方法。走到这里突然你可能忘了HttpStream从哪里得到的。这里我们复习一下。在构造HttpEngine时创建的对象的时候我们创建了一个streamAllocation对象。调用的构造器为new StreamAllocation(client.connectionPool(), createAddress(client, request)); 对于OkHttpClient的链接池connectionPool部分参考后面的OkHttpClient.class部分的分析。构造完StreamAllocation之后调用其newStream方法，得到一个HttpStream对象。我们先看一下getResponse方法，随后即可进入StreamAllocation和其newStream方法学习。

getResponse()@HttpEngine.class

[java]view plaincopy 
         
 public Response getResponse() {  
     if (userResponse == null) throw new IllegalStateException();  
     return userResponse;  
 }  

该方法很简单就是返回HttpEngine中的userResponse域。

StreamAllocation.class

StreamAllocation@StreamAllocation.class

[java]view plaincopy 
        
 public StreamAllocation(ConnectionPool connectionPool, Address address) {  
     this.connectionPool = connectionPool;  
     this.address = address;  
     this.routeSelector = new RouteSelector(address, routeDatabase());  
   }  

这里额外的创建了一个RouteSelector对象，该对象由Address和路由数据库构造。

routeDatabase()@StreamAllocation.class

[java]view plaincopy 
        
 private RouteDatabase routeDatabase() {  
     return Internal.instance.routeDatabase(connectionPool);  
 }  

该方法其实返回的就是connectionPool.routeDatabase; 该routeDatabase实际上用于存储之前访问失败的路由代理。上面看完了StreamAllocation的构造器，赶紧来看看其newStream方法。

newStream()@StreamAllocation.class

[java]view plaincopy 
        
 public HttpStream newStream(int connectTimeout, int readTimeout, int writeTimeout,  
       boolean connectionRetryEnabled, boolean doExtensiveHealthChecks)  
       throws RouteException, IOException {  
     try {  
       RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout, //note1  
           writeTimeout, connectionRetryEnabled, doExtensiveHealthChecks);  
   
       HttpStream resultStream; //note2  
       if (resultConnection.framedConnection != null) {  
         resultStream = new Http2xStream(this, resultConnection.framedConnection); //在这里支持HTTP/2 and SPDY黑科技  
       } else {  
         resultConnection.socket().setSoTimeout(readTimeout);  
         resultConnection.source.timeout().timeout(readTimeout, MILLISECONDS);  
         resultConnection.sink.timeout().timeout(writeTimeout, MILLISECONDS);  
         resultStream = new Http1xStream(this, resultConnection.source, resultConnection.sink); //支持1.1协议；  
       }  
   
       synchronized (connectionPool) {  
         stream = resultStream;  
         return resultStream;  
       }  
     } catch (IOException e) {  
       throw new RouteException(e);  
     }  
   }  

1、首先利用findHealthyConnection()方法得到一个RealConnection对象。得到了RealConnection对象意味着我们已经跟服务端有了一条通信链路了，而且通过RealConnection的source 和 sink分别实现向管道中读写数据。

2、根据请求的协议不同创建不同的HttpStream，一般情况下我们创建的都是Http1xStream对象，即Http1.X协议。该对象功能就是对request中的数据按照对应的http协议中的格式暴力的通过sink写入到管道流中，对response中的数据通过source读取并进行解析。

该部分的重点转移到了方法findHealthyConnection方法，往下看。

findHealthyConnection()@StreamAllocation.class

[java]view plaincopy 
        
 while (true) {  
       RealConnection candidate = findConnection(connectTimeout, readTimeout, writeTimeout,  
           connectionRetryEnabled);  
       // If this is a brand new connection, we can skip the extensive health checks.  
       synchronized (connectionPool) {  
         if (candidate.successCount == 0) {  
           return candidate;  
         }  
       }  
       // Otherwise do a potentially-slow check to confirm that the pooled connection is still good.  
       if (candidate.isHealthy(doExtensiveHealthChecks)) {  
         return candidate;  
       }  
       connectionFailed(new IOException());  
 }  

该方法的大体流程就是先通过findConnection获取到一个可用的链接，随后对该链接进行一定的健康性检查，如果不通过则继续调用findConnection寻找直到找到为止。继续看findConnection方法

findConnection()@StreamAllocation.class

[java]view plaincopy 
        
 private RealConnection findConnection(int connectTimeout, int readTimeout, int writeTimeout,  
       boolean connectionRetryEnabled) throws IOException, RouteException {  
     Route selectedRoute;  
     synchronized (connectionPool) {  
       if (released) throw new IllegalStateException("released");  
       if (stream != null) throw new IllegalStateException("stream != null");  
       if (canceled) throw new IOException("Canceled");  
       //note 1  
       RealConnection allocatedConnection = this.connection;  
       if (allocatedConnection != null && !allocatedConnection.noNewStreams) {  
         return allocatedConnection;  
       }  
   
       //note 2  
       RealConnection pooledConnection = Internal.instance.get(connectionPool, address, this);  
       if (pooledConnection != null) {  
         this.connection = pooledConnection;  
         return pooledConnection;  
       }  
       selectedRoute = route;   
       //如果是第一次走到这里 则route为null  
     }  
   
     if (selectedRoute == null) {  
       selectedRoute = routeSelector.next();  
        //note 3  
       synchronized (connectionPool) {  
         route = selectedRoute;  
       }  
     }  
     RealConnection newConnection = new RealConnection(selectedRoute);   
      //note 4  
     acquire(newConnection);   
     //note 5  
     synchronized (connectionPool) {  
       Internal.instance.put(connectionPool, newConnection);    
       //note 6  
       this.connection = newConnection;  
       if (canceled) throw new IOException("Canceled");  
     }  
   
     newConnection.connect(connectTimeout, readTimeout, writeTimeout, address.connectionSpecs(), connectionRetryEnabled);   
      //note7  
     routeDatabase().connected(newConnection.route());     
     //note 8  
     return newConnection;  
   }  

1、如果当前StreamAllocation对象中的RealConnection不为空，且没有新的Stream则直接返回该RealConnection。

2、从线程池中获取一个RealConnection对象，等价于直接调用connectionPool.get(address, streamAllocation)，如果获取到了RealConnection则直接返回该RealConnection。step1和step2得到的RealConnection都是已经跟服务器完成了三次握手链接的连接。

3、利用routeSelector.next()方法得到一个route对象；routeSelector在构造StreamAllocation时创建的跟我们的request是绑定的；每个链接都需要选择一个代理,IP地址，TLS。

4、通过得到的route对象构建一个RealConnection对象，该route包含了客户请求链接的ip地址和端口号等信息。

5、connection.allocations.add(new WeakReference<>(this)); 为当前StreamAllocation创建一个弱引用，添加到RealConnection的allocation中,即增加其引用计数。

6、将上面创建的RealConnection添加到OkHttpClient的ConnectionPool链接池中。

7、调用RealConnection的connect方法，创建链接，完成跟目标地址的的三次握手。

8、将newConnection对应的route从routeDatabase中移除出去，routeDatabase实际上维护一个集合，里面存入的route都是failed

最后给大家科普StreamAllocation最后一个方法，该方法用于回收StreamAllocation对应的Connection。调用StreamAllocation的noNewStreams和release方法都会调用到该方法。一般在任务执行结束后都会通过HttpEngine的releaseStreamAllocation()方法间接调用StreamAllocation的deallocate方法将RealConnection和StreamAllocation进行解绑。

deallocate@S treamAllocation.class

[java]view plaincopy 
        
 private void deallocate(boolean noNewStreams, boolean released, boolean streamFinished) {  
     RealConnection connectionToClose = null;  
     synchronized (connectionPool) {  
       if (streamFinished) {  
         this.stream = null;  
       }  
       if (released) {  
         this.released = true;  
       }  
       if (connection != null) {  
         if (noNewStreams) {  
           connection.noNewStreams = true; //noNewStreams表明该链接不能提供给新Stream使用  
         }  
         if (this.stream == null && (this.released || connection.noNewStreams)) {  
           release(connection); //note1  
           if (connection.allocations.isEmpty()) { //note2  
             connection.idleAtNanos = System.nanoTime();  
             if (Internal.instance.connectionBecameIdle(connectionPool, connection)) { //note3  
               connectionToClose = connection;  
             }  
           }  
           connection = null;  
         }  
       }  
     }  
     if (connectionToClose != null) { //note4  
       Util.closeQuietly(connectionToClose.socket());  
     }  
   }  

1、完成的工作就是把当前的StreamAllocation从Realconnection的allocations队列中移除出去。如果没有在RealConnection的Allocation集合中找到对StreamAllocation的引用则抛出异常。

2、Connection的Allocation队列如果为空，表明该RealConnection没有被任何StreamAllocation使用。

3、Internal.instance.connectionBecameIdle(connectionPool, connection)等价于pool.connectionBecameIdle(connection); 该方法内部判断connection.noNewStreams为真，即该Connection不能给新的stream提供服务，则将该Connection从Connectionpool中移除出去，同时返回true。否则让Connectionpool的清理线程去处理，返回false。

4、第三步中返回结果为真，即RealConnection已经从ConnectionPool中移除，则在此处强制调用socket的close方法，关闭套接字，回收网络资源。

继续往下走，那就是RealConnection对象的创建和其connected方法的实现。RealConnection这也是我们所能走到的最底层的类了。胜利的曙光要来了~

RealConnection.class

private Socket rawSocket; //最底层socket

public Socket socket; //应用层socket

public final List<Reference<StreamAllocation>> allocations = new ArrayList<>();

RealConnection@RealConnection.class

[java]view plaincopy 
         
 public RealConnection(Route route) {  
     this.route = route;  
 }  

connect@RealConnection.class

[java]view plaincopy 
         
 public void connect(int connectTimeout, int readTimeout, int writeTimeout,List<ConnectionSpec> connectionSpecs, boolean connectionRetryEnabled) throws RouteException {  
     if (protocol != null) throw new IllegalStateException("already connected");  
     RouteException routeException = null;  
     ConnectionSpecSelector connectionSpecSelector = new ConnectionSpecSelector(connectionSpecs);  
     Proxy proxy = route.proxy();  
     Address address = route.address();  
     if (route.address().sslSocketFactory() == null  
         && !connectionSpecs.contains(ConnectionSpec.CLEARTEXT)) {  
       throw new RouteException(new UnknownServiceException(  
           "CLEARTEXT communication not supported: " + connectionSpecs));  
     }  
     while (protocol == null) {  
       try {  
         //note1  
         rawSocket = proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP  
             ? address.socketFactory().createSocket() //对于ssl的情况  
             : new Socket(proxy);  
         //note 2 上面调用的方法已经很底层了！！使用的是jdk中的内容了  
         connectSocket(connectTimeout, readTimeout, writeTimeout, connectionSpecSelector);  
       } catch (IOException e) {  
         ......  
       }  
     }  
   }  

1、利用proxy的type值判断构造一个怎样的Socket，是普通Socket还是SSL性质的Socket。

2、调用 connectSocket方法。

connectSocket()@RealConnection.class

[java]view plaincopy 
         
 private void connectSocket(int connectTimeout, int readTimeout, int writeTimeout, ConnectionSpecSelector connectionSpecSelector) throws IOException {   
     rawSocket.setSoTimeout(readTimeout);  
     try {  
       //note 1  
       Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);  
     } catch (ConnectException e) {  
       throw new ConnectException("Failed to connect to " + route.socketAddress());  
     }  
     //note 2  
     source = Okio.buffer(Okio.source(rawSocket));  
     sink = Okio.buffer(Okio.sink(rawSocket));  
     if (route.address().sslSocketFactory() != null) {  
       connectTls(readTimeout, writeTimeout, connectionSpecSelector);  
     } else {  
       protocol = Protocol.HTTP_1_1;  
       socket = rawSocket;  
     }  
     if (protocol == Protocol.SPDY_3 || protocol == Protocol.HTTP_2) {  
       socket.setSoTimeout(0); // Framed connection timeouts are set per-stream.  
       FramedConnection framedConnection = new FramedConnection.Builder(true)  
           .socket(socket, route.address().url().host(), source, sink)  
           .protocol(protocol)  
           .listener(this)  
           .build();  
       framedConnection.sendConnectionPreface();  
       // Only assign the framed connection once the preface has been sent successfully.  
       this.allocationLimit = framedConnection.maxConcurrentStreams();  
       this.framedConnection = framedConnection;  
     } else {  
       this.allocationLimit = 1;  
     }  
   }  

这部分是最激动人心的地方，这里我们就要开始跟外界进行通信了~，也是我们这次对okhttp项目学习的最底层了。

1、Platform.get()等价于Platform.findPlatform();结果是根据平台的不同得到不同的Platform对象，使用Class.forName方法获取对应的类对象；下面假设平台是Android平台。Platform. get(). connectSocket() 方法等价于调用socket.connect(address, connectTimeout); 完成了TCP三次握手

2、source = Okio.buffer(Okio.source(rawSocket))；就是从rawSocket获得一个InputStream再用buffer包装一下。 sink = Okio.buffer(Okio.sink(rawSocket)); 就是从rawSocket获得一个OutputStream再用buffer包装一下。到此为止我们已经获得了跟服务器通信的链路。

在本节结束之前我们最后对ConnectionPool和RouteSelector进行介绍

ConnectionPool.class

[java]view plaincopy 
          
 private static final Executor executor = new ThreadPoolExecutor(0 /* corePoolSize */,  
       Integer.MAX_VALUE /* maximumPoolSize */, 60L /* keepAliveTime */, TimeUnit.SECONDS,  
       new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp ConnectionPool", true));  
 //该类跟Dispatcher.class一样创建了一个线程池，用于维护管理RealConnection  
 final RouteDatabase routeDatabase = new RouteDatabase();  
 //该对象创建一个RouteDataBase对象，是一个路由数据库，该数据库其实很简单，里面维护了一个private final Set<Route> failedRoutes = new LinkedHashSet<>()集合。存放失败的路由数据  
 private final Deque<RealConnection> connections = new ArrayDeque<>();  
 //该集合是ConnectionPool用于存储当前系统经历过三次握手可用的RealConnection  

ConnectionPool()@ConnectionPool.class

[java]view plaincopy 
            
 public ConnectionPool() {  
     this(5, 5, TimeUnit.MINUTES);  
 }  
 public ConnectionPool(int maxIdleConnections, long keepAliveDuration, TimeUnit timeUnit) {  
     this.maxIdleConnections = maxIdleConnections;  //最大空闲连接数  
     this.keepAliveDurationNs = timeUnit.toNanos(keepAliveDuration);  
     // Put a floor on the keep alive duration, otherwise cleanup will spin loop.  
     if (keepAliveDuration <= 0) {  
       throw new IllegalArgumentException("keepAliveDuration <= 0: " + keepAliveDuration);  
     }  
   }  

创建的连接池默认维护5条自由链接，且自由链接空闲时间最多为5分钟。RealConnection是否是自由态由RealConnection中存储的Allocations集合的大小决定。如果RealConnection.noNewStream==true则表明该RealConnection拒绝为新StreamAllocation服务，往往意味着等待被回收。

get()@ConnectionPool.class

[java]view plaincopy 
            
 RealConnection get(Address address, StreamAllocation streamAllocation) {  
     assert (Thread.holdsLock(this));  
     for (RealConnection connection : connections) {  
       if (connection.allocations.size() < connection.allocationLimit //note1  
           && address.equals(connection.route().address) //note2  
           && !connection.noNewStreams) { //note3  
         streamAllocation.acquire(connection); //note4  
         return connection;  
       }  
     }  
     return null;  
   }  

该方法的作用就是尝试从集合connections中获取到一个可重复利用的RealConnection。
1、connection.allocations.size() < connection.allocationLimit；判断该RealConnection所服务的StreamAllocation数量是否小于门限值。
2、address.equals(connection.route().address)；该Connection的hostname地址等于方法参数的address值。
3、connection.noNewStreams能否被其它StreamAllocation。
4、streamAllocation.acquire(connection);等价于 connection.allocations.add(streamAllocation) ，将StreamAllocation添加到RealConnection的allocations集合中。增加RealConnection的引用计数。当该引用计数为0时考虑回收该RealConnection。

put()@ConnectionPool.class

[java]view plaincopy 
            
 void put(RealConnection connection) {  
     assert (Thread.holdsLock(this));  
     if (!cleanupRunning) {  
       cleanupRunning = true;  
       executor.execute(cleanupRunnable);//note1  
     }  
     connections.add(connection);//note2  
   }  

1、对connections集合进行维护，cleanupRunnable的run方法内部会执行cleanup方法，下面我们将对其进行介绍

2、将RealConnection加入到ConnectionPool的connects集合

cleanup()@ConnectionPool.class

[java]view plaincopy 
            
 long cleanup(long now) {  
     int inUseConnectionCount = 0;  
     int idleConnectionCount = 0;  
     RealConnection longestIdleConnection = null;  
     long longestIdleDurationNs = Long.MIN_VALUE;  
     // Find either a connection to evict, or the time that the next eviction is due.  
     synchronized (this) {  
       for (Iterator<RealConnection> i = connections.iterator(); i.hasNext(); ) {  
         RealConnection connection = i.next();  
         // note1  
         if (pruneAndGetAllocationCount(connection, now) > 0) {  
           inUseConnectionCount++;  
           continue;  
         }  
         idleConnectionCount++;  
         // If the connection is ready to be evicted, we're done.  
         long idleDurationNs = now - connection.idleAtNanos; //note 2  
         if (idleDurationNs > longestIdleDurationNs) {  
           longestIdleDurationNs = idleDurationNs;  
           longestIdleConnection = connection;  
         }  
       } // end of for  
       if (longestIdleDurationNs >= this.keepAliveDurationNs  
           || idleConnectionCount > this.maxIdleConnections) { //note3  
         connections.remove(longestIdleConnection);  
       } else if (idleConnectionCount > 0) {  
         //返回下次正常情况下次需要检查的等待时间  
         return keepAliveDurationNs - longestIdleDurationNs;  
       } else if (inUseConnectionCount > 0) {  
         //返回下次正常情况下次需要检查的等待时间  
         return keepAliveDurationNs;  
       } else {  
         //池中没有自由链接，也没有正在使用的链接  
         cleanupRunning = false;  
         return -1;  
       }  
     }  
     closeQuietly(longestIdleConnection.socket()); //note4  
     // Cleanup again immediately.  
     return 0;  
   }  

Connectionpool维护其链接池中链接；该方法是在cleanupRunnable中的run方法中被调用。

1、缩减和获得与该Connection绑定的StreamAllocation数量，如果数量不为0，证明该RealConnection正在被某个StreamAllocation使用，否则进行下面的步骤。

2、获取该Connection的自由时间，如果该链接自由时间超过当前系统所记录的Connection最长自由时间，则刷新当前记录最大值。这是标记过程

3、执行到这里，已经得到了当前系统空闲线程等待的最长时间，如果该时间大于系统设定的最大自由时间或自由链接数大于系统所能维护的最大自由链接数，则将该RealConnection从链接池中移除出去。

4、执行到这里，表明刚刚有一个链接从连接池中被移出，此处将关闭该RealConnection对应的socket，即执行socket.close().

connectionBecameIdle@ConnectionPool.class

[java]view plaincopy 
            
 boolean connectionBecameIdle(RealConnection connection) {  
     assert (Thread.holdsLock(this));  
     if (connection.noNewStreams || maxIdleConnections == 0) {  
       connections.remove(connection);  
       return true;  
     } else {  
       notifyAll(); // Awake the cleanup thread: we may have exceeded the idle connection limit.  
       return false;  
     }  
   }  

该方法在StreamAllocation的deallocate中被调用。用于将connection回收，或者将RealConnection变成自由态。

我们对ConnectionPool做个小结：

Connection pool 创建了一个线程池，用于维护池中的自由链接数，RealConnection采用引用计数的方法判断一个Connection是否是自由态，如果RealConnection的Allocations集合为空则判断为自由态。最后采用标记清除的算法实现对废弃RealConnection的垃圾回收。当自由态链接数大于门限或者链接空闲时间超过门限值时则对该RealConnection资源进行回收，具体工作就是将RealConnection从ConnectionPool的connections集合中移出，底层调用socket.close()关闭网络连接。

RouteSelector.class

在StreamAllocation的findConnection方法中在构造RealConnection之前是需要获得一个route对象的，而route对象的获取是通过调用routeSelector的next方法来获取的。该route对象包含了我的url请求对应的ip地址和对应端口号。

[java]view plaincopy 
           
 /* State for negotiating the next proxy to use. */  
 private List<Proxy> proxies = Collections.emptyList();  
 private int nextProxyIndex;  
 /* State for negotiating the next socket address to use. */  
 private List<InetSocketAddress> inetSocketAddresses = Collections.emptyList();  
 private int nextInetSocketAddressIndex;  
 private final List<Route> postponedRoutes = new ArrayList<>();  

RouteSelector()@ RouteSelector.class

[java]view plaincopy 
           
 public RouteSelector(Address address, RouteDatabase routeDatabase) {  
     this.address = address;  
     this.routeDatabase = routeDatabase;  
     resetNextProxy(address.url(), address.proxy());  
 }  

该构造其中的Address参数是在HttpEngine构建StreamAllocation时创建的，创建方法是通过调用HttpEngine的createAddress(client, request)方法来获得的，方法参数分别为OkHttpClient和Request。在RouteSelector的构造器中会调用resetNextProxy方法，参数为客户请求的url和对应的代理，一般情况刚开始时代理是空。

resetNextProxy()@ RouteSelector.class

[java]view plaincopy 
           
 private void resetNextProxy(HttpUrl url, Proxy proxy) {  
     if (proxy != null) {  
       //note1  
       proxies = Collections.singletonList(proxy);  
     } else {  
       proxies = new ArrayList<>();  
       List<Proxy> selectedProxies = address.proxySelector().select(url.uri()); //note2  
       if (selectedProxies != null) proxies.addAll(selectedProxies);  
       // Finally try a direct connection. We only try it once!  
       proxies.removeAll(Collections.singleton(Proxy.NO_PROXY));  
       proxies.add(Proxy.NO_PROXY);  
     }  
     nextProxyIndex = 0;  
 }  

1、如果代理不为空，则直接对proxies赋值

2、address.proxySelector()等价于client.proxySelector()，后者默认等价于ProxySelector.getDefault()等价于new java,net.ProxySelectorImpl();经历这么一堆等价于其实简单讲就是调用address.proxySelector()等于创建一个java,net.ProxySelectorImpl()对象。随后调用该对象的select方法获取与该url对应的Proxy

下面我们就来看看next方法具体完成的操作。

next()@ RouteSelector.class

[java]view plaincopy 
           
 public Route next() throws IOException {  
     if (!hasNextInetSocketAddress()) {  
       if (!hasNextProxy()) {  
         if (!hasNextPostponed()) {  
           //前面三个队列都为空  
           throw new NoSuchElementException();  
         }//end if 3  
         return nextPostponed();//返回最后一个之前失败的route  
       }//end if 2  
       lastProxy = nextProxy();//note1  
     }//end if 1  
     lastInetSocketAddress = nextInetSocketAddress(); //note 2  
     Route route = new Route(address, lastProxy, lastInetSocketAddress);  //note 3  
     if (routeDatabase.shouldPostpone(route)) {  //note 4  
       postponedRoutes.add(route); //note 5  
       return next(); //note 6  
     }  
     return route; //返回可以用的route  
   }  

1、首先运行到这里，获取下一个代理，同时刷新集合inetSocketAddresses的数据

2、获取到InetSocketAddress

3、利用前面得到的代理和SocketAddress构造一个Route

4、查找route是否存在于routeDatabase中，即检验生成的route是不是可用

5、step4返回真，该route加入到postponedRoutes集合中，如果最后所有的代理都试过了还是不行，则还会将该route重新再尝试一次

6、递归调用

nextProxy()@ RouteSelector.class

[java]view plaincopy 
            
 private Proxy nextProxy() throws IOException {  
     if (!hasNextProxy()) {  
       throw new SocketException("No route to " + address.url().host()  
           + "; exhausted proxy configurations: " + proxies);  
     }  
     Proxy result = proxies.get(nextProxyIndex++);//note1  
     resetNextInetSocketAddress(result);  
     return result;  
 }  

从Proxies对象中获取一个Proxy对象。proxies的值是在resetNextProxy()方法中获得的

resetNextInetSocketAddress()@ RouteSelector.class

[java]view plaincopy 
            
 private void resetNextInetSocketAddress(Proxy proxy) throws IOException {  
     // Clear the addresses. Necessary if getAllByName() below throws!  
     inetSocketAddresses = new ArrayList<>();  
     String socketHost;  
     int socketPort;  
     if (proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.SOCKS) {  
       socketHost = address.url().host();  
       socketPort = address.url().port();  
     } else {  
       SocketAddress proxyAddress = proxy.address();  
       if (!(proxyAddress instanceof InetSocketAddress)) {  
         throw new IllegalArgumentException(  
             "Proxy.address() is not an " + "InetSocketAddress: " + proxyAddress.getClass());  
       }  
       InetSocketAddress proxySocketAddress = (InetSocketAddress) proxyAddress;  
       socketHost = getHostString(proxySocketAddress);  
       socketPort = proxySocketAddress.getPort();  
     }  
     //获取得到Address对应的IP和Port  
     if (socketPort < 1 || socketPort > 65535) {  
       throw new SocketException("No route to " + socketHost + ":" + socketPort  
           + "; port is out of range");  
     }  
     if (proxy.type() == Proxy.Type.SOCKS) {  
       inetSocketAddresses.add(InetSocketAddress.createUnresolved(socketHost, socketPort));  
     } else {  
       // Try each address for best behavior in mixed IPv4/IPv6 environments.  
       List<InetAddress> addresses = address.dns().lookup(socketHost);  //DNS查询的结果 url对应多个ip地址和端口号  
       for (int i = 0, size = addresses.size(); i < size; i++) {  
         InetAddress inetAddress = addresses.get(i);  
         inetSocketAddresses.add(new InetSocketAddress(inetAddress, socketPort));  
       }  
     }  
     nextInetSocketAddressIndex = 0;  
 }  

根据参数Proxy的值，得到一个java.net.InetSocketAddress类型对象，该对象包含了请求url对应的ip和端口信息。

至此我们对于okhttp的网络通信功能的实现进行了了解，下面对本节进行一下总结：

1、该部分的层次关系有这样的形式：httpEngine->httpStream->RealConnection。

2、无论是同步还是异步的请求最终都是通过getResponseWithInterceptorChain()方法来获得对应的Response。在真实的网络请求之前会使用ApplicationInterceptorChain拦截器对请求进行拦截。之后利用request和OkHttpClient创建一个HttpEngine对象，该对象持有有一个对StreamAllocation对象的引用，通过调用该对象的engine.sendRequest()方法发送请求，通过调用engine.readResponse();方法读取响应数据，同时给HttpEngine中的userResponse域赋值，最后通过engine.getResponse()返回HttpEngine中的userResponse域。

3、 engine.sendRequest()方法，在通过HttpEngine的sendRequest方法发送请求的到网络上时，会先去OkHttpClient的Cache中查找是否有对应的Response数据，如果有则直接对userResponse进行赋值并返回，如果没有则通过StreamAllocation的newStream方法获得的HttpStream对象，随后利用该对象访问网络的响应。StreamAllocation的newstream方法首先从OKHttpClient中的链接池connection s中尝试获取到RealConnection对象，如果没有获得则利用Route对象创建一个RealConnection，该route是由OkHttpClient和request共同构建得到的，里面有请求主机的对应IP和端口等信息，随后调用该对象的connect方法，操作一个socket完成跟指定主机三次握手。随后将该connection加入到OkHttpClient的链接池中。将上面得到的RealConnection根据不同的Http协议创建不同的HttpStream对象，该对象的作用是根据不同的Http协议，将用户的请求转换成特定的格式后通过RealConnection写入到对应ip的服务端中，然后对通过RealConnection读取到的数据进行解析。

4、engine.readResponse()方法，该方法首先检测usrResponse是否为空，即是否通过上面的sendRequest方法已经获得了缓存Response，有则直接返回usrResponse，如果没有获得则一般情况下会通过networkResponse = new NetworkInterceptorChain(0, networkRequest).proceed(networkRequest)获得Response。该部分与ApplicationInterceptorChain的功能类似，只是拦截的位置出现变化，这些拦截器更加靠近网络发送时的位置，越底层。所有拦截器执行结束后，通过调用 readNetworkResponse()方法得到网络返回数据，该方法内部通过HttpStream向服务端写入和读取数据。随后对返回数据的cookies进行存储，并判断是否加入缓存中，最后将结果赋值给userResponse。

===

知道分子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
OkHttp深入学习

转自：http://blog.csdn.net/evan_man/article/details/51173810 Android 4.4之后，HttpURLConnection底层实现已被OkHttp替换。可以见得OkHttp的性能已经被Google所认同。对于为何会想深入了解该库的原因：因为它的最底层走到了java的Socket；利用向Socket写入特定的Http协议数据包，
复制链接

扫一扫

专栏目录