OKHttp源码解析(一) OkHttp整体流程

OkHttp官网地址：http://square.github.io/okhttp/
OkHttp GitHub地址：https://github.com/square/okhttp

本篇文章阐述一下OKHttp的整体流程。首先通过代码来一步一步进行分析它的内部流程。

源码环境

OKHttp3.2.0

1，基本用法

1.1，创建 OkHttpClient 对象

final OkHttpClient client = new OkHttpClient();

这是OKHttp提供的一个默认的构造函数，我们进去可以发现，它里面设置了一个默认的Builder，如果我们需要设置自己的Builder的话则可以使用它的有Builder参数的构造函数。

无参构造函数

public OkHttpClient() {
    this(new Builder());
  }

有参构造函数

 private OkHttpClient(Builder builder) {
    this.dispatcher = builder.dispatcher;
    this.proxy = builder.proxy;
    //省略部分其他的参数...
  }

构造完了对象后我们就可以发起请求了，请求分为同步请求和异步请求。我们首先来看下请求部分的代码。

1.2，发起http请求

//构造Request
Request request = new Request.Builder()
                .url("https://github.com/crazyandcoder")
                .build();

//响应结果
Response response = client.newCall(request).execute();
         if (response.isSuccessful()) {
              String  result= response.body().string());
         }

网络请求方式一般有get、post、delete等等，这个请求中并没有设置是哪种请求方式，所以一般情况下都有设置的默认方法。

public Builder() {
      this.method = "GET";
      this.headers = new Headers.Builder();
    }

我们进去发现它的默认方式get。以上便是一个最简单，完整的请求流程。接下来我们分步进行分析一下。

2，请求类型

2.1，同步请求

OKHttp请求类型分为同步请求和异步请求，上面其实是用同步方式完成的网络请求。即：

Response response = client.newCall(request).execute();

我们进入发现execute它是接口Call中的方法，那么我们就去它的实现类中去查看它的实现方法。进入到client.newCall中查看。

  @Override public Call newCall(Request request) {
    return new RealCall(this, request);
  }

其实真正实现call的是类RealCall，我们就去这个类中查看。

 @Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    try {
      client.dispatcher().executed(this);
      Response result = getResponseWithInterceptorChain(false);
      if (result == null) throw new IOException("Canceled");
      return result;
    } finally {
      client.dispatcher().finished(this);
    }
  }

因为这是一个同步请求方式，所在开始的时候就进行了判断，如果已经在执行的话就设置一下flag标明正在执行中，每个 call 只能被执行一次。

接着通过下面的代码来进行实际的请求，其中Dispatcher是Builder中的参数之一，即这是一个请求策略实现类。

client.dispatcher().executed(this);

执行完了请求之后通过getResponseWithInterceptorChain来返回相应结果

Response result = getResponseWithInterceptorChain(false);

接着通过dispatcher来通知结束请求。

我们来看下getResponseWithInterceptorChain方法里面的实现内容，通过名字可以简单看出这是一个关于拦截器的实现，拦截器，观察，修改以及可能短路的请求输出和响应请求的回来。通常情况下拦截器用来添加，移除或者转换请求或者回应的头部信息。


  private Response getResponseWithInterceptorChain(boolean forWebSocket) throws IOException {
    Interceptor.Chain chain = new ApplicationInterceptorChain(0, originalRequest, forWebSocket);
    return chain.proceed(originalRequest);
  }

进入到方法中可以看出真正执行response的还是getResponse方法。由于getResponse方法太长我们一步一步分析。

Response getResponse(Request request, boolean forWebSocket)

首先判断进行RequestBody判断是否为null然后进行一系列的设置。

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

接着构造了一个HttpEngine，通过HttpEngine来发起请求以及读取响应结果，即：

//构造HttpEngine
engine = new HttpEngine(client, request, false, false, forWebSocket, null, null, null);

//发送请求以及读取响应结果
engine.sendRequest();
engine.readResponse();

在读取响应结果中，又进行了是否有本地缓存cacheResponse进行判断，如果没有的话则进行网络请求networkResponse，否则就读取cacheResponse，最后将response返回。

Response response = engine.getResponse();
      Request followUp = engine.followUpRequest();

      if (followUp == null) {
        if (!forWebSocket) {
          engine.releaseStreamAllocation();
        }
        return response;
      }

借用网上一张流程图来表示。

以上便是同步请求的一个整体流程，接着我们来分析下异步请求流程。

2.2，异步请求

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的异步请求其实是通过将请求Request插入到队列中，然后在回调中返回结果response的过程。下面我们来详细的了解一下异步请求。

从上面我们可以知道执行call的其实是RealCall，我们进入到里面看下enqueue的方法

 @Override 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));
  }

同样的一次只能执行一个call，接着我们看下AsyncCall类，其中存在excute方法。

@Override protected void execute() {
      boolean signalledCallback = false;
      try {
        Response response = getResponseWithInterceptorChain(forWebSocket);
        if (canceled) {
          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!
          logger.log(Level.INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }