OkHttp3 源码解析执行流程

OkHttp是一款网络请求框架，【OkHttp传送门】，为了在开发中使用的更加得心应手，必然的要去探究其源码，分析其中的工作原理，而且还能学习框架的设计思想。文章主要对OkHttp整体的工作流程进行分析，所以一些操作方法并没有涉及，读者可以通过传送门阅读文档自行实践。在分析之前，先看一张整体的流程图（本文内容会根据图的流程展开）：

okhttp流程.png

OkHttp请求网络的简单示例

private static final String URL_CONTENT = "https://www.baidu.com/";

    public static void doOkHttp() {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .retryOnConnectionFailure(true)  //连接失败后进行重连
                .build();

        final Request request = new Request.Builder()              
                .url(URL_CONTENT)
                .build();
        
        //异步方式请求网络
        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                //请求失败
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //请求成功,对response进行处理
                
            }
        });
    }

上面的代码，首先创建一个okHttpClient对象，调用newCall()并且request作为参数传入，然后执行enqueue()，并且new一个Callback，请求结果的回调，这个过程是异步的。

//execute()是同步的方式请求网络，会阻塞UI线程，所以一般情况都是通过异步的方式请求网络
okHttpClient.newCall(request).execute();

1、OkHttpClient的build()过程。

public Builder() {
      dispatcher = new Dispatcher();  //异步请求调度器
      protocols = DEFAULT_PROTOCOLS;//请求协议集合，默认为http/1.1和Http/2
      connectionSpecs = DEFAULT_CONNECTION_SPECS;//连接规格
      eventListenerFactory = EventListener.factory(EventListener.NONE);//事件监听器
      proxySelector = ProxySelector.getDefault();//代理选择器
      cookieJar = CookieJar.NO_COOKIES;//http cookies 提供持久化策略
      socketFactory = SocketFactory.getDefault(); //socket工厂类
      hostnameVerifier = OkHostnameVerifier.INSTANCE;//对host基本接口的验证
      certificatePinner = CertificatePinner.DEFAULT; //约束的信任证书
      proxyAuthenticator = Authenticator.NONE;//代理身份认证
      authenticator = Authenticator.NONE;
      connectionPool = new ConnectionPool();//连接复用池
      dns = Dns.SYSTEM;//默认使用系统的dns
      followSslRedirects = true; //遵循SSL重定向
      followRedirects = true;//普通重定向
      retryOnConnectionFailure = true;//连接失败后进行重新连接
      connectTimeout = 10_000;//连接超时时间
      readTimeout = 10_000;//读取数据超时时间
      writeTimeout = 10_000;//发送数据超时时间
      pingInterval = 0;//时间间隔
    }

public OkHttpClient build() {
      return new OkHttpClient(this);
    }

OkHttpClient(Builder builder) {
    this.dispatcher = builder.dispatcher;
    this.proxy = builder.proxy;
    this.protocols = builder.protocols;
    this.connectionSpecs = builder.connectionSpecs;
    this.interceptors = Util.immutableList(builder.interceptors);//自定义的拦截器
    this.networkInterceptors = Util.immutableList(builder.networkInterceptors);//网络拦截器
    this.eventListenerFactory = builder.eventListenerFactory;
    this.proxySelector = builder.proxySelector;
    this.cookieJar = builder.cookieJar;
    this.cache = builder.cache;//创建OkHttpClient对象时的自定义缓存
    this.internalCache = builder.internalCache;//内部缓存
    this.socketFactory = builder.socketFactory;

    boolean isTLS = false;
    for (ConnectionSpec spec : connectionSpecs) {
      isTLS = isTLS || spec.isTls();
    }

    if (builder.sslSocketFactory != null || !isTLS) {
      this.sslSocketFactory = builder.sslSocketFactory;
      this.certificateChainCleaner = builder.certificateChainCleaner;
    } else {
      X509TrustManager trustManager = systemDefaultTrustManager();
      this.sslSocketFactory = systemDefaultSslSocketFactory(trustManager);
      this.certificateChainCleaner = CertificateChainCleaner.get(trustManager);
    }

    this.hostnameVerifier = builder.hostnameVerifier;
    this.certificatePinner = builder.certificatePinner.withCertificateChainCleaner(
        certificateChainCleaner);
    this.proxyAuthenticator = builder.proxyAuthenticator;
    this.authenticator = builder.authenticator;
    this.connectionPool = builder.connectionPool;
    this.dns = builder.dns;
    this.followSslRedirects = builder.followSslRedirects;
    this.followRedirects = builder.followRedirects;
    this.retryOnConnectionFailure = builder.retryOnConnectionFailure;
    this.connectTimeout = builder.connectTimeout;
    this.readTimeout = builder.readTimeout;
    this.writeTimeout = builder.writeTimeout;
    this.pingInterval = builder.pingInterval;

    if (interceptors.contains(null)) {
      throw new IllegalStateException("Null interceptor: " + interceptors);
    }
    if (networkInterceptors.contains(null)) {
      throw new IllegalStateException("Null network interceptor: " + networkInterceptors);
    }
  }

