okhttp之Connection

public interface Connection {
  Route route();//路由
  Socket socket();//套接字
  @Nullable Handshake handshake();//https协议的TLS握手， 其他协议返回null.
  Protocol protocol();//连接的协议
}

/**
 * 解决Android 7.0 的一个报错
 * https://github.com/square/okhttp/issues/3245
 */
private static final String NPE_THROW_WITH_NULL = "throw with null exception";
/**
 * 隧道连接 connectTunnel(...) 的最大尝试次数 
 */
private static final int MAX_TUNNEL_ATTEMPTS = 21;

private final ConnectionPool connectionPool; //连接池
private final Route route; //路由

private Socket rawSocket;//低级的 TCP socket
private Socket socket;// socket
private Handshake handshake;//HTTPS的TLS握手记录
private Protocol protocol;//连接协议
private Http2Connection http2Connection;// http2的连接
private BufferedSource source;//类似inputstream的输入流
private BufferedSink sink;//类似outputstream的输出流

/**
 * 为true  则无法在此连接上创建新的流
 */
public boolean noNewStreams;
public int successCount; //连接成功次数
public int allocationLimit = 1; //此连接可以承载的并发流的最大数量。
/**
 * 此连接承载的当前流
 */
public final List<Reference<StreamAllocation>> allocations = new ArrayList<>();
/**
 * 达到零时的纳秒时间戳
 */
public long idleAtNanos = Long.MAX_VALUE;

public RealConnection(ConnectionPool connectionPool, Route route) {
    this.connectionPool = connectionPool;
    this.route = route;
}

public void connect(...) {
    //一个RealConnection只能掉一次此方法
    if (protocol != null) throw new IllegalStateException("already connected");
    ...
    while (true) {
        try {
            if (route.requiresTunnel()) {
                //https 协议 的准备工作
                connectTunnel(connectTimeout, readTimeout, writeTimeout, call, eventListener);
               ...
            } else {
                //其他通过socket 的准备工作
                connectSocket(connectTimeout, readTimeout, call, eventListener);
            }
            //确定协议开始连接
            establishProtocol(connectionSpecSelector, pingIntervalMillis, call, eventListener);
            eventListener.connectEnd(call, route.socketAddress(), route.proxy(), protocol);
            break;
        } catch (IOException e) {
            //处理异常之后的释放以及回调操作
            //置空 protocol 等变量
        }
    }
    ...
}
private void establishProtocol(...) throws IOException {
    if (route.address().sslSocketFactory() == null) {
        //非https 连接
        if (route.address().protocols().contains(Protocol.H2_PRIOR_KNOWLEDGE)) {
            ...
            //通过Http2Connection.Builder(true).build().start() 建立http2连接
            startHttp2(pingIntervalMillis);
            return;
        }
        socket = rawSocket;
        protocol = Protocol.HTTP_1_1;
        return;
    }
    //https 建立安全连接
    eventListener.secureConnectStart(call);
    connectTls(connectionSpecSelector);
    eventListener.secureConnectEnd(call, handshake);

    if (protocol == Protocol.HTTP_2) {
        //通过Http2Connection.Builder(true).build().start() 建立http2连接
        startHttp2(pingIntervalMillis);
    }
}

public boolean isEligible(Address address, @Nullable Route route) {
    // 如果此连接不接受新的流 则不合格
    if (allocations.size() >= allocationLimit || noNewStreams) return false;
    // 如果地址的非主机字段不重叠，则不合格
    if (!Internal.instance.equalsNonHost(this.route.address(), address)) return false;
    // 如果主机完全匹配，此连接可以携带地址。
    if (address.url().host().equals(this.route().address().url().host())) {
        return true; // This connection is a perfect match.
    }
    // 1.必须是HTTP/2连接.
    if (http2Connection == null) return false;
    // 2.路由必须共享一个IP地址
    if (route == null) return false;
    if (route.proxy().type() != Proxy.Type.DIRECT) return false;
    if (this.route.proxy().type() != Proxy.Type.DIRECT) return false;
    if (!this.route.socketAddress().equals(route.socketAddress())) return false;
    // 3.此连接的服务器证书必须包含新主机。
    if (route.address().hostnameVerifier() != OkHostnameVerifier.INSTANCE) return false;
    if (!supportsUrl(address.url())) return false;
    // 4.证书固定必须与主机匹配。
    try {
        address.certificatePinner().check(address.url().host(), handshake().peerCertificates());
    } catch (SSLPeerUnverifiedException e) {
        return false;
    }
    return true;
}

public boolean supportsUrl(HttpUrl url) {
    if (url.port() != route.address().url().port()) {
        return false;//端口不一致
    }
    if (!url.host().equals(route.address().url().host())) {
        // 主机不匹配  但是证书匹配也可以
        return handshake != null && OkHostnameVerifier.INSTANCE.verify(
                url.host(), (X509Certificate) handshake.peerCertificates().get(0));
    }
    return true;
}

public HttpCodec newCodec(OkHttpClient client, Interceptor.Chain chain,
                          StreamAllocation streamAllocation) throws SocketException {
    if (http2Connection != null) {
        return new Http2Codec(client, chain, streamAllocation, http2Connection);
    } else {
        socket.setSoTimeout(chain.readTimeoutMillis());
        source.timeout().timeout(chain.readTimeoutMillis(), MILLISECONDS);
        sink.timeout().timeout(chain.writeTimeoutMillis(), MILLISECONDS);
        return new Http1Codec(client, streamAllocation, source, sink);
    }
}

public void cancel() {
    closeQuietly(rawSocket);
}
public static void closeQuietly(Socket socket) {
    if (socket != null) {
        try {
            socket.close();
        ...
        } catch (Exception ignored) {
        }
    }
}

public boolean isHealthy(boolean doExtensiveChecks) {
    if (socket.isClosed() || socket.isInputShutdown() || socket.isOutputShutdown()) {
        return false;
    }
    if (http2Connection != null) {
        return !http2Connection.isShutdown();
    }
    if (doExtensiveChecks) {
        try {
            int readTimeout = socket.getSoTimeout();
            try {
                socket.setSoTimeout(1);
                if (source.exhausted()) {
                    return false;
                }
                return true;
            } finally {
                socket.setSoTimeout(readTimeout);
            }
        } catch (SocketTimeoutException ignored) {
        } catch (IOException e) {
            return false;
        }
    }
    return true;
}