学习一下OkHttp原理，探究他发送请求的过程
合理的跳过了一些内容，比如DNS、Cookie、Protocol、okio
OkHttp版本3.14.9

btn.setOnClickListener(v -> {
    new Thread(() -> {
        OkHttpClient client = new OkHttpClient.Builder().build();
        Request request = new Request.Builder()
                .url("这里是一个能访问的url")  
                .build();
        Call call = client.newCall(request);
        try{
            //同步请求
            Response response = call.execute();
            System.out.println(response.body().string());
        }catch(IOException e){
            e.printStackTrace();
        }
    }).start();


    OkHttpClient client = new OkHttpClient.Builder().build();
                Request request = new Request.Builder()
                        .url("这里是一个能访问的url")
                        .build();
                Call call = client.newCall(request);

                call.enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {

                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            System.out.println(response.body().string());
                        }
                    });



});

随便写了一个按钮，定义 OkHttpClient 、 Request 、 Call, 然后同步请求，写了一个最少的http代码请求，返回 Response 输出body
2块内容一个是同步请求，一个是异步请求，同步请求不加线程会抛出异常

开始

OkHttpClient.Builder()

看到 OkHttpClient.Builder() 我已经不想开了，肯定是初始各种值
build()各种赋值，然后返回一个 OkHttpClient 对象

Builder(OkHttpClient okHttpClient) {
  this.dispatcher = okHttpClient.dispatcher;//调度器
  //..
  this.connectionPool = okHttpClient.connectionPool;
  //..
  this.callTimeout = okHttpClient.callTimeout;
  this.connectTimeout = okHttpClient.connectTimeout;
  this.readTimeout = okHttpClient.readTimeout;
  this.writeTimeout = okHttpClient.writeTimeout;
  this.pingInterval = okHttpClient.pingInterval;
}

只留关键的，看名字大概都能知道是什么了
调度器，连接池，call超时，连接超时等等，其他的基本也能根据名字看出来是干什么的

Request.Builder()

public static class Builder {
  @Nullable HttpUrl url;
  String method;
  Headers.Builder headers;
  @Nullable RequestBody body;

  Map<Class<?>, Object> tags = Collections.emptyMap();

  public Builder() {
    this.method = "GET";
    this.headers = new Headers.Builder();
  }
}

一个请求包含url、method、headers和body,默认GET

client.newCall(request)

@Override public Call newCall(Request request) {
  return RealCall.newRealCall(this, request, false);
}

static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
  RealCall call = new RealCall(client, originalRequest, forWebSocket);
  call.transmitter = new Transmitter(client, call);
  return call;
}

根据 newCall() 返回了一个 RealCall 对象,还new了一个Transmitter发射器，对象交给了call
看一下RealCall和Transmitter构造函数

private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
  this.client = client;
  this.originalRequest = originalRequest;
  this.forWebSocket = forWebSocket;
}
public Transmitter(OkHttpClient client, Call call) {
  this.client = client;
  this.connectionPool = Internal.instance.realConnectionPool(client.connectionPool());
  this.call = call;
  this.eventListener = client.eventListenerFactory().create(call);
  this.timeout.timeout(client.callTimeoutMillis(), MILLISECONDS);
}

也是简单的初始化，不过能看出这个RealCall已经有了发射器，并且里面有连接池了

call.execute() 同步请求

关键部分，先看call.execute()，同步执行，根据安卓机制必须在子线程

@Override public Response execute() throws IOException {
  //保证只有一个执行
  synchronized (this) {
    if (executed) throw new IllegalStateException("Already Executed");
    executed = true;
  }
  transmitter.timeoutEnter();
  transmitter.callStart();
  try {
    client.dispatcher().executed(this);
    return getResponseWithInterceptorChain();
  } finally {
    client.dispatcher().finished(this);
  }
}

//dispatcher的executed， 这里把RealCall放到了同步队列里
synchronized void executed(RealCall call) {
  runningSyncCalls.add(call);
}

getResponseWithInterceptorChain() 是库的最关键代码,直接贴代码
interceptor 是拦截器的意思