通过建造者模式创建OkHttpClient对象，并且配置各种参数。

2、Request的Builder()的过程

public Builder() {
      this.method = "GET"; //请求方法，默认GET
      this.headers = new Headers.Builder();//创建请求头
    }

public Request build() {
      if (url == null) throw new IllegalStateException("url == null");
      return new Request(this);
    }

Request(Builder builder) {
    this.url = builder.url; //请求url
    this.method = builder.method;//请求方法
    this.headers = builder.headers.build();//请求头
    this.body = builder.body;//请求体
    this.tag = builder.tag != null ? builder.tag : this;
  }

Request也是以建造者模式创建对象，配置参数。关于HTTP报文结构图（左图对应Request，右图对应Response）：

HTTP报文结构.png

3、okHttpClient.newCall()

public Call newCall(Request request) {
    return RealCall.newRealCall(this, request, false /* for web socket */);
  }

//RealCall # newRealCall
static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    // Safely publish the Call instance to the EventListener.
    RealCall call = new RealCall(client, originalRequest, forWebSocket);
    call.eventListener = client.eventListenerFactory().create(call);
    return call;
  }

调用newCall()实际返回的是一个RealCall(继承自Call)对象。RealCall内部封装了网络请求和请求结果回调。那么，上面的异步请求实际调用的是RealCall的enqueue()方法。

4、RealCall # enqueue()

public void enqueue(Callback responseCallback) {
    synchronized (this) {
      //若任务已经执行，则抛出IllegalStateException
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    //跟踪调用堆栈
    captureCallStackTrace();
    //监听开始事件
    eventListener.callStart(this);
    // 1
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

上面代码的核心是注释1处，client.dispatcher()返回一个Dispatcher对象，异步请求调度器，里面会对任务进行分辨，是立刻执行还是放入等待队列。AsyncCall继承NamedRunnable（实现了Runnable接口）类，接着进入Dispatcher的enqueue()方法：

synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
  }

从代码可以发现，Dispatcher的enqueue()是一个同步方法，maxRequests是最大请求数(值为64)，maxRequestsPerHost是Host最大请求数据(值为5)，当满足这两个条件时，把任务添加到执行队列runningAsyncCalls，立刻执行，否则加入等待队列readyAsyncCalls，等待异步调用。executorService()内部创建了一个执行任务的线程池，并且返回一个执行对象ExecutorService。
executorService()的内部实现：

public synchronized ExecutorService executorService() {
    if (executorService == null) {
      executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue(), Util.threadFactory("OkHttp Dispatcher", false));
    }
    return executorService;
  }

以单例模式中的懒汉模式创建了一个线程池。其实上面创建的线程池和我们直接用Executors的newCachedThreadPool()创建是类似的，核心线程数为0，线程空闲时的超时时间60s，直接提交策略。关于线程池的分析，可以阅读【探索Java 线程池】这篇文章。在这里，往线程池中添加的任务对象是AsyncCall，那么看看AsyncCall的内部实现：

