本文将从类图和一次完整的同步网络请求角度分析OKHttp。如有不妥，欢迎指正。

类图

该类图不是很完整，但是包含了一次请求涉及的类。

GET请求过程

OkHttpClient client = new OkHttpClient();  //1
//新建一个Request对象
Request request = new Request.Builder() //2
    .url(url)
    .build();
Response response = client.newCall(request).execute(); //3
//获取响应结果
response.body().string(); //4

1.创建OKHttpClient:

final Dispatcher dispatcher;

final Proxy proxy;

final List<Protocol> protocols;

final List<ConnectionSpec> connectionSpecs;

final List<Interceptor> interceptors;

final List<Interceptor> networkInterceptors;

final ProxySelector proxySelector;

final CookieJar cookieJar;

final Cache cache;

final InternalCache internalCache;

final SocketFactory socketFactory;

final SSLSocketFactory sslSocketFactory;

final CertificateChainCleaner certificateChainCleaner;

final HostnameVerifier hostnameVerifier;

final CertificatePinner certificatePinner;

final Authenticator proxyAuthenticator;

final Authenticator authenticator;

final ConnectionPool connectionPool;

final Dns dns;

final boolean followSslRedirects;

final boolean followRedirects;

final boolean retryOnConnectionFailure;

final int connectTimeout;

final int readTimeout;

final int writeTimeout;

OKHttpClient包含了各种配置信息。

2.创建Request

private final HttpUrl url;  //url

private final String method;   //请求方法

private final Headers headers; //首部

private final RequestBody body;  //主题

private final Object tag; //唯一标识一个请求

Request类包含了一次http请求所有的信息。真正执行请求的是这段代码 Response response = client.newCall(request).execute();我们看下OKHttpClient类的newCall()方法：

@Override public Call newCall(Request request) {

return new RealCall(this, request, false /* for web socket */);

}

创建并返回了一个RealCall对象。

3.RealCall对象

RealCall实现了Call接口：
final class RealCall implements Call

成员变量：
final OkHttpClient client;
final RetryAndFollowUpInterceptor retryAndFollowUpInterceptor;
/** The application's original request unadulterated by redirects or auth headers. */
final Request originalRequest;  //包含请求信息
final boolean forWebSocket;
// Guarded by this.
private boolean executed;

核心方法：
    @Override protected void execute() {
      boolean signalledCallback = false;
      try {
        Response response = getResponseWithInterceptorChain();    //执行网络请求
        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 {
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
  }

  Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());    //添加自定义拦截器
    interceptors.add(retryAndFollowUpInterceptor);    //这个拦截器的intercept创建StreamAllocation，回头再看
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    interceptors.add(new CacheInterceptor(client.internalCache()));
    interceptors.add(new ConnectInterceptor(client));    //这个拦截器的intercept创建HttpCodec，回头再看
    if (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));    //这个拦截器的intercept方法执行网络请求，回头再看

    Interceptor.Chain chain = new RealInterceptorChain(
        interceptors, null, null, null, 0, originalRequest);    //创建一个RealInterceptorChain对象，传入请求信息和拦截器信息
    return chain.proceed(originalRequest);    //开始处理
  }

RealCall的execute()中调用了getResponseWithInterceptorChain()，该方法中创建了很多Interceptor，这里使用了职责链模式，几个关键的Intercept已经在注释中标注，回头还会再看。然后创建RealInterceptorChain对象。

4.RealInterceptorChain类：

主要成员变量：
private final List<Interceptor> interceptors;  
private final StreamAllocation streamAllocation;
private final HttpCodec httpCodec;     //执行网络请求
private final Connection connection;
private final int index;              //表明当前对象使用的Inteceptor在interceptros列表中的下标
private final Request request;

主要方法：
  public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      Connection connection) throws IOException {
    if (index >= interceptors.size()) throw new AssertionError();

    calls++;

    // If we already have a stream, confirm that the incoming request will use it.
    if (this.httpCodec != null && !sameConnection(request.url())) {
      throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
          + " must retain the same host and port");
    }

    // If we already have a stream, confirm that this is the only call to chain.proceed().
    if (this.httpCodec != null && calls > 1) {
      throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
          + " must call proceed() exactly once");
    }

    // Call the next interceptor in the chain.
    RealInterceptorChain next = new RealInterceptorChain(
        interceptors, streamAllocation, httpCodec, connection, index + 1, request);          //创建一个新的RealInterceptorChain对象，该对象的index增加1，表明这个对象由下一个Interceptor处理
    Interceptor interceptor = interceptors.get(index);  //获取当前RealInterceptorChain对象的Interceptor
    Response response = interceptor.intercept(next); //处理新生成的RealInterceptorChain对象

    // Confirm that the next interceptor made its required call to chain.proceed().
    if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
      throw new IllegalStateException("network interceptor " + interceptor
          + " must call proceed() exactly once");
    }

    // Confirm that the intercepted response isn't null.
    if (response == null) {
      throw new NullPointerException("interceptor " + interceptor + " returned null");
    }

    return response;
  }

proceed()关键的方法已经注释，该方法根据index下标获取一个interceptor，然后生成一个新的RealInterceptorChain对象，作为intercepter.intercept()的参数。我们根据interceptor加入的顺序看看第一个interceptor是谁？

    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());
    interceptors.add(retryAndFollowUpInterceptor);
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    interceptors.add(new CacheInterceptor(client.internalCache()));
    interceptors.add(new ConnectInterceptor(client));

