OkHttp源码解析（一）基本用法及整体流程源码讲解

主线流程源码分析

常规使用

OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
// 请求报文的信息
Request request = new Request.Builder().url("https://www.baidu.com").get().build();

// 连接request和response的桥梁
Call call = okHttpClient.newCall(request);
// 同一个call对象只能执行一次enqueue方法
// 异步请求
call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        MLog.e(TAG, "onFailure: " + e.toString());
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        /*step 5:获取响应体*/
        MLog.e(TAG, "onResponse: " + response.body());
    }
});

// 同步请求
Response response = call.execute();

源码解析

同步请求

RealCall类调用execute方法

@Override public Response execute() throws IOException {
    synchronized (this) {
      ...
    try {
      // 保存同步请求，加入到同步请求执行队列中
      client.dispatcher().executed(this);
      // 通过拦截器链获取到Response
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      // 移除同步请求
      client.dispatcher().finished(this);
    }
  }

dispatcher作用：加入和移除同步请求。

异步请求

1.RealCall调用enqueue方法

client.dispatcher().enqueue(new AsyncCall(responseCallback));

/** 同步请求队列 */
  private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();

/**异步就绪，执行队列*/  
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
// 里面还会包含已经被取消，但是未执行完的请求
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
  
dispatcher的方法
synchronized void enqueue(AsyncCall call) {
    // runningAsyncCalls运行队列
    // 同时运行异步任务小于64，同时访问同一个服务器不超过5个
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      // 线程池执行AsyncCall耗时任务
      executorService().execute(call);
    } else {
      // readyAsyncCalls等待队列
      readyAsyncCalls.add(call);
    }
}
这两个队列是双端队列
AsyncCall 耗时任务

2.AsyncCall类
由上面可以看到RealCall的enqueue方法，会执行new AsyncCall的对象，该对象继承runnable，实现run方法，重写execute方法。

@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) {
    // signalledCallback为true，代表用户造成的异常，在回调的方法中业务处理出现错误
    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 {
    // 1.把请求从正在请求的异步队列中移除
    // 2.所用到的队列是非线程安全的，为了考虑线程安全加了同步锁
    // 3.调整任务队列
    client.dispatcher().finished(this);
  }
}

粗略梳理主线流程

异步：
创建okHttpClient，Request对象 --> 通过newCall()将Request转成RealCall对象 --> 调用RealCall的enqueue()(不能重复被执行) --> 传入的Callback封装成AsyncCall对象，AsyncCall是Runnable -> 在子线程中通过拦截器链获取到最终的Response

同步：
将Request方法封装成Call对象，真正实现类是RealCall - 直接调用拦截器链去获得最终的结果

用到的设计模式

建造者设计模式

OkHttpClient对象创建。

责任链设计模式

通过拦截器链获取到最终的Response进行处理。