final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;

    AsyncCall(Callback responseCallback) {
      super("OkHttp %s", redactedUrl());
      this.responseCallback = responseCallback;
    }

    String host() {
      return originalRequest.url().host();
    }

    Request request() {
      return originalRequest;
    }

    RealCall get() {
      return RealCall.this;
    }

    @Override 
     protected void execute() {
      boolean signalledCallback = false;
      try {
        //核心请求
        Response response = getResponseWithInterceptorChain();
        //根据是否取消RetryAndFollowUpInterceptor,分别回调onFailure或onResponse
        if (retryAndFollowUpInterceptor.isCanceled()) {
          signalledCallback = true;
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
        } else {
          signalledCallback = true;
          responseCallback.onResponse(RealCall.this, response);
        }
      } catch (IOException e) {
        if (signalledCallback) {
          // Do not signal the callback twice!
          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          eventListener.callFailed(RealCall.this, e);
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {  
        //请求完毕，移除runningAsyncCalls中当前执行的Call。
        //并且查找等待队列readyAsyncCalls是否存在任务，存在，则添加执行队列runningAsyncCalls，然后执行任务
        //如果runningAsyncCalls不存在任务，且idleCallback不为null，则启动空闲状态Runnable
        client.dispatcher().finished(this);
      }
    }
  }

NamedRunnable实现了Runnable接口，在其run()方法内部调用了execute()方法，这里运用了设计模式中的模板模式，那么，这里就把任务交给了AsyncCall的execute()方法。通过代码的注释可以知道，把请求交由了getResponseWithInterceptorChain()方法，这个方法直译过来意思就是：用拦截器链获取响应报文。而方法内部也正运用了设计模式中的责任链模式。

模板模式
优点：封装不变部分，扩展可变部分；提取公共部分代码，便于维护。
缺点：在代码阅读方面可能会带来相对的难度。

责任链模式
优点：对请求者和处理者关系解耦，提高了代码灵活性。
缺点：如果处理者太多，过多的遍历会导致性能降低。

回到OkHttp的请求流程，上面已经把任务交由了getResponseWithInterceptorChain()方法，那么，看下其内部实现。

Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List interceptors = new ArrayList<>();
    //初始化OkHttpClient对象时添加的自定义interceptors
    interceptors.addAll(client.interceptors());   
    interceptors.add(retryAndFollowUpInterceptor);
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    interceptors.add(new CacheInterceptor(client.internalCache()));
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {  
      //添加用户自定义的networkInterceptors
      interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));
    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }

getResponseWithInterceptorChain()内部添加各种拦截器，利用RealInterceptorChain将已有的拦截器进行串联，然后proceed()开始遍历拦截器。

 public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
  ... ....//省略部分代码

    // Call the next interceptor in the chain.
    //遍历拦截器链，index代表责任链中拦截器的下标，初始值为0
    RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
        connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
        writeTimeout);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);

   ... ...//省略部分代码
    return response;
  }

5、分析各个拦截器的作用

• RetryAndFollowUpInterceptor：在连接失败后进行重新连接，必要时进行重定向，如果调用被取消，可能会抛出IOException
• BridgeInterceptor：构建访问网络的桥梁，首先，将用户请求转换成网络请求，然后访问网络，最后将网络响应转换成用户响应。
• CacheInterceptor：缓存拦截器，从缓存中获取服务器请求，或者把服务器响应写入缓存中。
• ConnectInterceptor：打开一个连接，去连接目标服务器。
• CallServerInterceptor：拦截器链中的最后一个链点，通过网络请求服务器。

链式执行流程：

链式流程.png

5.1、RetryAndFollowUpInterceptor # intercept()

