Okhttp框架源码分析

96
懒癌患者2018
2017.07.10 18:53* 字数 827

1.OkHttp的简单使用

一般情况下,对于网络框架有两种常见的使用场景,同步请求和异步请求。
同步请求:

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url("http://www.baidu.com").build();
Call call = client.newCall(request);
Response response = call.execute();

异步请求:

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url("http://www.baidu.com").build();
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {

    }

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

    }
});

上面代码比较简单,并不是本文的重点。旨在抛砖引玉...

2.OkHttp内部相关类的介绍

  • OkHttpClient:Okhttp的主类,一般情况下设计成单列使用。
  • Request:OkHttp的请求类,可以分装了请求消息头,消息实体相关的信息
  • Response:OkHttp的响应类,分装了相应码,相应实体相关的信息
  • Call:对于OkHttp来说,一个call对应一次网络请求操作
  • RealCall:Call接口的真正实现
  • AsyncCall:当执行的时移步请求时,会转化成AsyncCall,它实现Runnable接口,是对RealCall的再次封装
  • Dispatcher:用来分发请求任务的类
  • RetryAndFollowUpInterceptor:负责重连和重定向的拦截器
  • BridgeInterceptor:桥拦截器,处理请求头
  • CacheInterceptor:缓存拦截器
  • ConnectInterceptor:连接拦截器
  • CallServerInterceptor:服务相应拦截器

3.OkHttp内部执行流程介绍

同步请求流程:
当一次同步请求被执行时,会先调用RealCall的excute方法

  @Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    try {
      client.dispatcher().executed(this);
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } finally {
      client.dispatcher().finished(this);
    }
  }

这个方法的作用是先对同步请求进行分发,调用的Diapatcher的excuted方法,这个方法只是将请求缓存到dispatcher的runningSyncCalls的队列集合中,然后调用RealCall自己的getResponseWithInterceptorChain方法,这是整体OkHttp最为核心的方法,这个一个拦截器链,它将一层层过滤请求,最终返回响应,然后在调用dispatcher的finished方法,就是从runningSyncCalls队列集合中将请求剔除。这就是一次完整的okhttp的同步请求。

异步请求流程:
当一次异步请求被执行时,会先调用RealCall的enqueue方法

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

这个方法的作用时判断这个请求是否已经被执行了,如果没有被执行,会将这个RealCall转化成AsyncCall对象,然后把他交给dispatcher类进行分发,dispather对象中有两个队列集合跟异步请求有关系。

/** 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<>();

这两个队列集合从名字上就可以看出一个是准备去执行的异步请求,一个时正在执行中的异步请求。dsipather的enqueue方法会对异步请求做进一步处理

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

这个方法的逻辑很清晰,如果超过最大任务数量64个,或者同一个域名任务数5个,它将进入准备队列,反之将进入执行队列,交由线程池执行。因为AsyncCall继承了NamedRunnable类,而NamedRunnable类实现了Runnable接口,所以最终的执行方法在AsyncCall的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 {
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }

这个方法的逻辑的核心还是getResponseWithInterceptorChai这个方法,根据这个方法的返回回调Callback接口实现,然后在Dispatcher中的集合中剔除。

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);
    return chain.proceed(originalRequest);
  }

这个就是getResponseWithInterceptorChain的方法实现,这个就是一个责任链设计的拦截器链,每个拦截器层层处理。

以上就是okhttp内部的大致使用流程。

日记本