Android高频面试专题 - 架构篇（二）okhttp面试必知必会

//1.创建OkHttpClient
OkHttpClient client = new OkHttpClient();
//2.创建Request，并填入url信息
String run(String url) throws IOException {
Request request = new Request.Builder()
    .url(url)
    .build();
//3.同步请求
Response response = client.newCall(request).execute();
//4.异步请求
client.newCall(request).enqueue(responseCallback)；

@Override 
public Response execute() throws IOException {
    synchronized (this) {
      //1.如果该请求已经运行抛出异常，否则将运行标志位置为true，防止重复请求
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    //2.捕获调用堆栈的跟踪
    captureCallStackTrace();
    //告知eventlisten请求开始
    eventListener.callStart(this);
    try {
      //3.通过dispatcher的executed来实际执行
      client.dispatcher().executed(this);
      //4.经过一系列"拦截"操作后获取结果
      Response result = getResponseWithInterceptorChain();
      //如果result为空抛出异常
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      //告知eventlisten请求失败
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      //通知dispatcher执行完毕
      client.dispatcher().finished(this);
    }
}

Response getResponseWithInterceptorChain() throws IOException {
    //创建一个拦截器链表用于存放各种拦截器
    List<Interceptor> interceptors = new ArrayList<>();
    //向链表中添加用户自定义的拦截器
    interceptors.addAll(client.interceptors());
    //1.向链表中添加retryAndFollowUpInterceptor用于失败重试和重定向 
    interceptors.add(retryAndFollowUpInterceptor);
    //2.向链表中添加BridgeInterceptor用于把用户构造的请求转换为发送给服务器的请求，把服务器返回的响应转换为对用户友好的响应。
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    //3.向链表中添加CacheInterceptor用于读取缓存以及更新缓存
    interceptors.add(new CacheInterceptor(client.internalCache()));
    //4.向链表中添加ConnectInterceptor用于与服务器建立连接
    interceptors.add(new ConnectInterceptor(client));
    //如果不是webSocket添加networkInterceptors
    if (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    //5.向链表中添加CallServerInterceptor用于从服务器读取响应的数据
    interceptors.add(new CallServerInterceptor(forWebSocket));
    //根据上述的拦截器链表生成一个拦截链
    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());
    //通过拦截链的proceed方法开始整个拦截链事件的传递
    return chain.proceed(originalRequest);
  }

@Override 
public void enqueue(Callback responseCallback) {
  synchronized (this) {
    //1.如果该请求正在运行抛出异常，否则将运行标志位置为true，防止重复请求
    if (executed) throw new IllegalStateException("Already Executed");
    executed = true;
  }
  //2.捕获调用堆栈的跟踪
  captureCallStackTrace();
  eventListener.callStart(this);
  //3.通过dispatcher的enqueue将此次请求添加到异步队列
  client.dispatcher().enqueue(new AsyncCall(responseCallback));
}

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

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

  public final String string() throws IOException {
    BufferedSource source = source();
    try {
      Charset charset = Util.bomAwareCharset(source, charset());
      return source.readString(charset);
    } finally {
      //这里讲resource给悄悄close了
      Util.closeQuietly(source);
    }
  }