0.前言

okhttp是一个有square开发网络请求框架，square出品，必属精品。以前也看过这个框架的源码，但是时间久了，好多都记不清了，悔当初没有好好记录下来，今天有时间，又看了一遍，把思路分析记录下来。

1.基本使用

从最简单的Get请求分析，okhttp请求分为同步请求和异步请求：

同步请求：

 private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      Headers responseHeaders = response.headers();
      for (int i = 0; i < responseHeaders.size(); i++) {
        System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
      }

      System.out.println(response.body().string());
    }
  }

异步请求：

private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build();

    client.newCall(request).enqueue(new Callback() {
      @Override public void onFailure(Call call, IOException e) {
        e.printStackTrace();
      }

      @Override public void onResponse(Call call, Response response) throws IOException {
        try (ResponseBody responseBody = response.body()) {
          if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

          Headers responseHeaders = response.headers();
          for (int i = 0, size = responseHeaders.size(); i < size; i++) {
            System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
          }

          System.out.println(responseBody.string());
        }
      }
    });
  }

代码分析就从这最基本的开始。

2.基本流程

先看同步请求，首先创建了一个Request，Request采用了建造者模式，可以很好的避免构造函数参数的数量爆棚，Request代表了一个http请求，包含了请求方法，请求头，和请求体。

接着是调用了OkHttpClient的newCall(request)

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

这个方法返回一个RealCall，接着看RealCall的newRealCall这个静态方法

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

可以看到这里是真正RealCall的创建，里面包含了okhttpclient还有request，同时为这个RealCall注册了一个事件监听，这个eventListenerFactory就是在构建okhttp的时候传入的

new OkHttpClient.Builder()
      .eventListenerFactory(PrintingEventListener.FACTORY)
      .build();

网络请求的结果被封装在Response里，通过调用RealCall的execute方法，得到最终结果，所以可想而知，真正的网络请求也是在这一个过程进行的。接着就看一下execute方法

@Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    try {
      client.dispatcher().executed(this);
      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);
    }
  }

这个方法先判断是否已经执行该Call了，如果executed=true，那么就抛出异常，如果为false，就调用client.dispatcher().executed(this);Dispatcher根据注释来看，是用来决定何时执行异步策略的，看一下它的executed方法

synchronized void executed(RealCall call) {
    runningSyncCalls.add(call);
  }

runningSyncCalls是一个双向列表，这个方法就是单纯的将该RealCall添加进列表，所以网络请求不是在这里发起的，那么回到RealCall的execute方法，在dispatcher的executed方法调用后，接着调用了
getResponseWithInterceptorChain();该方法返回了Response，所以可以看出真正的网络请求是在这里做的。看一下这个方法：

 Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    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));
    if (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));

    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }

这个方法的前办部分构建了一个拦截器列表，包括我们在构建okhttpclient时添的interceptor和networkInterceptor，接着又生成了一个RealInterceptorChain，调用它的proceed方法返回最终的Response。
这个proceed方法，就是我们要关注的重点：

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection 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 && !this.connection.supportsUrl(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, call, eventListener, connectTimeout, readTimeout,
        writeTimeout);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);

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

    if (response.body() == null) {
      throw new IllegalStateException(
          "interceptor " + interceptor + " returned a response with no body");
    }

    return response;
  }

注重看这两行

 RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
        connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
        writeTimeout);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);

可以看到每次调用proceed方法，都会生成一个新的RealInterceptorChain，其他参数都一样，只是index增加了1，接着就是根据index在拦截器列表找到一个拦截器，然后调用拦截器的intercept方法，并将刚才生成的RealInterceptorChain传入，所以现在大家应该清楚了吧，在自定义拦截器时复写的intercept方法传入Chain，其实是RealInterceptorChain，在复写拦截器的时候，经常会写chain.processed(request)，之后就会重复之前的过程，如果你不调用chain.processed(request)方法，你会发现没有网络请求发出（没有http缓存的情况下），这是因为整个网络请求过程采用的是责任链模式，不调用这个方法，就相当于断掉了这个链条的传递，因为最终的请求的发出和Response的构建是在CallServerInterceptor里完成的，是链条的最后一环，这里注意的是resposne是由下向上返回的，类似于递归。得到response后，我们再回到Realcall的execute方法，看最后有一个finally

 client.dispatcher().finished(this);

调用dispatcher的finished方法

    private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
    int runningCallsCount;
    Runnable idleCallback;
    synchronized (this) {
      if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
      if (promoteCalls) promoteCalls();
      runningCallsCount = runningCallsCount();
      idleCallback = this.idleCallback;
    }

    if (runningCallsCount == 0 && idleCallback != null) {
      idleCallback.run();
    }
  }

将call从dispatcher的列表中移除。并重置RunningCount的数量，当runningCallsCount的数量为0时，会回调idleCallback。
接下来看一下异步的get请求， client.newCall(request).enqueue，同样是生成了一个RealCall，只不过这次调用的是enqueue方法，

@Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

给方法还是调用了Dispatcher的enqueue方法，，但是你发现这里生成了一个新对象AsyncCall。

final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;

    AsyncCall(Callback responseCallback) {
      super("OkHttp %s", redactedUrl());
      this.responseCallback = responseCallback;
    }

    String host() {
      return originalRequest.url().host();
    }

    Request request() {
      return originalRequest;
    }

    RealCall get() {
      return RealCall.this;
    }

    @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 {
          eventListener.callFailed(RealCall.this, e);
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
  }

它有一个父类NamedRunnable，先看他的父类

public abstract class NamedRunnable implements Runnable {
  protected final String name;

  public NamedRunnable(String format, Object... args) {
    this.name = Util.format(format, args);
  }

  @Override public final void run() {
    String oldName = Thread.currentThread().getName();
    Thread.currentThread().setName(name);
    try {
      execute();
    } finally {
      Thread.currentThread().setName(oldName);
    }
  }

  protected abstract void execute();
}

NamedRunnable是一个抽象类，并且实现了runnable接口，在run方法里调用了execute这个抽象方法。
我们在回到AsyncCall，看他的execute方法

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 {
          eventListener.callFailed(RealCall.this, e);
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }

getResponseWithInterceptorChain()，熟悉吧，还是原来的配方，还是原来的味道。再看Dispatcher的enqueu方法

synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
  }

很显然，现将这个call添加到一个双向列表，然后启用了一个线程池，调用了这个AsyncCall。最后也是调用dispatcher的finish方法。

盗张图

image

3.拦截器

从刚才分析的流程来看，拦截器是重点，okhttp允许我们自定义拦截器，也有一些默认的拦截器，下面分析一下这些拦截器的作用：

RetroyAndFollowUpInterceptor:处理重定向和失败重连

BridgeInterceptor:请求前添加一些http header，保存cookie，处理zip

CacheInterceptor:处理http响应缓存

ConnectInterceptor:建立与服务器的链接

CallServerInterceptor:发送request并解析response

这里只是简单说一下其作用，有时间单拿出一篇文章详细分析。

image

关注我的公众号