OkHttp 4.0 Kotlin源码分析 (二) 基本的数据对象以及Call类分析

前言

前面一节我们讲解了 同步请求和异步请求的实际使用方式,并分析了两种方式的区别。这里我们回顾下:

  1. 同步请求和异步的发送实际分为了4个步骤,其中前三个步骤是相同的;分别是创建OkhttpClient、request、和Call对象; 不同的是同步调用的是Call对象的execute()方法,而异步调用的是enqueue()方法。
  2. 同步请求会阻塞等待,异步请求在子线程中执行则不会阻塞。

请参考上一章节:
OKhttp3 的同步和异步请求基本用法

其他相关文章

OkHttp 4.0 Kotlin源码分析 (一) 同步和异步请求基本用法

OkHttp 4.0 Kotlin源码分析 (二) 基本的数据对象以及Call类分析

OkHttp 4.0 Kotlin源码分析 (三) Dispatcher分发器流程控制

那么我们每个步骤中的对象是什么,分别做了什么工作呢? 在接下来的这个章节我将对其进行解析。

2. Okhttp3 的对象解析

2.1 Okhttp3 请求的执行流程图

同步和异步请求结构

2.2 OkHttpClient客户端类

OkhttpClient是由一个静态内部内Builder进行创建,我们看下这个Builder的构造方法。其中初始化了OkhttpClient对象的初始化工作,而且其中包括两个非常重要的对象,分别是分发器(Dispather)和连接池(ConnectionPool)。

public Builder() {
      //1. Dispatcher是http请求的分发器; 这是Okhttp的核心之一,
      // 主要完成的任务是处理缓冲策略,不管是同步请求还是异步请求都是经过这个Dispatcher进行分发处理
      dispatcher = new Dispatcher();

      protocols = DEFAULT_PROTOCOLS;
      connectionSpecs = DEFAULT_CONNECTION_SPECS;
      eventListenerFactory = EventListener.factory(EventListener.NONE);
      proxySelector = ProxySelector.getDefault();
      if (proxySelector == null) {
        proxySelector = new NullProxySelector();
      }
      cookieJar = CookieJar.NO_COOKIES;
      socketFactory = SocketFactory.getDefault();
      hostnameVerifier = OkHostnameVerifier.INSTANCE;
      certificatePinner = CertificatePinner.DEFAULT;
      proxyAuthenticator = Authenticator.NONE;
      authenticator = Authenticator.NONE;
      // ConnectionPool 连接池,这也是我们上一节讲到的四大特性之一。主要作用是:
      // a. 管理客户和服务器之间的连接,并对连接进行复用。
      // b. 对于连接策略进行管理以提高连接效率
      connectionPool = new ConnectionPool();
      dns = Dns.SYSTEM;
      followSslRedirects = true;
      followRedirects = true;
      retryOnConnectionFailure = true;
      callTimeout = 0;
      connectTimeout = 10_000;
      readTimeout = 10_000;
      writeTimeout = 10_000;
      pingInterval = 0;
    }

2.2 Request请求报文信息类

和OkhttpClient相同,Request也是使用的是Build创建模式,对于需要大量参数进行初始化操作的对象使用Build创建模式是非常好的一个策略。这个类创建了 HTTP请求所需要的信息

// Builder内部类的构造方法
public Builder() {
      this.method = "GET";
      // 创建Http请求所需要的头部信息
      this.headers = new Headers.Builder();
  }
// 将创建的Builder 信息传递给Request的构造方法
public Request build() {
      if (url == null) throw new IllegalStateException("url == null");
      return new Request(this);
  }

//构造方法初始化了请求所需要的信息: url 、 请求方法、 头部信息、 body等
Request(Builder builder) {
    this.url = builder.url;
    this.method = builder.method;
    this.headers = builder.headers.build();
    this.body = builder.body;
    this.tags = Util.immutableMap(builder.tags);
  }

2.3 call 请求/响应对象

Call 是为执行而准备的请求。这个对象代表的是一个请求响应流,只能被执行一次,并且是可以取消的。

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

Call是一个Interface, 实际的逻辑是在它的实现类RealCall中。