public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Call call = realChain.call();
    EventListener eventListener = realChain.eventListener();
    
    //用于分配一个到服务器特定的HttpStream，内部封装了ConnectionPool连接池，管理Http的连接
    StreamAllocation streamAllocation = new StreamAllocation(client.connectionPool(),
        createAddress(request.url()), call, eventListener, callStackTrace);
    this.streamAllocation = streamAllocation;

    int followUpCount = 0;
    Response priorResponse = null;
    //开启轮询
    while (true) {
      //若已取消连接，释放资源
      if (canceled) {
        streamAllocation.release();
        throw new IOException("Canceled");
      }

      Response response;
      boolean releaseConnection = true;
      try {
        //调用下一个拦截器
        response = realChain.proceed(request, streamAllocation, null, null);
        releaseConnection = false;
      } catch (RouteException e) {
        // The attempt to connect via a route failed. The request will not have been sent.
        if (!recover(e.getLastConnectException(), streamAllocation, false, request)) {
          throw e.getLastConnectException();
        }
        releaseConnection = false;
        continue;
      } catch (IOException e) {
        // An attempt to communicate with a server failed. The request may have been sent.
        boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
        if (!recover(e, streamAllocation, requestSendStarted, request)) throw e;
        releaseConnection = false;
        continue;
      } finally {
        // We're throwing an unchecked exception. Release any resources.
        if (releaseConnection) {
          streamAllocation.streamFailed(null);
          streamAllocation.release();
        }
      }

      // Attach the prior response if it exists. Such responses never have a body.
      //检测前一个Response
      if (priorResponse != null) {
        response = response.newBuilder()
            .priorResponse(priorResponse.newBuilder()
                    .body(null)
                    .build())
            .build();
      }
      
      Request followUp = followUpRequest(response, streamAllocation.route());
      //followUp为null，表示不要重定向，释放资源并且返回response
      if (followUp == null) {
        if (!forWebSocket) {
          streamAllocation.release();
        }
        return response;
      }
      //关闭response的body
      closeQuietly(response.body());
      //最大重定向次数20
      if (++followUpCount > MAX_FOLLOW_UPS) {
        streamAllocation.release();
        throw new ProtocolException("Too many follow-up requests: " + followUpCount);
      }
      
      //如果是不可重复的请求体，抛出异常
      if (followUp.body() instanceof UnrepeatableRequestBody) {
        streamAllocation.release();
        throw new HttpRetryException("Cannot retry streamed HTTP body", response.code());
      }

      //检测地址是否相同，释放旧连接，重新创建一个新的连接
      if (!sameConnection(response, followUp.url())) {
        streamAllocation.release();
        streamAllocation = new StreamAllocation(client.connectionPool(),
            createAddress(followUp.url()), call, eventListener, callStackTrace);
        this.streamAllocation = streamAllocation;
      } else if (streamAllocation.codec() != null) {
        throw new IllegalStateException("Closing the body of " + response
            + " didn't close its backing stream. Bad interceptor?");
      }

      request = followUp;
      priorResponse = response;
    }
  }

5.2、BridgeInterceptor # intercept()

public Response intercept(Chain chain) throws IOException {
    Request userRequest = chain.request();
    Request.Builder requestBuilder = userRequest.newBuilder();
    //将用户的Request构造成服务器的Request
    RequestBody body = userRequest.body();
    if (body != null) {     //请求体存在，进行转换
      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");
      }
    }

    if (userRequest.header("Host") == null) {
      requestBuilder.header("Host", hostHeader(userRequest.url(), false));
    }
    
    //保持连接
    if (userRequest.header("Connection") == null) {
      requestBuilder.header("Connection", "Keep-Alive");
    }
 
    //使用Gzip压缩
    boolean transparentGzip = false;
    if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
      transparentGzip = true;
      requestBuilder.header("Accept-Encoding", "gzip");
    }
  
    //设置cookies
    List cookies = cookieJar.loadForRequest(userRequest.url());
    if (!cookies.isEmpty()) {
      requestBuilder.header("Cookie", cookieHeader(cookies));
    }

    if (userRequest.header("User-Agent") == null) {
      requestBuilder.header("User-Agent", Version.userAgent());
    }
    
    //传入已构造好的服务器Request，调用下一个拦截器，获取服务器的networkResponse 
    Response networkResponse = chain.proceed(requestBuilder.build());
    
    //保存networkResponse的cookie
    HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());
   
    //后续则是把networkResponse构造成用户的response
    Response.Builder responseBuilder = networkResponse.newBuilder()
        .request(userRequest);

    if (transparentGzip
        && "gzip".equalsIgnoreCase(networkResponse.header("Content-Encoding"))
        && HttpHeaders.hasBody(networkResponse)) {
      GzipSource responseBody = new GzipSource(networkResponse.body().source());
      Headers strippedHeaders = networkResponse.headers().newBuilder()
          .removeAll("Content-Encoding")
          .removeAll("Content-Length")
          .build();
      responseBuilder.headers(strippedHeaders);
      String contentType = networkResponse.header("Content-Type");
      responseBuilder.body(new RealResponseBody(contentType, -1L, Okio.buffer(responseBody)));
    }

    return responseBuilder.build();
  }

5.3、CacheInterceptor # intercept()

