Okhttp3源码

hi,大家好，我是爱吃香蕉的猴子，Okhttp3的源码之前没有怎深入了解，最近看了很多Okhttp3源码的文章，看的云里雾里，在这我也不贴连接了，整理一篇自己理解的吧。

源码Githup地址 具体的使用过程上面也有介绍，现在步入正题。

从使用步骤切入，再进入源码，最后总结

OkHttpClient client = new OkHttpClient.Builder().build();
        Request request = new Request.Builder().
                url("https://github.com/square/okhttp").
                build();
        Call call = client.newCall(request);
        try {
            Response response = call.execute();
            call.enqueue(new Callback() {//异步
                @Override
                public void onFailure(Call call, IOException e) {
                }
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
           

上面的代码是规规矩矩的使用范例，现在我们逐一解析

• ①OkHttpClient client = new OkHttpClient.Builder().build();
• 第一步声明client对象，如何声明呢？ 为什么通过Builder().builder()？
• 那肯定要看OkHttpClient的代码； path: OkHttp\okhttp\okhttp\src\main\java\okhttp3\OkHttpClient.java

public Builder() {
      dispatcher = new Dispatcher();//重点 分析Dispatcher
      protocols = DEFAULT_PROTOCOLS;//默认支持的协议
      connectionSpecs = DEFAULT_CONNECTION_SPECS;//默认的连接规范
      eventListenerFactory = EventListener.factory(EventListener.NONE);
      proxySelector = ProxySelector.getDefault();//默认的代理选择器，直连
       ........
           

• 在这个Builder构造器中，初始化了dispatcher, 在看一下build方法

public OkHttpClient build() {
      return new OkHttpClient(this);
    }
           

这样就声明了client对象，并初始化了dispatcher等等.

• ②Request request = new Request.Builder().url().build();
• 这一步就是初始化request; 方法和OkhttpClient很一样， 注释的大概意思：一个HTTP请求。我理解为对请求链接的处理吧
• 然后主要就是要将request(数据请求连接)放入newCall中。

public Builder() {
      this.method = "GET"; //get的请求方式
      this.headers = new Headers.Builder();
    }
           

• ③Call call = client.newCall(request);
• 上面两步的执行，就是为第三步做准备的，现在 在okhttpclient中newCall方法声明了call对象.

/**
   * Prepares the {@code request} to be executed at some point in the future.
   */
  @Override public Call newCall(Request request) {
    return RealCall.newRealCall(this, request, false /* for web socket */);
  }
           

• Call是一个interface, RealCall是真正的实现类，可以着重看RealCall；
• path: OkHttp\okhttp\okhttp\src\main\java\okhttp3\RealCall.java

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.transmitter = new Transmitter(client, call);
    return call;
  }
           

这样就是初始化了call, 这样就要开始异步请求的工作；

• ④ call.enqueue(new Callback() {

@Override public void enqueue(Callback responseCallback) {
     。。。。
    //client.dispatcher()返回一个Dispatcher对象，异步请求调度器，里面会对任务进行分辨，是立刻执行还是放入等待队列
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }
           

• 最后的代码中参数new AsyncCall(responseCallback); 我们来猜一下 这个类是干嘛的，我的直觉是和Runnable有关，因为毕竟异步请求嘛
• final class AsyncCall extends NamedRunnable { //果然继承NameRunnable
• 这样RealCall的代码暂时看到这里，现在看Dispatcher的enqueue方法；

path: OkHttp\okhttp\okhttp\src\main\java\okhttp3\Dispatcher.java

• 先看一些变量

private int maxRequests = 64;//最大并发数为64，同时请求
  private int maxRequestsPerHost = 5;//每个主机的最大请求数为5
  private @Nullable Runnable idleCallback;//闲置接口
  /** Executes calls. Created lazily. */
  private @Nullable ExecutorService executorService;//线程池
  /** Ready async calls in the order they'll be run. */
  //缓存好的异步调用，都是放在队列里保存
  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
  /** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
  //运行中的异步调用，都是放在队列里保存
  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
  /** Running synchronous calls. Includes canceled calls that haven't finished yet. */
  //运行中的同步调用，都是放在队列里保存
  private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();
           

void enqueue(AsyncCall call) {
    synchronized (this) {
    readyAsyncCalls.add(call);//缓存好的异步调用，都是放在队列里保存
      。。。
    //TODO 
    promoteAndExecute();//这一步就是增加线程池
  }
           

进入promoteAndExecute看一下

private boolean promoteAndExecute() {
        。。。。。
        //如果当前运行的异步请求队列长度小于最大请求数，也就是64,并且主机的请求数小于每个主机的请求数也就是5,
        //则把当前请求添加到 运行队列，接着交给线程池ExecutorService处理，否则则放置到readAsyncCall进行缓存，等待执行
        if (runningAsyncCalls.size() >= maxRequests) break; // Max capacity.
        if (asyncCall.callsPerHost().get() >= maxRequestsPerHost) continue; // Host max capacity.
    。。。。。
    for (int i = 0, size = executableCalls.size(); i < size; i++) {
      AsyncCall asyncCall = executableCalls.get(i);
      //进入线程池
      asyncCall.executeOn(executorService());
    }
    return isRunning;
  }
           

• 网络请求数据，增加线程池 提高效率，进入线程池看一下–> executorService;

//同步最大的区别
  public synchronized ExecutorService executorService() {
    if (executorService == null) {
      executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue<>(), Util.threadFactory("OkHttp Dispatcher", false));
    }
    return executorService;
  }
           

• 小结：添加到线程池后就交给ThreadPoolExecutor去调用，最终则是调用到我们的请求AsyncCall的execute方法。回看上面的代码，异步请求中，我们传递了个Callback接口进来，而在RealCall的enqueue方法中，Callback回调接口被封装到AsyncCall中，而AsyncCall继承与NamedRunnable，而NamaedRunnable则实现了Runnable方法。

• 现在，返回到RealCall中查看executeOn方法；

  path: OkHttp\okhttp\okhttp\src\main\java\okhttp3\RealCall.java # 内部类：AsyncCall

/**
     * Attempt to enqueue this async call on {@code executorService}. This will attempt to clean up
     * if the executor has been shut down by reporting the call as failed.
     */
    void executeOn(ExecutorService executorService) {
      assert (!Thread.holdsLock(client.dispatcher()));
      boolean success = false;
      try {
        executorService.execute(this);
           

进入executorService.execute(this);查看

@Override protected void execute() {
      boolean signalledCallback = false;
      transmitter.timeoutEnter();
      try {
        //重点: 看OkHttp如何连接返回
        Response response = getResponseWithInterceptorChain();
        signalledCallback = true;
        responseCallback.onResponse(RealCall.this, response);
           

现在要对返回值处理： getResponseWithInterceptorChain

Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());
    interceptors.add(new RetryAndFollowUpInterceptor(client));
    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, transmitter, null, 0,
        originalRequest, this, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());
           

• 这样就分析到了，Okhttp的关键部分拦截器

  用户自定义连接器

RetryAndFollowUpInterceptor：在连接失败后进行重新连接，必要时进行重定向，如果调用被取消，可能会抛出IOException

BridgeInterceptor：构建访问网络的桥梁，首先，将用户请求转换成网络请求，然后访问网络，最后将网络响应转换成用户响应。

CacheInterceptor：缓存拦截器，从缓存中获取服务器请求，或者把服务器响应写入缓存中。

ConnectInterceptor：打开一个连接，去连接目标服务器。

CallServerInterceptor：拦截器链中的最后一个链点，通过网络请求服务器。