Response getResponseWithInterceptorChain() throws IOException {
  //创建了一个拦截器List,然后添加了写拦截器对象
  List<Interceptor> interceptors = new ArrayList<>();
  //这是自定义的 先不管
  interceptors.addAll(client.interceptors());
  //重定向拦截器
  interceptors.add(new RetryAndFollowUpInterceptor(client));
  //桥拦截器
  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, transmitter, null, 0,
      originalRequest, this, client.connectTimeoutMillis(),
      client.readTimeoutMillis(), client.writeTimeoutMillis());

  boolean calledNoMoreExchanges = false;
  try {
    //这里是正真的把拦截器串联起来的地方 ，并返回Response对象
    Response response = chain.proceed(originalRequest);
    if (transmitter.isCanceled()) {
      closeQuietly(response);
      throw new IOException("Canceled");
    }
    return response;
  } catch (IOException e) {
    calledNoMoreExchanges = true;
    throw transmitter.noMoreExchanges(e);
  } finally {
    if (!calledNoMoreExchanges) {
      transmitter.noMoreExchanges(null);
    }
  }
}

看看是怎么连起来的
chain.proceed(originalRequest) 执行拦截器方法

public final class RealInterceptorChain implements Interceptor.Chain {
  @Override public Response proceed(Request request) throws IOException {
    return proceed(request, transmitter, exchange);
  }

  public Response proceed(Request request, Transmitter transmitter, @Nullable Exchange exchange)throws IOException {

    //保留重要代码

    // Call the next interceptor in the chain.
    RealInterceptorChain next = new RealInterceptorChain(interceptors, transmitter, exchange,
        index + 1, request, call, connectTimeout, readTimeout, writeTimeout);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);


    return response;
  }
}

可以看到 RealInterceptorChain 类实现了 Interceptor.Chain 接口,完成了 proceed(Request request) 方法
在下面的　proceed(...) 中,又new了一个 RealInterceptorChain 把拦截器List等参数又传了进去，有个关键的变量 index
也就是说 自己new了自己，并告诉new出来的自己索引+1
在看下面2行获取了一个拦截器，执行他的拦截方法interceptor.intercept(next)
这里构造了一个 责任链模式，简单理解下责任链模式，有点链表结构的感觉，但不是链表，相当于把一个节点一个节点的连起来，当输出第一个节点，会依次调用下面一个节点输出内容
按着顺序来取第一个拦截器

1、RetryAndFollowUpInterceptor 重定向拦截器

重定向拦截器：主要负责失败重连，但并不是所有失败都重连

public final class RetryAndFollowUpInterceptor implements Interceptor {
  @Override public Response intercept(Chain chain) throws IOException {
      Request request = chain.request();
      RealInterceptorChain realChain = (RealInterceptorChain) chain;
      Transmitter transmitter = realChain.transmitter();

      int followUpCount = 0;
      Response priorResponse = null;
      while (true) {
        transmitter.prepareToConnect(request);
        //如果取消就抛异常
        if (transmitter.isCanceled()) {
          throw new IOException("Canceled");
        }

        Response response;
        boolean success = false;
        try {
          //使用realChain执行下一个拦截器
          //为什么要直接执行下一个拦截器？
          //因为这个是为重定向做的拦截器，肯定是等请求返回结果之后再决定是否要重定向
          response = realChain.proceed(request, transmitter, null);
          success = true;
        } catch (RouteException e) {
          // The attempt to connect via a route failed. The request will not have been sent.
          if (!recover(e.getLastConnectException(), transmitter, false, request)) {
            throw e.getFirstConnectException();
          }
          continue;
        }//这里删了catch，出了异常，catch肯定是关闭流

        //如果priorResponse不为null，又newBuilder()
        //把上一个Response和现在的结合在一起
        //正常来说第一次肯定是空的
        //prior 先前的，先前的Response不为null
        if (priorResponse != null) {
          response = response.newBuilder()
              .priorResponse(priorResponse.newBuilder()
                      .body(null)
                      .build())
              .build();
        }

        Exchange exchange = Internal.instance.exchange(response);
        Route route = exchange != null ? exchange.connection().route() : null;
        //检查是否符合要求
        //这个方法里是一个switch、case去找HttpCode状态码 比如200，404
        Request followUp = followUpRequest(response, route);

        //正常来说应该是200 followUpRequest()就会返回null
        if (followUp == null) {
          if (exchange != null && exchange.isDuplex()) {
            transmitter.timeoutEarlyExit();
          }
          return response;
        }

        RequestBody followUpBody = followUp.body();
        if (followUpBody != null && followUpBody.isOneShot()) {
          return response;
        }

        closeQuietly(response.body());
        if (transmitter.hasExchange()) {
          exchange.detachWithViolence();
        }
        //限制重定向次数
        if (++followUpCount > MAX_FOLLOW_UPS) {
          throw new ProtocolException("Too many follow-up requests: " + followUpCount);
        }

        request = followUp;
        priorResponse = response;
      }
    }
}

