OKHTTP 之责任链理解

okhttp中一开始以为拦截器使用的是动态代理,类似Spring MVC里面的拦截器,当然okhttp仅仅为底层框架是没必要代理的,不过retrofit 使用的是动态代理,后来翻看源码为责任链加递归调用

拦截器调用顺序

RealCall.java

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)); //最底下是CallServerInterceptor 拦截器

    Interceptor.Chain chain = new RealInterceptorChain(
        interceptors, null, null, null, 0, originalRequest);
    return chain.proceed(originalRequest);
  }
  • 在配置 OkHttpClient 时设置的 interceptors;
  • 负责失败重试以及重定向的 RetryAndFollowUpInterceptor;
  • 负责把用户构造的请求转换为发送到服务器的请求、把服务器返回的 响应转换为用户友好的响应的 BridgeInterceptor;
  • 负责读取缓存直接返回、更新缓存的 CacheInterceptor;
  • 负责和服务器建立连接的 ConnectInterceptor;
  • 配置 OkHttpClient 时设置的 networkInterceptors;
  • 负责向服务器发送请求数据、从服务器读取响应数据的 CallServerInterceptor。

RealInterceptorChain.java

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      Connection 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 && !sameConnection(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);
//索引+1 ,这里是使用了RealInterceptorChain的链 进行递归管理的,而不是我们普通上的那种递归,这种使用方式值得考虑,
//这样可以进行一些判断等处理,递归的是类,不是方法,很棒
    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");
    }

    return response;
  }

CacheInterceptor.java


    // If we don't need the network, we're done.
    if (networkRequest == null) {
      return cacheResponse.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build();
    }
    Response networkResponse = null;
    try {
      networkResponse = chain.proceed(networkRequest);  // 此处进行了递归处理
    } finally {
      // If we're crashing on I/O or otherwise, don't leak the cache body.
      if (networkResponse == null && cacheCandidate != null) {
        closeQuietly(cacheCandidate.body());
      }
    }

CallServerInterceptor.java

在最后一个Intercept 里面是直接返回了response 而不是进行继续递归

 httpCodec.finishRequest();

    if (responseBuilder == null) {
      responseBuilder = httpCodec.readResponseHeaders(false);
    }

    Response response = responseBuilder //  这里直接进行了new操作
        .request(request)
        .handshake(streamAllocation.connection().handshake())
        .sentRequestAtMillis(sentRequestMillis)
        .receivedResponseAtMillis(System.currentTimeMillis())
        .build();

    int code = response.code();
    if (forWebSocket && code == 101) {
      // Connection is upgrading, but we need to ensure interceptors see a non-null response body.
      response = response.newBuilder()
          .body(Util.EMPTY_RESPONSE)
          .build();
    } else {
      response = response.newBuilder()
          .body(httpCodec.openResponseBody(response))
          .build();
    }

    if ("close".equalsIgnoreCase(response.request().header("Connection"))
        || "close".equalsIgnoreCase(response.header("Connection"))) {
      streamAllocation.noNewStreams();
    }

    if ((code == 204 || code == 205) && response.body().contentLength() > 0) {
      throw new ProtocolException(
          "HTTP " + code + " had non-zero Content-Length: " + response.body().contentLength());
    }

    return response;

总结:

  • 首先定义拦截器一层层往下运行,直到最底下的拦截器返回response ,一层层往上透传,直到最上层,然后处理一些信息,这个很像事件传递机制,类比下

推荐阅读更多精彩内容

  • 前言 用了那么久的OkHttp,解决了不少的联网问题。对于热门的好轮子,总不能一直停留在会用这个层面上吧,是时候动...
    Goo_Yao阅读 1,499评论 3 11
  • OkHttp源码的samples的简单使用的示例: public static void main(String....
    _warren阅读 307评论 0 1
  • 这篇文章主要讲 Android 网络请求时所使用到的各个请求库的关系,以及 OkHttp3 的介绍。(如理解有误,...
    小庄bb阅读 665评论 0 4
  • 缓存的一般思路 下面是我理解的网络请求框架的缓存基本实现。大致的过程是有缓存用缓存的数据,没缓存发起http请求取...
    原件阅读 1,499评论 3 10
  • 下个路口还是没有你 搞不懂自己为什么要答应 如果这五个多月我仍然孤寂 生活不就是平淡自然而简单 我这么多的小情绪 ...
    整个宇宙我最帅阅读 40评论 0 2