// 这个静态方法 创建了一个RealCall对象,并创建赋值了一个回调监听
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;
}


private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
  // OkHttpClient对象
  this.client = client;
  // request对象
  this.originalRequest = originalRequest;
  this.forWebSocket = forWebSocket;
  // 重定向拦截器 是Okhttp的核心之一, 在创建Call的时候进行了创建
  this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
  this.timeout = new AsyncTimeout() {
    @Override protected void timedOut() {
      cancel();
    }
  };
  this.timeout.timeout(client.callTimeoutMillis(), MILLISECONDS);
}

Okhttp 3.13 版本引入了lambda 表达式,看着下面的代码是不是一脸蒙圈?
实现的作用是创建了一个EventListerner.Factory

static EventListener.Factory factory(EventListener listener) {
  return call -> listener;
}

--> 其实他是这个样子的, 创建了一个create返回listener的EventListener的Factory;
而这个Factory是在OkhttpClient创建时创建的。

static EventListener.Factory factory(final EventListener listener) {
  return new EventListener.Factory() {
    public EventListener create(Call call) {
      return listener;
    }
  };
}

3. Call 源码分析

3.1 Call 的同步请求方法 executed() 分析

@Override public Response execute() throws IOException {
    // 前面说到Call对象只能被执行一次, 那么是怎么保证的呢?
    // a. 通过这个executed 进行状态标记,
    // b. 加入对象锁
    //    多线程同一个call对象也只能被执行一次,否则抛出IllegalStateException异常
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }

    captureCallStackTrace();
    timeout.enter();
    eventListener.callStart(this);
    /**这块核心代码*/
    try {
      // 这是关键步骤, 调用Dispatcher中的 executed 方法;
      // 这里并没有执行, 而是将Call加入到执行队列中
      client.dispatcher().executed(this);
      // 获取response 的责任链的执行结果  , 这是Okhttp设计非常巧妙的地方,后面会进行详细讲解
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      e = timeoutExit(e);
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      // 在Dispatcher中将Call对象 从执行列表中移除掉
      // 这将在下一节 Dispatcher进行详细讲解
      client.dispatcher().finished(this);
    }
  }

我们发现 Call的executed()方法

  1. 调用了 dispatcher.executed()dispatcher.finished()方法,实际上是将Call对象加入到同步执行队列,然后移除。
  2. 调用了getResponseWithInterceptorChain并同步返回执行结果。

3.2 Call 的异步请求方法 enqueue() 分析

@Override public void enqueue(Callback responseCallback) {
    // 这个和 execute() 方法是一样的
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    // 1. 将Callback 封装成Asyncall对象(实际是一个Runnable)
    // 2. 将call对象添加到异步等待队列并调度执行
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

异步请求做了两件事:

  1. 将Callback 封装成Asyncall对象(实际是一个Runnable)
  2. 将call对象添加到异步等待队列并由Dispatcher调度执行
3.3 Call 取消请求 cancel() 分析
// Call 代码
@Override public void cancel() {
    retryAndFollowUpInterceptor.cancel();
}

// retryAndFollowUpInterceptor 对象取消代码
public void cancel() {
  canceled = true;
  StreamAllocation streamAllocation = this.streamAllocation;
  if (streamAllocation != null) streamAllocation.cancel();
}

3.4 总结

这一章节讲解了Okhttp使用过程中创建的各个数据对象的作用,和创建流程。详细分析了Call的实现类Realcall的源码,针对同步和异步请求有了更深层次的理解。

  1. 同步方法直接调用了dispatcher().executed() 添加到同步队列中; 阻塞获取请求结果 getResponseWithInterceptorChain(); 然后调用Finish() 方法回收call对象。

  2. 异步请求主要的调度工作在Dispatcher中,我们将在下一章节讲解。在ReallCall中异步请求所做的工作是将CallBack封装成Runnable,并添加到Dispatcher的异步请求队列中。

对于异步请求到底是怎么调度的 , 异步线程池又是以什么方式使用呢 ?


接下来我们讲解调度器Dispatcher

你可能感兴趣的:(OkHttp 4.0 Kotlin源码分析 (二) 基本的数据对象以及Call类分析)