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

异步请求里面也是通过getResponseWithInterceptorChain来获取响应结果的,然后通过responseCallback的回调将onFailure和onResponse返回出去。

在发起请求时,整个框架主要通过Call来封装每一次的请求。同时Call持有OkHttpClient和HttpEngine。而每一次的同步或者异步请求都会有Dispatcher的参与。

3,总结

通过前两部分的学习分析,我们大概知道了一下OKHttp的使用流程。接下来我们通过一个流程图来总结一下OKHttp的使用流程。

后面的部分将针对每个环节进行详细的分析。

阅读更多
版权声明:本文为博主原创文章,转载请注明出处,联系作者:QQ:275137657 https://blog.csdn.net/lj188266/article/details/79192907
文章标签: OKHttp
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