public Response intercept(Chain chain) throws IOException {
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;
    //获取当前时间
    long now = System.currentTimeMillis();
    
    //获取缓存策略
    CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
    Request networkRequest = strategy.networkRequest;
    Response cacheResponse = strategy.cacheResponse;

    //从缓存中追踪Response
    if (cache != null) {
      cache.trackResponse(strategy);
    }

    //如果缓存不适用，则关闭
    if (cacheCandidate != null && cacheResponse == null) {
      closeQuietly(cacheCandidate.body()); 
    }

    // 如果网络被禁止，且缓存为空，则返回失败
    if (networkRequest == null && cacheResponse == null) {
      return new Response.Builder()
          .request(chain.request())
          .protocol(Protocol.HTTP_1_1)
          .code(504)
          .message("Unsatisfiable Request (only-if-cached)")
          .body(Util.EMPTY_RESPONSE)
          .sentRequestAtMillis(-1L)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build();
    }

    // 不需要网络时，从缓存中获取
    if (networkRequest == null) {
      return cacheResponse.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build();
    }

    Response networkResponse = null;
    try {
      //调用下一个拦截者，从网络获取Response 
      networkResponse = chain.proceed(networkRequest);
    } finally {
      // 关闭body，防止内存泄露
      if (networkResponse == null && cacheCandidate != null) {
        closeQuietly(cacheCandidate.body());
      }
    }

    // 如果缓存中存在Response，同时检测networkResponse是否被修改
    if (cacheResponse != null) {
      if (networkResponse.code() == HTTP_NOT_MODIFIED) {
        Response response = cacheResponse.newBuilder()
            .headers(combine(cacheResponse.headers(), networkResponse.headers()))
            .sentRequestAtMillis(networkResponse.sentRequestAtMillis())
            .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
            .cacheResponse(stripBody(cacheResponse))
            .networkResponse(stripBody(networkResponse))
            .build();
        networkResponse.body().close();

        // Update the cache after combining headers but before stripping the
        // Content-Encoding header (as performed by initContentStream()).
        //更新缓存中的数据至最新
        cache.trackConditionalCacheHit();
        cache.update(cacheResponse, response);
        return response;
      } else {
        closeQuietly(cacheResponse.body());
      }
    }

    //构建response 
    Response response = networkResponse.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();

    //把之前未缓存的添加至缓存中
    if (cache != null) {
      if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
        // Offer this request to the cache.
        CacheRequest cacheRequest = cache.put(response);
        return cacheWritingResponse(cacheRequest, response);
      }

      if (HttpMethod.invalidatesCache(networkRequest.method())) {
        try {
          cache.remove(networkRequest);
        } catch (IOException ignored) {
          // The cache cannot be written.
        }
      }
    }

    return response;
  }

5.4、ConnectInterceptor # intercept()

public Response intercept(Chain chain) throws IOException {
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Request request = realChain.request();
    StreamAllocation streamAllocation = realChain.streamAllocation();

    // We need the network to satisfy this request. Possibly for validating a conditional GET.
    boolean doExtensiveHealthChecks = !request.method().equals("GET");

    //获取httpCodec 对象，HttpCodec的实现类有Http1Codec和Http2Codec
    //分别对应Http1.1和Http2
    //HttpCodec主要是对Http请求和Http响应进行编解码
    HttpCodec httpCodec = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
    RealConnection connection = streamAllocation.connection();
    
    //调用下一个拦截器
    return realChain.proceed(request, streamAllocation, httpCodec, connection);
  }

StreamAllocation的newStream()方法内部实现

public HttpCodec newStream(
      OkHttpClient client, Interceptor.Chain chain, boolean doExtensiveHealthChecks) {
    int connectTimeout = chain.connectTimeoutMillis();
    int readTimeout = chain.readTimeoutMillis();
    int writeTimeout = chain.writeTimeoutMillis();
    int pingIntervalMillis = client.pingIntervalMillis();
    boolean connectionRetryEnabled = client.retryOnConnectionFailure();

    try {
      //寻找一个可用连接
      RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
          writeTimeout, pingIntervalMillis, connectionRetryEnabled, doExtensiveHealthChecks);
      //根据具体的resultConnection 创建resultCodec对象
      HttpCodec resultCodec = resultConnection.newCodec(client, chain, this);

      synchronized (connectionPool) {
        codec = resultCodec;
        return resultCodec;
      }
    } catch (IOException e) {
      throw new RouteException(e);
    }
  }

5.5、CallServerInterceptor # intercept()

public Response intercept(Chain chain) throws IOException {
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    HttpCodec httpCodec = realChain.httpStream();
    StreamAllocation streamAllocation = realChain.streamAllocation();
    RealConnection connection = (RealConnection) realChain.connection();
    Request request = realChain.request();
    
    long sentRequestMillis = System.currentTimeMillis();

    realChain.eventListener().requestHeadersStart(realChain.call());
    //写入请求头
    httpCodec.writeRequestHeaders(request);
    realChain.eventListener().requestHeadersEnd(realChain.call(), request);

    Response.Builder responseBuilder = null;
    
    //检测是否有body的请求方法
    if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {

      //如果请求头是"100-continue"，等待服务器的响应
      if ("100-continue".equalsIgnoreCase(request.header("Expect"))) {
        httpCodec.flushRequest();
        realChain.eventListener().responseHeadersStart(realChain.call());
        responseBuilder = httpCodec.readResponseHeaders(true);
      }

      if (responseBuilder == null) {
        // Write the request body if the "Expect: 100-continue" expectation was met.
        realChain.eventListener().requestBodyStart(realChain.call());        
        long contentLength = request.body().contentLength();
       
        //将请求体转换成sink，并封装在CountingSink 内部
        CountingSink requestBodyOut =
            new CountingSink(httpCodec.createRequestBody(request, contentLength));
        BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);

        request.body().writeTo(bufferedRequestBody);
        bufferedRequestBody.close();
        realChain.eventListener()
            .requestBodyEnd(realChain.call(), requestBodyOut.successfulCount);
      } else if (!connection.isMultiplexed()) {
        // If the "Expect: 100-continue" expectation wasn't met, prevent the HTTP/1 connection
        // from being reused. Otherwise we're still obligated to transmit the request body to
        // leave the connection in a consistent state.
        streamAllocation.noNewStreams();
      }
    }

    httpCodec.finishRequest();

    //从httpCodec中获取响应头
    if (responseBuilder == null) {
      realChain.eventListener().responseHeadersStart(realChain.call());
      responseBuilder = httpCodec.readResponseHeaders(false);
    }

    //构建response 
    Response response = responseBuilder
        .request(request)
        .handshake(streamAllocation.connection().handshake())
        .sentRequestAtMillis(sentRequestMillis)
        .receivedResponseAtMillis(System.currentTimeMillis())
        .build();

    //如果服务器返回的状态码是100，再次尝试读取具体的response
    int code = response.code();
    if (code == 100) {
      // server sent a 100-continue even though we did not request one.
      // try again to read the actual response
      responseBuilder = httpCodec.readResponseHeaders(false);

      response = responseBuilder
              .request(request)
              .handshake(streamAllocation.connection().handshake())
              .sentRequestAtMillis(sentRequestMillis)
              .receivedResponseAtMillis(System.currentTimeMillis())
              .build();

      code = response.code();
    }

    realChain.eventListener()
            .responseHeadersEnd(realChain.call(), response);

    //如果是WebSocket，并且返回状态码为101，表示响应body为空
    if (forWebSocket && code == 101) {
      response = response.newBuilder()
          .body(Util.EMPTY_RESPONSE)
          .build();
    } else {
      //读取body
      response = response.newBuilder()
          .body(httpCodec.openResponseBody(response))
          .build();
    }
     
    //如果响应头部是"close"，关闭流
    if ("close".equalsIgnoreCase(response.request().header("Connection"))
        || "close".equalsIgnoreCase(response.header("Connection"))) {
      streamAllocation.noNewStreams();
    }
    
    //协议异常
    if ((code == 204 || code == 205) && response.body().contentLength() > 0) {
      throw new ProtocolException(
          "HTTP " + code + " had non-zero Content-Length: " + response.body().contentLength());
    }

    return response;
  }

到这里，OkHttp的执行流程就分析完毕了。

关于OkHttp3系列的其它文章：
OkHttp3 源码解析 连接池的复用
OkHttp3源码解析内部缓存