这个拦截器就是先请求，请求返回数据之后根据数据来判断，是否需要重定向

2、BridgeInterceptor 桥拦截器

这里很长，桥拦截器主要用来添加头部信息、编码方式

public final class BridgeInterceptor implements Interceptor {
  @Override public Response intercept(Chain chain) throws IOException {
    Request userRequest = chain.request();
    Request.Builder requestBuilder = userRequest.newBuilder();

    RequestBody body = userRequest.body();
    if (body != null) {
      MediaType contentType = body.contentType();
      if (contentType != null) {
        requestBuilder.header("Content-Type", contentType.toString());
      }

      long contentLength = body.contentLength();
      if (contentLength != -1) {
        requestBuilder.header("Content-Length", Long.toString(contentLength));
        requestBuilder.removeHeader("Transfer-Encoding");
      } else {
        requestBuilder.header("Transfer-Encoding", "chunked");
        requestBuilder.removeHeader("Content-Length");
      }
    }

    if (userRequest.header("Host") == null) {
      requestBuilder.header("Host", hostHeader(userRequest.url(), false));
    }

    if (userRequest.header("Connection") == null) {
      requestBuilder.header("Connection", "Keep-Alive");
    }

    // If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing
    // the transfer stream.
    boolean transparentGzip = false;
    if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
      transparentGzip = true;
      requestBuilder.header("Accept-Encoding", "gzip");
    }

    List<Cookie> cookies = cookieJar.loadForRequest(userRequest.url());
    if (!cookies.isEmpty()) {
      requestBuilder.header("Cookie", cookieHeader(cookies));
    }

    if (userRequest.header("User-Agent") == null) {
      requestBuilder.header("User-Agent", Version.userAgent());
    }

    //这里调用下一层的拦截器
    Response networkResponse = chain.proceed(requestBuilder.build());
    //下面是处理cookie缓存和GZip的内容
    HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());

    Response.Builder responseBuilder = networkResponse.newBuilder()
        .request(userRequest);

    //判断服务器是否支持GZip，支持交给okio处理
    if (transparentGzip
        && "gzip".equalsIgnoreCase(networkResponse.header("Content-Encoding"))
        && HttpHeaders.hasBody(networkResponse)) {
      GzipSource responseBody = new GzipSource(networkResponse.body().source());
      Headers strippedHeaders = networkResponse.headers().newBuilder()
          .removeAll("Content-Encoding")
          .removeAll("Content-Length")
          .build();
      responseBuilder.headers(strippedHeaders);
      String contentType = networkResponse.header("Content-Type");
      //处理之后build 一个新的Response
      responseBuilder.body(new RealResponseBody(contentType, -1L, Okio.buffer(responseBody)));
    }

    return responseBuilder.build();
  }
}

这里就是3段内容，增加头信息、调用下一层拦截器、处理缓存和GZip

3、CacheInterceptor 缓存拦截器

缓存拦截器，顾名思义处理缓存

