#AsyncCall
   @Override protected void execute() {
       boolean signalledCallback = false;
       timeout.enter();
       try {
       //关键，去获取response对象，真正的耗时也就在这
       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) {
           e = timeoutExit(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);
         }
       }
     }
     

6. RealCall#getResponseWithInterceptorChain:
   1. RealCall#getResponseWithInterceptorChain会把用户自定义的拦截器、系统级别的拦截器放到list中组装好，给一个new RealInterceptorChain。这里需要注意拦截器加入的顺序，用户拦截器优先级最高->系统一些中间拦截->最后网络请求。
   2. RealInterceptorChain#proceed在这里会构造一个新的RealInterceptorChain:next，注意新的RealInterceptorChain中index+1;另外根据当前的index取得当前拦截器，执行拦截器中唯一的方法intercept(next)，具体执行的哪一个呢，就看上层实现的是哪一个具体实现。
   3. 我们随便看一个实现，假如BridgeInterceptor:会在BridgeInterceptor中执行BridgeInterceptor相关的实现，最关键的会执行chain.proceed(requestBuilder.build()),注意Chain是上一个创建的RealInterceptorChain，所以又跑到了第二步，同时index这个时候已经+1，如此完成递归操作！
   4. 经过2、3两步，通过迭代操作，完整所有拦截器的执行。至于说网络请求、缓存、重试、日志等等核心包括外围功能，全部通过拦截器实现，并且责任分明，高度解耦合，实现方式：责任链模式。

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

#RealInterceptorChain
@Override public Response proceed(Request request) throws IOException {
    return proceed(request, streamAllocation, httpCodec, connection);
  }

  public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
    //...
    
    //注意这里又构造了一个RealInterceptorChain，重点index+1
    RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
        connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
        writeTimeout);
        
    //取当前index对应的拦截器
    Interceptor interceptor = interceptors.get(index);
    //执行取到的拦截器
    Response response = interceptor.intercept(next);
    
    //...
    return response;
  }

# BridgeInterceptor
@Override public Response intercept(Chain chain) throws IOException {
    //根据上游chain继续处理当前拦截器。注意：chain的源头：RealInterceptorChain#proceed中创建的next,一个新的RealInterceptorChain
    Request userRequest = chain.request();
    Request.Builder requestBuilder = userRequest.newBuilder();

    //各种逻辑，跳过只看核心...
    
    //核心，这里又回到了RealInterceptorChain#proceed
    Response networkResponse = chain.proceed(requestBuilder.build());

    //后续逻辑...

    return responseBuilder.build();
  }