源码分析okHttp基本工作流程

okHttp基本用法

关于okHttp基本的用法，这里简单提一下吧。
okHttp可以使用同步请求和异步请求两种方式，当然同步请求不能在UI线程里面做，这样会导致app崩溃。

同步请求

//构造OkHttpClient
final OkHttpClient client=new OkHttpClient.Builder().build();
//构造请求体
final Request request=new Request.Builder().url("www.baidu.com").build();
new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            //请求得到响应
            Response response=client.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}).start();

异步请求

//构造OkHttpClient
final OkHttpClient client=new OkHttpClient.Builder().build();
//构造请求体
final Request request=new Request.Builder().url("www.baidu.com").build();
//异步请求
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        //请求失败响应
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        //请求成功响应
    }
});

okHttp的基本工作流程

okHttp有三个队列：

/** Ready async calls in the order they'll be run. */
//等待队列，存放所有待执行请求的任务
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();

/** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
//正在执行的异步请求队列，存放所有正在执行异步请求任务
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();

/** Running synchronous calls. Includes canceled calls that haven't finished yet. */
//正在执行的同步请求队列，存放所有正在执行同步请求任务
private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();

enqueue方法
该方法传入一个AsyncCall对象，每个AsyncCall对象都封装了一个请求所需要的所有信息。同时，将当前请求加入到待执行队列里

void enqueue(AsyncCall call) {
   synchronized (this) {
   	 //加入等待队列中
     readyAsyncCalls.add(call);
   }
   promoteAndExecute();
 }

promoteAndExecute方法
1、遍历待执行任务队列
2、判断如果正在执行的任务数量超过规定的最大请求数量，则跳出
3、判断如果当前域名的请求数超过规定的最大单域名请求数量，则当前请求不做处理
4、从待执行列表里移除当前请求，将它添加到正在执行队列和可执行列表里
5、遍历可执行列表，将刚才的待执行任务，全部丢到线程池里去执行

private boolean promoteAndExecute() {
  assert (!Thread.holdsLock(this));
  
  List<AsyncCall> executableCalls = new ArrayList<>();
  boolean isRunning;
  synchronized (this) {
    //遍历待执行任务队列
    for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
      AsyncCall asyncCall = i.next();
	  //判断如果正在执行的任务数量超过规定的最大请求数量，则跳出
      if (runningAsyncCalls.size() >= maxRequests) break; 
      //判断如果当前域名的请求数超过规定的最大单域名请求数量，则当前请求不做处理
      if (runningCallsForHost(asyncCall) >= maxRequestsPerHost) continue; 
	  //从待执行列表里移除当前请求，将它添加到正在执行队列和可执行列表里
      i.remove();
      executableCalls.add(asyncCall);
      runningAsyncCalls.add(asyncCall);
    }
    isRunning = runningCallsCount() > 0;
  }
  //遍历可执行列表，将刚才的待执行任务，全部丢到线程池里去执行
  for (int i = 0, size = executableCalls.size(); i < size; i++) {
    AsyncCall asyncCall = executableCalls.get(i);
    asyncCall.executeOn(executorService());
  }

  return isRunning;
}

丢到线程池后，会执行每个请求AsyncCall的execute方法
execute()方法主要的两个功能：
1、调用getResponseWithInterceptorChain方法，构造拦截器链，对请求进行处理
2、任务结束时调用dispatcher.finish方法，将当前请求移出正在执行队列，重新遍历待执行队列间，将待执行任务推到线程池中执行

protected void execute() {
    .....
    try {
      //构造拦截器链，执行各种拦截器后得到响应
      Response response = getResponseWithInterceptorChain();
      signalledCallback = true;
      responseCallback.onResponse(RealCall.this, response);
    } catch (IOException e) {
     ...
    } catch (Throwable t) {
      ...
    } finally {
      //任务结束，调用finished方法
      client.dispatcher().finished(this);
    }
  }
}

我们先看finished方法，getResponseWithInterceptorChain后面分析。
finished方法又去调用了promoteAndExecute()方法，还记得这个方法的功能吗，就是去遍历待执行队列，将待执行的任务丢到线程池里执行，因为本次请求执行完毕了，线程池就空闲出来了，如果之前还有待执行的请求，那么这时就又去重新调用执行一遍

private <T> void finished(Deque<T> calls, T call) {
  Runnable idleCallback;
  synchronized (this) {
  	//将当前任务从正在执行队列里移除
    if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
    idleCallback = this.idleCallback;
  }
  //主要是这里，又去调用了promoteAndExecute()方法
  boolean isRunning = promoteAndExecute();

  if (!isRunning && idleCallback != null) {
    idleCallback.run();
  }
}

到这里，我们就了解了okHttp是怎么去推请求，下面看，具体每个请求任务在线程池里都做了些什么，先上图

线程池会执行每个请求任务的execute()方法，
execute里调用getResponseWithInterceptorChain去构造了拦截器链，对请求进行处理

protected void execute() {
    .....
    try {
      //构造拦截器链，执行各种拦截器后得到响应
      Response response = getResponseWithInterceptorChain();
      signalledCallback = true;
      responseCallback.onResponse(RealCall.this, response);
    } catch (IOException e) {
     ...
    } catch (Throwable t) {
      ...
    } finally {
      //任务结束，调用finished方法
      client.dispatcher().finished(this);
    }
  }
}

getResponseWithInterceptorChain()方法
这个方法主要构造一个拦截器链对象，并调用它的proceed方法

Response getResponseWithInterceptorChain() throws IOException {
    List<Interceptor> interceptors = new ArrayList<>();
    //添加用户自定义的拦截器
    interceptors.addAll(client.interceptors());
    //添加重连和重定向拦截器
    interceptors.add(retryAndFollowUpInterceptor);
    //添加请求头、cookie、压缩处理拦截器
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    //添加缓存处理拦截器
    interceptors.add(new CacheInterceptor(client.internalCache()));
    //添加连接拦截器
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    //添加发送请求拦截器
    interceptors.add(new CallServerInterceptor(forWebSocket));
	//构造拦截器链对象，index传入0
    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
    	originalRequest, this, eventListener, client.connectTimeoutMillis(),
    client.readTimeoutMillis(), client.writeTimeoutMillis());
	//调用链对象的proceed方法
    Response response = chain.proceed(originalRequest);
    if (retryAndFollowUpInterceptor.isCanceled()) {
      closeQuietly(response);
      throw new IOException("Canceled");
    }
    return response;
  }

chain.proceed方法

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
  .....
  //使用原有的拦截器列表构造新的拦截链对象，index+1
  RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
      connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
      writeTimeout);
  //获取当前index的拦截器
  Interceptor interceptor = interceptors.get(index);
  //调用当前拦截器的intercept方法，并且传入新的拦截链对象（index已经+1的）
  Response response = interceptor.intercept(next);
  .....
  return response;
}

interceptor.intercept方法
除了CallServerInterceptor外，其他所有的interceptor.intercept方法，都会调用chain.proceed()方法，

public Response intercept(Chain chain) throws IOException {
  .....
  1、做自身拦截器的职责
  2、调用chain.proceed()方法，由于传入的chain为新构造的，index加了1，于是重新执行上面的chain.proceed方法时，
  获取的拦截器就是下一个的，并且又会构造index+2的新的拦截链对象，传入index+1的拦截器中
}

直到最后一个拦截器CallServerInterceptor就不会调用chain.proceed()方法，而是请求网络，构造返回Response对象，后面会单独将每个拦截器的代码