public final class CacheInterceptor implements Interceptor {
  @Override public Response intercept(Chain chain) throws IOException {
     Response cacheCandidate = cache != null
         ? cache.get(chain.request())
         : null;

     long now = System.currentTimeMillis();

     CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
     Request networkRequest = strategy.networkRequest;
     Response cacheResponse = strategy.cacheResponse;

     if (cache != null) {
       cache.trackResponse(strategy);
     }

     if (cacheCandidate != null && cacheResponse == null) {
       closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.
     }

     //注释写明了，如果没网和没缓存 直接返回失败
     // If we're forbidden from using the network and the cache is insufficient, fail.
     if (networkRequest == null && cacheResponse == null) {
       return new Response.Builder()
           .request(chain.request())
           .protocol(Protocol.HTTP_1_1)
           .code(504)
           .message("Unsatisfiable Request (only-if-cached)")
           .body(Util.EMPTY_RESPONSE)
           .sentRequestAtMillis(-1L)
           .receivedResponseAtMillis(System.currentTimeMillis())
           .build();
     }
     //这里没网
     // 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());
       }
     }

     // If we have a cache response too, then we're doing a conditional get.
     //如果有缓存并且code为304，使用缓存内容
     if (cacheResponse != null) {
       if (networkResponse.code() == HTTP_NOT_MODIFIED) {
         Response response = cacheResponse.newBuilder()
             .headers(combine(cacheResponse.headers(), networkResponse.headers()))
             .sentRequestAtMillis(networkResponse.sentRequestAtMillis())
             .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
             .cacheResponse(stripBody(cacheResponse))
             .networkResponse(stripBody(networkResponse))
             .build();
         networkResponse.body().close();

         // Update the cache after combining headers but before stripping the
         // Content-Encoding header (as performed by initContentStream()).
         cache.trackConditionalCacheHit();
         cache.update(cacheResponse, response);
         return response;
       } else {
         closeQuietly(cacheResponse.body());
       }
     }

     Response response = networkResponse.newBuilder()
         .cacheResponse(stripBody(cacheResponse))
         .networkResponse(stripBody(networkResponse))
         .build();

     if (cache != null) {
       if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
         // Offer this request to the cache.
         CacheRequest cacheRequest = cache.put(response);
         return cacheWritingResponse(cacheRequest, response);
       }

       if (HttpMethod.invalidatesCache(networkRequest.method())) {
         try {
           cache.remove(networkRequest);
         } catch (IOException ignored) {
           // The cache cannot be written.
         }
       }
     }

     return response;
   }
}

这一层也很明确，专门处理缓存，有个关键cache对象，如果最开始okhttp初始化，赋值了，则会使用这个缓存，如果没赋值则不会使用。

4、ConnectInterceptor 连接拦截器

连接拦截器，这层是关键内容，也最复杂，负责与服务器建立连接

public final class ConnectInterceptor implements Interceptor {
  public final OkHttpClient client;

  @Override public Response intercept(Chain chain) throws IOException {
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Request request = realChain.request();
    Transmitter transmitter = realChain.transmitter();

    // We need the network to satisfy this request. Possibly for validating a conditional GET.
    boolean doExtensiveHealthChecks = !request.method().equals("GET");
    Exchange exchange = transmitter.newExchange(chain, doExtensiveHealthChecks);

    return realChain.proceed(request, transmitter, exchange);
  }
}
//前面只是获取对象
//关键 发射机 transmitter.newExchange(chain, doExtensiveHealthChecks)

public final class Transmitter {
  //这个exchangeFinder也是new出来的
  private ExchangeFinder exchangeFinder;

  //这里看方法是返回一个Exchange对象
  //我也不知道为什么要叫这个名字，历史版本我也没看过
  Exchange newExchange(Interceptor.Chain chain, boolean doExtensiveHealthChecks) {
    synchronized (connectionPool) {
      if (noMoreExchanges) {
        throw new IllegalStateException("released");
      }
      if (exchange != null) {
        throw new IllegalStateException("cannot make a new request because the previous response "
            + "is still open: please call response.close()");
      }
    }
    //exchangeFinder，exchange查找器
    ExchangeCodec codec = exchangeFinder.find(client, chain, doExtensiveHealthChecks);
    Exchange result = new Exchange(this, call, eventListener, exchangeFinder, codec);

    synchronized (connectionPool) {
      this.exchange = result;
      this.exchangeRequestDone = false;
      this.exchangeResponseDone = false;
      return result;
    }
  }
}
//Exchange查找器
final class ExchangeFinder {

