OkHttp 流程浅析 - NoHarry的博客

OkHttpClient client=new OkHttpClient.Builder().build();
//创建Request
Request request=new Request
    .Builder()
    .url(url)
    .build();
//发送一个异步请求
client.newCall(request).enqueue(new Callback() {
  
  public void (Call call, IOException e) {
  }
  
  public void onResponse(Call call, Response response) throws IOException {
  }
});
//发送一个同步请求
try {
  Response response = client.newCall(request).execute();
} catch (IOException e) {
  e.printStackTrace();
}

public final class Request {
  final HttpUrl url;
  final String method;
  final Headers headers;
  final @Nullable RequestBody body;
  final Map<Class<?>, Object> tags;
  private volatile @Nullable CacheControl cacheControl;
  Request(Builder builder) {
    this.url = builder.url;
    this.method = builder.method;
    this.headers = builder.headers.build();
    this.body = builder.body;
    this.tags = Util.immutableMap(builder.tags);
  }
  ...
  public static class Builder {
    @Nullable HttpUrl url;
    String method;
    Headers.Builder headers;
    @Nullable RequestBody body;
    Map<Class<?>, Object> tags = Collections.emptyMap();
    ....
  }
}

final class RealCall implements Call {
  ...
  private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    //构建的OkHttpClient
    this.client = client;
    //用户构建的Request
    this.originalRequest = originalRequest;
    //是不是WebSocket请求
    this.forWebSocket = forWebSocket;
    //构建RetryAndFollowUpInterceptor拦截器
    this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
    //Okio中提供的用于超时机制的方法
    this.timeout = new AsyncTimeout() {
       protected void timedOut() {
        cancel();
      }
    };
    this.timeout.timeout(client.callTimeoutMillis(), MILLISECONDS);
  }
  ...
}

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;
   }
   /**
    * Attempt to enqueue this async call on {@code executorService}. This will attempt to clean up
    * if the executor has been shut down by reporting the call as failed.
    */
   void executeOn(ExecutorService executorService) {
     assert (!Thread.holdsLock(client.dispatcher()));
     boolean success = false;
     try {
       executorService.execute(this);
       success = true;
     } catch (RejectedExecutionException e) {
       InterruptedIOException ioException = new InterruptedIOException("executor rejected");
       ioException.initCause(e);
       eventListener.callFailed(RealCall.this, ioException);
       responseCallback.onFailure(RealCall.this, ioException);
     } finally {
       if (!success) {
         client.dispatcher().finished(this); // This call is no longer running!
       }
     }
   }
   @Override protected void execute() {
     boolean signalledCallback = false;
     timeout.enter();
     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) {
       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);
     }
   }
 }

public final class Dispatcher {
  private int maxRequests = 64;
  private int maxRequestsPerHost = 5;
  private @Nullable Runnable idleCallback;
  /** Executes calls. Created lazily. */
  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<>();
  void enqueue(AsyncCall call) {
      synchronized (this) {
        readyAsyncCalls.add(call);
      }
      promoteAndExecute();
    }
  synchronized void executed(RealCall call) {
      runningSyncCalls.add(call);
    }
  private boolean promoteAndExecute() {
    assert (!Thread.holdsLock(this));
    List<AsyncCall> executableCalls = new ArrayList<>();
    boolean isRunning;
    synchronized (this) {
      for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
        AsyncCall asyncCall = i.next();
        if (runningAsyncCalls.size() >= maxRequests) break; // Max capacity.
        if (runningCallsForHost(asyncCall) >= maxRequestsPerHost) continue; // Host max capacity.
        i.remove();
        executableCalls.add(asyncCall);
        runningAsyncCalls.add(asyncCall);
      }
      isRunning = runningCallsCount() > 0;
    }
    for (int i = 0, size = executableCalls.size(); i < size; i++) {
      AsyncCall asyncCall = executableCalls.get(i);
      asyncCall.executeOn(executorService());
    }
    return isRunning;
  }
}

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