OkHttp学习源码心得

最新推荐文章于 2022-10-10 10:12:29 发布

m0_49044447

最新推荐文章于 2022-10-10 10:12:29 发布

阅读量138

点赞数

文章标签： android java web app

本文链接：https://blog.csdn.net/m0_49044447/article/details/107749225

版权

OkHttp学习源码心得

1.OkHttp的使用流程步骤
- 1.同步请求
- 2.异步请求
2.OkHttpClient
3.Request.
4.Realcall
5.同步请求
- 1.Dispatcher
6.异步请求

1.OkHttp的使用流程步骤

在学习OkHttp之前，我们先来看看OkHttp的大致运行流程图。图片是其他文章的，仅拿来给大家借鉴学习
(图片来源于网络）

这张图应该很清楚的描述了OkHttp大致的运行流程，大家可以先认真看看这个流程再学习后面内容，会更轻松。下面我们再看看用于基本使用的代码总流程。

1.同步请求

   OkHttpClient okHttpClient =new OkHttpClient();
        Request request = new Request.Builder()
                .url(url)
                .build();
       Call call =okHttpClient.newCall(request);
        try {
            Response response =call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }

2.异步请求

       OkHttpClient okHttpClient =new OkHttpClient();
        Request request = new Request.Builder()
                .url(url)
                .build();
       Call call =okHttpClient.newCall(request);
       call.enqueue(new Callback() {
           @Override
           public void onFailure(Call call, IOException e) {

           }

           @Override
           public void onResponse(Call call, Response response) throws IOException {

           }
       });

当然这是OkHttp最基本，最简单的流程。下面我们就一步步讲解流程。

2.OkHttpClient

从图片和代码可以看出来，我们首先得实例化一个OkHttpClient对象才能进行其他的流程。点到OkHttpClient源码里面可以看到里面有很多东西，其他先不管，我们直接看到初始化部分的源码。

 public OkHttpClient() {
    this(new Builder());
  }

  OkHttpClient(Builder builder) {
    this.dispatcher = builder.dispatcher;
    this.proxy = builder.proxy;
    this.protocols = builder.protocols;
    this.connectionSpecs = builder.connectionSpecs;
    this.interceptors = Util.immutableList(builder.interceptors);
    this.networkInterceptors = Util.immutableList(builder.networkInterceptors);
    this.eventListenerFactory = builder.eventListenerFactory;
    this.proxySelector = builder.proxySelector;
    this.cookieJar = builder.cookieJar;
    this.cache = builder.cache;
    this.internalCache = builder.internalCache;
    this.socketFactory = builder.socketFactory;
    ....（省略部分代码）
    }

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

可以看到，OkHttpClient初始化有两种方法，一种是.默认方式，基本参数已经默认好了，调用构造函数配置参数。第二种通过Builder配置参数，最后通过builder()方法返回一个OkHttpClient实例。第一步基本就这些内容。接下来我们看到第二步Request.

3.Request.

可以看到第二步也只是一个实例化一个request对象，也是用Builder模式，这里主要是放一些请求需要的东西。比如URL，请求方式，请求体，请求头等等。接着到第三步，Realcall。

  Builder(Request request) {
      this.url = request.url;//url链接
      this.method = request.method;//请求方式
      this.body = request.body;//请求体
      this.tag = request.tag;//用来标识请求
      this.headers = request.headers.newBuilder();//请求头，带参请求。
    }
       public Request build() {
      if (url == null) throw new IllegalStateException("url == null");
      return new Request(this);
    }

4.Realcall

第三步为什么是讲realcall而不是call呢？从代码里可以看到，call是okHttpClient里的newcall（Request request）方法返回的对象，所以我们直接去OkHttpClient找newcall方法。

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

可以看到，newcall方法本质上是通过RealCall的newRealCall方法返回的call对象。可以看到newRealCall有三个参数OkHttpClient，Request ，第三个参数默认为 false ，那什么时候为ture呢？我们知道OkHttp是默认使用HTTP协议的，而当你使用websocket时，它就为ture。

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

接下来我们就看看newRealCall具体有啥，可以看到，实例化了一个 RealCall对象，并创建了一个eventListener对象。然后返回一个call，这个call其实就是realcall。

5.同步请求

我们先来看同步请求，看看call调用的execute方法。当然我们知道这个call其实是realcall，所以去realcall里寻找。


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

这里首先利用synchronized加入了对象锁，防止多线程同时调用，这里先判断一下executed是否为true判断当前call是否被执行了，如果为ture，则抛出异常，没有则设置为true。captureCallStackTrace()可以大体上理解为retryAndFollowUpInterceptor（重定向拦截器）加入了一个用于追踪堆栈信息的callStackTrace。随后 client调用了dispatcher()进行了executed（）方法。然后再通过getResponseWithInterceptorChain()返回了response对象。这个response对象就是网络请求返回的数据了，而dispatcher和getResponseWithInterceptorChain()就是我们的重点关注对象。先看看dispatcher。

1.Dispatcher

它是一个调度器，是用来进行一个请求测试的分配调度，这里可能是异步的，也可能是同步的，而异步和同步的调度原理和方式就在Dispather这个类中可以详细看到。

public Dispatcher dispatcher() {
    return dispatcher;
  }

在OkHttpClient里仅返回了一个dispatcher对象，我们到dispatcher类里看一看。

public final class Dispdisatcher {
  private int maxRequests = 64;	//默认同时执行的最大请求数， 可以通过setMaxRequests(int)修改.
  private int maxRequestsPerHost = 5;//每个主机默认请求的最大数目， 可以通过setMaxRequestsPerHost(int)修改.
  private @Nullable Runnable idleCallback;//调度没有请求任务时的回调.

  /** Executes calls. Created lazily. */
  //执行异步请求的线程池，默认是 核心线程为0，最大线程数为Integer.MAX_VALUE，空闲等待为60s.
  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<>();//运行中的同步请求队列.

....（省略）
}

可以明显看到里面放了三个队列，同步请求队列，异步请求运行队列，异步请求等待队列。当正在执行的异步队列个数小于maxRequest(64)并且请求同一个主机的个数小于maxRequestsPerHost(5)时，则将这个请求加入异步执行队列runningAsyncCall，并用线程池执行这个call，否则加入异步等待队列。大概了解了dispatcher怎么调度之后,我们来看到同步请求中调度器里的executed方法。

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

这就很明显了，把一开始的realcall对象加入到同步运行队列中。随后的getResponseWithInterceptorChain()方法我会在讲完异步请求后再讲。

6.异步请求

上面我们说了同步和异步我们都需要调度器的使用，那我们来看看异步请求时dispatcher都干了些啥把。首先回到realcall，看看enqueue方法.

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

首先还是synchronized对象锁，防止对线程同时调用，然后进行一个executed的判断，如果为true说明已经运行过这个方法，抛出异常。随后就是captureCallStackTrace()方法。

captureCallStackTrace()

private void captureCallStackTrace() {
    Object callStackTrace = Platform.get().getStackTraceForCloseable("response.body().close()");
    retryAndFollowUpInterceptor.setCallStackTrace(callStackTrace);
  }

这个方法可以看到主要是为retryAndFollowUpInterceptor增加了一个callStackTrace,主要是用来追踪堆栈的信息。然后是前面创建的eventevenListener进行了一个回调，最后就到了我们这个异步请求的核心。

dispatcher().enqueue

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

可以看到这里传入的是一个Asyncall对象，并且还是对主机数和队列数进行一个判断，我们前面在看调度器的时候就有说过，主机数不能大于5，队列数不能大于64.这里判断成功之后就加入了异步的运行队列中，否则就加入准备队列中。可能会有同学问：“请求的返回值response在哪里？”在这段代码里很明显主要是把Asyncall加入到队列中的操作。那最大的可能就是在Asyncall对象中。

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

可以看到Asyncall类里的execute()方法里有返回response,并且也是通过调用getResponseWithInterceptorChain。但这个方法在哪里调用了呢？AsyncCall继承了NameRunnable类，接着看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();
}

这下子明白了，直接在线程里调用了execute的方法。先把当前执行的线程名字换成我们现在传入的名字，然后执行完execute之后再重新改为原来的线程名。然后我们再看回到execute这个方法。

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