  public ExchangeCodec find(
        OkHttpClient client, Interceptor.Chain chain, boolean doExtensiveHealthChecks) {
      int connectTimeout = chain.connectTimeoutMillis();
      int readTimeout = chain.readTimeoutMillis();
      int writeTimeout = chain.writeTimeoutMillis();
      int pingIntervalMillis = client.pingIntervalMillis();
      boolean connectionRetryEnabled = client.retryOnConnectionFailure();
      //上面只是赋值 连接时间 读取时间超时等等
      try {
        //获取一个健康的连接
        RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
            writeTimeout, pingIntervalMillis, connectionRetryEnabled, doExtensiveHealthChecks);
        return resultConnection.newCodec(client, chain);
      } catch (RouteException e) {
        trackFailure();
        throw e;
      } catch (IOException e) {
        trackFailure();
        throw new RouteException(e);
      }
    }
    //寻找一个健康的连接
    private RealConnection findHealthyConnection(int connectTimeout, int readTimeout,int writeTimeout, int pingIntervalMillis, boolean connectionRetryEnabled,boolean doExtensiveHealthChecks) throws IOException {
      while (true) {
        //while ture 去寻找一个 连接
        //这里死循环去找链接的连接 可能是有问题的连接
        RealConnection candidate = findConnection(connectTimeout, readTimeout, writeTimeout,
            pingIntervalMillis, connectionRetryEnabled);

        synchronized (connectionPool) {
          //这里锁 一下 判断 ，如果是全新的连接就直接返回
          if (candidate.successCount == 0 && !candidate.isMultiplexed()) {
            return candidate;
          }
        }

        //这里判断连接是否健康，无非是socket没有关闭，等等
        if (!candidate.isHealthy(doExtensiveHealthChecks)) {
          candidate.noNewExchanges();
          continue;
        }

        return candidate;
      }
    }

  //最长代码，一点点看
vate RealConnection findConnection(int connectTimeout, int  dTimeout, int writeTimeout,
nt pingIntervalMillis, boolean connectionRetryEnabled) throws OException {
  boolean foundPooledConnection = false;
  RealConnection result = null;
  Route selectedRoute = null;
  RealConnection releasedConnection;
  Socket toClose;
  synchronized (connectionPool) {
    if (transmitter.isCanceled()) throw new IOException("Canceled");
    hasStreamFailure = false; // This is a fresh attempt.

    //这里锁池子，看看当前发射机transmitter里面的连接能不能用
    releasedConnection = transmitter.connection;
    toClose = transmitter.connection != null &&   transmitter.connection.noNewExchanges
    ? transmitter.releaseConnectionNoEvents()
    : null;

    if (transmitter.connection != null) {
      //这里判断有点特别
      //发射机连接不为空 能用 就赋值给result对象
      result = transmitter.connection;
      releasedConnection = null;
    }
    //当然result为空就要从连接池取
    if (result == null) {
      //里面就是循环连接池，循环取，当然 也有可能取不到
      //取不到下面会new的，第一次肯定取不到
      if(connectionPool.transmitterAcquirePooledConnection(address,  transmitter, null, false)) {
        foundPooledConnection = true;
        result = transmitter.connection;
        } else if (nextRouteToTry != null) {
          selectedRoute = nextRouteToTry;
          nextRouteToTry = null;
          } else if (retryCurrentRoute()) {
            selectedRoute = transmitter.connection.route();
          }
        }
      }
      closeQuietly(toClose);

      if (releasedConnection != null) {
        eventListener.connectionReleased(call, releasedConnection);
      }
      if (foundPooledConnection) {
        eventListener.connectionAcquired(call, result);
      }
      if (result != null) {
        //到这里result不为空  则直接返回发射机里的 连接
        return result;
      }

      // If we need a route selection, make one. This is a blocking operation.
      boolean newRouteSelection = false;
      if (selectedRoute == null && (routeSelection == null ||   !routeSelection.hasNext())) {
        newRouteSelection = true;
        routeSelection = routeSelector.next();
      }

      List<Route> routes = null;
      synchronized (connectionPool) {
        if (transmitter.isCanceled()) throw new IOException("Canceled");

        if (newRouteSelection) {
          //获取路由表，再次尝试从连接池里取连接
          routes = routeSelection.getAll();
          if (connectionPool.transmitterAcquirePooledConnection(
            address, transmitter, routes, false)) {
              foundPooledConnection = true;
              //取到了就赋值给result
              result = transmitter.connection;
            }
          }

          if (!foundPooledConnection) {
            if (selectedRoute == null) {
              selectedRoute = routeSelection.next();
            }

            //各种都取不到 new了
            result = new RealConnection(connectionPool, selectedRoute);
            connectingConnection = result;
          }
        }

        //这里是回调 ，获取连接后调用的
        if (foundPooledConnection) {
          eventListener.connectionAcquired(call, result);
          return result;
        }

        //到这里肯定是新连接了，开始握手
        result.connect(connectTimeout, readTimeout, writeTimeout,   pingIntervalMillis,
          connectionRetryEnabled, call, eventListener);
          connectionPool.routeDatabase.connected(result.route());

        Socket socket = null;
        synchronized (connectionPool) {
          connectingConnection = null;
          //这里又尝试去取连接
          if(connectionPool.transmitterAcquirePooledConnection(address,  transmitter, routes, true)) {
              result.noNewExchanges = true;
              socket = result.socket();
              result = transmitter.connection;

              // It's possible for us to obtain a coalesced connection that is  immediately unhealthy. In
              // that case we will retry the route we just successfully connected   with.
              nextRouteToTry = selectedRoute;
              } else {
                connectionPool.put(result);
                transmitter.acquireConnectionNoEvents(result);
              }
            }
            closeQuietly(socket);

            eventListener.connectionAcquired(call, result);
            return result;
          }
    //到这里一个连接就找到了
    //返回上面 ，根据这个连接去判断他是否健康，不健康就再取
}