除了我们自定义的第一个就是retryAndFollowUpInterceptor这个Interceptor。我们看看这个类。

5.RetryAndFollowUpInterceptor类

成员变量：
private final OkHttpClient client;

private final boolean forWebSocket;

private StreamAllocation streamAllocation;

private Object callStackTrace;

private volatile boolean canceled;

核心方法：
  @Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();

    streamAllocation = new StreamAllocation(
        client.connectionPool(), createAddress(request.url()), callStackTrace);  //创建StreamAllocation,这个类和发送字节流有关，后面还会提到

    int followUpCount = 0;
    Response priorResponse = null;
    while (true) {
      if (canceled) {
        streamAllocation.release();
        throw new IOException("Canceled");
      }

      Response response = null;
      boolean releaseConnection = true;
      try {
        response = ((RealInterceptorChain) chain).proceed(request, streamAllocation, null, null);  //又调用chain的proceed方法，该方法又会生成一个RealInterceptorChain对象，交给下一个拦截器处理
        releaseConnection = false;
      } catch (RouteException e) {
        // The attempt to connect via a route failed. The request will not have been sent.
        if (!recover(e.getLastConnectException(), true, request)) throw e.getLastConnectException();
        releaseConnection = false;
        continue;
      } catch (IOException e) {
        // An attempt to communicate with a server failed. The request may have been sent.
        if (!recover(e, false, 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.
      if (priorResponse != null) {
        response = response.newBuilder()
            .priorResponse(priorResponse.newBuilder()
                    .body(null)
                    .build())
            .build();
      }

      Request followUp = followUpRequest(response);

      if (followUp == null) {
        if (!forWebSocket) {
          streamAllocation.release();
        }
        return response;
      }

      closeQuietly(response.body());

      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()), callStackTrace);
      } 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;
    }
  }

intercept()方法中重要的地方已经注释，该方法给RealInterceptorChain传入一个生成的StreamAllocation对象，这个对象和发送字节流相关。然后又调用chain的proceed方法，该方法又会生成一个RealInterceptorChain对象，交给下一个拦截器处理。我们看看最后一个拦截器是如何处理RealInterceptorChain的，最后一个拦截器是CallServerInterceptor。

6.CallServerInterceptor 类

@Override public Response intercept(Chain chain) throws IOException {
    HttpCodec httpCodec = ((RealInterceptorChain) chain).httpStream();
    StreamAllocation streamAllocation = ((RealInterceptorChain) chain).streamAllocation();
    Request request = chain.request();

    long sentRequestMillis = System.currentTimeMillis();
    httpCodec.writeRequestHeaders(request);

    if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
      Sink requestBodyOut = httpCodec.createRequestBody(request, request.body().contentLength()); 
      BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);  //这是okio中的类，就是用这个对象发送数据
      request.body().writeTo(bufferedRequestBody);   //发送请求实体
      bufferedRequestBody.close();
    }

    httpCodec.finishRequest();

    Response response = httpCodec.readResponseHeaders()
        .request(request)
        .handshake(streamAllocation.connection().handshake())
        .sentRequestAtMillis(sentRequestMillis)
        .receivedResponseAtMillis(System.currentTimeMillis())
        .build();        //接收响应

    int code = response.code();
    if (forWebSocket && code == 101) {
      // Connection is upgrading, but we need to ensure interceptors see a non-null response body.
      response = response.newBuilder()
          .body(Util.EMPTY_RESPONSE)
          .build();
    } else {
      response = response.newBuilder()
          .body(httpCodec.openResponseBody(response))
          .build();
    }

    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;
  }
}

最后一个拦截器真正执行网络请求，关键代码已经注释，将BufferedSink作为RequestBody.writeTo()的参数。我们看看RequestBody是如何用BufferedSink发送数据的。

7.RequestBody

核心方法：
  public static RequestBody create(MediaType contentType, String content) {
    Charset charset = Util.UTF_8;
    if (contentType != null) {
      charset = contentType.charset();
      if (charset == null) {
        charset = Util.UTF_8;
        contentType = MediaType.parse(contentType + "; charset=utf-8");
      }
    }
    byte[] bytes = content.getBytes(charset);
    return create(contentType, bytes);
  }


  public static RequestBody create(final MediaType contentType, final byte[] content,
      final int offset, final int byteCount) {
    if (content == null) throw new NullPointerException("content == null");
    Util.checkOffsetAndCount(content.length, offset, byteCount);
    return new RequestBody() {
      @Override public MediaType contentType() {
        return contentType;
      }

      @Override public long contentLength() {
        return byteCount;
      }

      @Override public void writeTo(BufferedSink sink) throws IOException {
        sink.write(content, offset, byteCount);    //调用BufferedSink发送字节流
      }
    };
  }

我们看到RequestBody最终是调用传入的BufferedSink参数将内容的字节发送给服务器。

总结

我们仅仅分析了一次同步请求的过程，还没有分析Okio中的BufferedSink是如何将字节流发送给服务器的，先占个坑。

后面会将更多笔记整理成博客，欢迎关注。
支持原创，转载请注明出处。