1、从transmitter中取，取到就返回
2、如果取不到从ConnectionPool中取，取到就返回
3、遍历路由地址、再从ConnectionPool中取
4、创建新的Connection
5、用新的Connection进行握手
到这里 从find()->findHealthyConnection()->findConnection()很清晰
这里我有个不明白的地方，如果大佬看到了可以为我解释：可能这里偏向网络了，不太明白这里的路由表Route有什么作用。
再来看一下 握手

result.connect(...) 握手

public void connect(int connectTimeout, int readTimeout, int writeTimeout,int pingIntervalMillis, boolean connectionRetryEnabled, Call call,EventListener eventListener) {
    if (protocol != null) throw new IllegalStateException("already connected");

    //去掉一些赋值和一些判断，如果有问题会抛出路由异常
    //判断客户端是否启用明文通信等等

    while (true) {
      try {
        if (route.requiresTunnel()) {
          //如果有通道，去进行连接通道 里面还是会连接socket
          connectTunnel(connectTimeout, readTimeout, writeTimeout, call, eventListener);
          if (rawSocket == null) {
            //成功就跳出
            break;
          }
        } else {
          //关键 连接socket
          connectSocket(connectTimeout, readTimeout, call, eventListener);
        }
        //定制协议
        //这里面赋值一下协议，这时候socket已经建立了
        //已经知道服务器用的什么协议了
        establishProtocol(connectionSpecSelector, pingIntervalMillis, call, eventListener);
        //listener 回调 告诉我们 连接完成
        //这里在Okhttp创建的时候 做一些日志操作
        eventListener.connectEnd(call, route.socketAddress(), route.proxy(), protocol);
        break;
      } catch (IOException e) {
        //一些关闭流的操作
     }

    if (route.requiresTunnel() && rawSocket == null) {
      ProtocolException exception = new ProtocolException("Too many tunnel connections attempted: "
          + MAX_TUNNEL_ATTEMPTS);
      throw new RouteException(exception);
    }

    if (http2Connection != null) {
      synchronized (connectionPool) {
        allocationLimit = http2Connection.maxConcurrentStreams();
      }
    }
}

//socket连接
connectSocket(connectTimeout, readTimeout, call, eventListener);
private void connectSocket(int connectTimeout, int readTimeout, Call call,
    EventListener eventListener) throws IOException {
  Proxy proxy = route.proxy();
  Address address = route.address();

  rawSocket = proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP
      ? address.socketFactory().createSocket()
      : new Socket(proxy);
  //连接开始
  eventListener.connectStart(call, route.socketAddress(), proxy);
  rawSocket.setSoTimeout(readTimeout);
  try {
    //连接操作
    //get判断是android平台还是java平台,再里面反射了一些SSL的底层实现类
    //connectSocket里面就是socket连接了
    Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);
  } catch (ConnectException e) {
    ConnectException ce = new ConnectException("Failed to connect to " + route.socketAddress());
    ce.initCause(e);
    throw ce;
}

ConnectInterceptor 连接拦截器,这里很长，做的事情也很明确
1、从连接池取连接
2、如果是新的连接，socket建立连接
其实这里的握手操作意思是建立Socket操作，Socket是一个套接字，是一个通信连接的对象，socket属于传输层，正真建立三次握手的是在这一层，不是在我们写的引用层。

5、CallServerInterceptor 呼叫服务器拦截器

最后一层，请求网络

public final class CallServerInterceptor implements Interceptor {

  @Override public Response intercept(Chain chain) throws IOException {
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Exchange exchange = realChain.exchange();
    Request request = realChain.request();

    long sentRequestMillis = System.currentTimeMillis();
    //向socket头写入信息
    exchange.writeRequestHeaders(request);

    boolean responseHeadersStarted = false;
    Response.Builder responseBuilder = null;
    //这里判断是否有Body
    if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
      //当socket连接服务器后，就已经有状态码了
      //100 该状态码 说明服务器已经接收到了 请求的初始部分
      if ("100-continue".equalsIgnoreCase(request.header("Expect"))) {
        exchange.flushRequest();
        responseHeadersStarted = true;
        exchange.responseHeadersStart();
        responseBuilder = exchange.readResponseHeaders(true);
      }

      if (responseBuilder == null) {
        //这里判断全双工  默认false
        if (request.body().isDuplex()) {
          // Prepare a duplex body so that the application can send a request body later.
          exchange.flushRequest();
          BufferedSink bufferedRequestBody = Okio.buffer(
              exchange.createRequestBody(request, true));
          request.body().writeTo(bufferedRequestBody);
        } else {
          // Write the request body if the "Expect: 100-continue" expectation was met.
          BufferedSink bufferedRequestBody = Okio.buffer(
              exchange.createRequestBody(request, false));
          request.body().writeTo(bufferedRequestBody);
          //
          bufferedRequestBody.close();
        }
      } else {
        exchange.noRequestBody();
        if (!exchange.connection().isMultiplexed()) {
          // If the "Expect: 100-continue" expectation wasn't met, prevent the HTTP/1 connection
          // from being reused. Otherwise we're still obligated to transmit the request body to
          // leave the connection in a consistent state.
          exchange.noNewExchangesOnConnection();
        }
      }
    } else {
      exchange.noRequestBody();
    }

    if (request.body() == null || !request.body().isDuplex()) {
      //完成网络的写入
      exchange.finishRequest();
    }

    if (!responseHeadersStarted) {
      //回调listener
      exchange.responseHeadersStart();
    }

    if (responseBuilder == null) {
      //读取Response  在这个里面正真的 调用他自己的okio 读取数据
      responseBuilder = exchange.readResponseHeaders(false);
    }
    //数据已经回来了到这里 后面就是一些小判断了
    Response response = responseBuilder
        .request(request)
        .handshake(exchange.connection().handshake())
        .sentRequestAtMillis(sentRequestMillis)
        .receivedResponseAtMillis(System.currentTimeMillis())
        .build();

    int code = response.code();
    if (code == 100) {
      // server sent a 100-continue even though we did not request one.
      // try again to read the actual response
      response = exchange.readResponseHeaders(false)
          .request(request)
          .handshake(exchange.connection().handshake())
          .sentRequestAtMillis(sentRequestMillis)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build();

      code = response.code();
    }

    exchange.responseHeadersEnd(response);

    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(exchange.openResponseBody(response))
          .build();
    }

    if ("close".equalsIgnoreCase(response.request().header("Connection"))
        || "close".equalsIgnoreCase(response.header("Connection"))) {
      exchange.noNewExchangesOnConnection();
    }

    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已经回来，数据也读取完毕。最后返回 response
这里5个拦截器已经全部走完
回顾一下5个拦截器
1、RetryAndFollowUpInterceptor 重定向拦截器
2、BridgeInterceptor 桥拦截器
3、CacheInterceptor 缓存拦截器
4、ConnectInterceptor 连接拦截器
5、CallServerInterceptor 呼叫服务拦截器
这5个拦截器依次从上往下执行，最后再返回
以上记录的是 同步请求方法

call.enqueue(new Callback(){..} ) 异步请求

@Override public void enqueue(Callback responseCallback) {
  synchronized (this) {
    if (executed) throw new IllegalStateException("Already Executed");
    executed = true;
  }
  transmitter.callStart();
  //创建了一个AsynCall对象
  client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
//调度器的dispatcher方法
void enqueue(AsyncCall call) {
  synchronized (this) {
    //锁住对象放入 readyAsyncCalls 队列中
    readyAsyncCalls.add(call);

    if (!call.get().forWebSocket) {
      AsyncCall existingCall = findExistingCallWithHost(call.host());
      if (existingCall != null) call.reuseCallsPerHostFrom(existingCall);
    }
  }
  //执行
  promoteAndExecute();
}

//执行
private boolean promoteAndExecute() {

  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 (asyncCall.callsPerHost().get() >= maxRequestsPerHost) continue; // Host max capacity.

      i.remove();
      asyncCall.callsPerHost().incrementAndGet();
      //锁住对象时的 临时队列
      executableCalls.add(asyncCall);
      //锁住对象，把准备好的AsyncCall 放到runningAsyncCalls队列里
      //runningAsyncCalls是正在执行的队列
      runningAsyncCalls.add(asyncCall);
    }
    isRunning = runningCallsCount() > 0;
  }

  for (int i = 0, size = executableCalls.size(); i < size; i++) {
    AsyncCall asyncCall = executableCalls.get(i);
    //循环这个执行临时队列的
    //根据安卓的机制还是需要在子线程里请求网络
    //executorService()是个线程池
    asyncCall.executeOn(executorService());
  }

  return isRunning;
}
//看一下AsyncCall结构 是个内部类
final class RealCall implements Call {
  final class AsyncCall extends NamedRunnable {
  }
}
//在看一下NamedRunnable,继承了Runnable，他的run方法里执行了execute()
public abstract class NamedRunnable implements Runnable {
  protected final String name;

  public NamedRunnable(String format, Object... args) {
    this.name = Util.format(format, args);
  }

  @Override public final void run() {
    String oldName = Thread.currentThread().getName();
    Thread.currentThread().setName(name);
    try {
      execute();
    } finally {
      Thread.currentThread().setName(oldName);
    }
  }

  protected abstract void execute();
}
//既然执行了execute()方法 打开asyncCall.executeOn(executorService());

void executeOn(ExecutorService executorService) {

      boolean success = false;
      try {
        //executorService线程池对象 执行this
        //这个this就是AsyncCall类
        //也就是线程池执行 run方法，上面的run方法又执行了execute()

        executorService.execute(this);
        success = true;
      } catch (RejectedExecutionException e) {

      } finally {

      }
}
//所以只要看  AsyncCall 完成的 NamedRunnable的 execute()方法
@Override protected void execute() {
  boolean signalledCallback = false;
  transmitter.timeoutEnter();
  try {
    Response response = getResponseWithInterceptorChain();
    signalledCallback = true;
    responseCallback.onResponse(RealCall.this, response);
  } catch (IOException e) {

  } finally {

  }
}

最后又执行了 getResponseWithInterceptorChain() 方法，执行5个拦截器，返回
这里代码很长，关键内容就在5个拦截器
OkHttp还有一个比较关键的内容就是连接池，暂时不写了。
贴个图加深印象，看源码不太清晰的时候，画个思维导图或者画一个重要类的 类图基本上代码就很清晰了

OkHttp.png

学艺不精，如果内容有错误请及时联系我，我及时改正