OKHttp原码分析(六)之RealConnection

一，概述

okhttp是底层实现框架，与httpURLconnection是同一级别的。OKHttp底层建立网络连接的关键就是RealConnection类。RealConnection类底层封装socket，是真正的创建连接者。分析这个类之后就明白了OKHttp与httpURLconnection的本质不同点。

RealConnection是底层类，都是间接的被其他类调用，所以到目前为止还未发现使用这个类的地方。不要感觉到源码分析断层了，因为这个类太重要了，所以不得不拿出来单独分析。先记住这个类，等下一篇blog分析httpStream时就会将RealConnection与其他部分连接起来。

二，RealConnection对象的创建。

RealConnection 对象在StreamAllocation 类中得到。

有人说我是怎么知道RealConnection对象是在StreamAllocation 类中得到，因为我已经把源码看过一遍了，所以找到了这个地方。看这篇blog的小伙伴只需先记着，下一篇blog就会有说明。

得到RealConnection 对象的代码是在newStream方法中，核心代码是：

RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,          writeTimeout, connectionRetryEnabled, doExtensiveHealthChecks);

findHealthyConnection方法又调用了findConnection方法。findConnection方法的源码是：

private RealConnection findConnection(int connectTimeout, int readTimeout, int writeTimeout, boolean connectionRetryEnabled) throws IOException {    Route selectedRoute;    synchronized (connectionPool) {    ;//创建RealConnection对象。    RealConnection newConnection = new RealConnection(selectedRoute);    acquire(newConnection);    ;//连接网络    newConnection.connect(connectTimeout, readTimeout, writeTimeout, address.connectionSpecs(),        connectionRetryEnabled);    routeDatabase().connected(newConnection.route());    return newConnection;  }

这段代码主要做了两件事情，一是创建RealConnection 对象，二是建立网络连接。

下面看建立网络连接的代码。

三，建立网络连接(重点)

建立网络连接使用的代码是RealConnection 类的connect方法。
connect方法又调用了buildConnection方法。
buildConnection方法的源码是：

private void buildConnection(int connectTimeout, int readTimeout, int writeTimeout,      ConnectionSpecSelector connectionSpecSelector) throws IOException {    connectSocket(connectTimeout, readTimeout);//连接socket    establishProtocol(readTimeout, writeTimeout, connectionSpecSelector);//建立协议  }

首先看connectSocket方法：

 private void connectSocket(int connectTimeout, int readTimeout) throws IOException {    Proxy proxy = route.proxy();    Address address = route.address();    ;//得到socket对象    rawSocket = proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP        ? address.socketFactory().createSocket()        : new Socket(proxy);    rawSocket.setSoTimeout(readTimeout);    try {    ;//连接socket      Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);    } catch (ConnectException e) {      throw new ConnectException("Failed to connect to " + route.socketAddress());    }    source = Okio.buffer(Okio.source(rawSocket));//从socket中获取source 对象。    sink = Okio.buffer(Okio.sink(rawSocket));//从socket中获取sink 对象。  }

这个方法里做了三件事情：
1，创建socket对象。
2，连接socket。
3，使用okio包从socket中得到source 对象和sink 对象。

下面看下Okio.source(rawSocket)的原码：

  public static Source source(Socket socket) throws IOException {    if (socket == null) throw new IllegalArgumentException("socket == null");    AsyncTimeout timeout = timeout(socket);    Source source = source(socket.getInputStream(), timeout);//从socket中得到输入流对象。    return timeout.source(source);  }

看到这儿大家会有种熟悉的感觉，这不就是我们熟悉的socket编码吗？对，这就是面向socket编程。
所以OKHttp本质是封装的socket。

四，建立协议

建立协议的方法是establishProtocol。方法原码如下：

private void establishProtocol(int readTimeout, int writeTimeout,      ConnectionSpecSelector connectionSpecSelector) throws IOException {    if (route.address().sslSocketFactory() != null) {      connectTls(readTimeout, writeTimeout, connectionSpecSelector);    } else {      protocol = Protocol.HTTP_1_1;      socket = rawSocket;    }    if (protocol == Protocol.SPDY_3 || protocol == Protocol.HTTP_2) {      socket.setSoTimeout(0); // Framed connection timeouts are set per-stream.      FramedConnection framedConnection = new FramedConnection.Builder(true)          .socket(socket, route.address().url().host(), source, sink)          .protocol(protocol)          .listener(this)          .build();      framedConnection.start();      // Only assign the framed connection once the preface has been sent successfully.      this.allocationLimit = framedConnection.maxConcurrentStreams();      this.framedConnection = framedConnection;    } else {      this.allocationLimit = 1;    }  }

从代码中可以看到，使用哪一种协议主要看route.address().sslSocketFactory() != null的返回值是true还是false。

RealConnection 的route对象来自于streamAllocation对象，streamAllocation对象在RetryAndFollowUpInterceptor类的intercept方法中被创建。创建streamAllocation对象的核心代码是：

streamAllocation = new StreamAllocation( client.connectionPool(), createAddress(request.url()));

下面看createAddress方法的源码：

  private Address createAddress(HttpUrl url) {    SSLSocketFactory sslSocketFactory = null;    HostnameVerifier hostnameVerifier = null;    CertificatePinner certificatePinner = null;    if (url.isHttps()) {      sslSocketFactory = client.sslSocketFactory();      hostnameVerifier = client.hostnameVerifier();      certificatePinner = client.certificatePinner();    }    return new Address(url.host(), url.port(), client.dns(), client.socketFactory(),        sslSocketFactory, hostnameVerifier, certificatePinner, client.proxyAuthenticator(),        client.proxy(), client.protocols(), client.connectionSpecs(), client.proxySelector());

这儿出现了SSLSocketFactory 对象，如果url是https则sslSocketFactory有值。如果url是http则sslSocketFactory等于null.所以如果url是https则使用http2.0或spdy协议。如果url是http则使用http1.1协议。

五，SSLSocket的使用

当使用https时，route.address().sslSocketFactory() != null返回值是true，则会调用connectTls方法。
connectTls方法源码是：

 private void connectTls(int readTimeout, int writeTimeout,      ConnectionSpecSelector connectionSpecSelector) throws IOException {    Address address = route.address();    SSLSocketFactory sslSocketFactory = address.sslSocketFactory();    boolean success = false;    SSLSocket sslSocket = null;    try {      // 创建SSLSocket对象。      sslSocket = (SSLSocket) sslSocketFactory.createSocket(          rawSocket, address.url().host(), address.url().port(), true /* autoClose */);      // Configure the socket's ciphers, TLS versions, and extensions.      ConnectionSpec connectionSpec = connectionSpecSelector.configureSecureSocket(sslSocket);      if (connectionSpec.supportsTlsExtensions()) {        Platform.get().configureTlsExtensions(            sslSocket, address.url().host(), address.protocols());      }      // Force handshake. This can throw!      sslSocket.startHandshake();      Handshake unverifiedHandshake = Handshake.get(sslSocket.getSession());      // Verify that the socket's certificates are acceptable for the target host.      if (!address.hostnameVerifier().verify(address.url().host(), sslSocket.getSession())) {        X509Certificate cert = (X509Certificate) unverifiedHandshake.peerCertificates().get(0);        throw new SSLPeerUnverifiedException("Hostname " + address.url().host() + " not verified:"            + "\n    certificate: " + CertificatePinner.pin(cert)            + "\n    DN: " + cert.getSubjectDN().getName()            + "\n    subjectAltNames: " + OkHostnameVerifier.allSubjectAltNames(cert));      }      // Check that the certificate pinner is satisfied by the certificates presented.      address.certificatePinner().check(address.url().host(),          unverifiedHandshake.peerCertificates());      // Success! Save the handshake and the ALPN protocol.      String maybeProtocol = connectionSpec.supportsTlsExtensions()          ? Platform.get().getSelectedProtocol(sslSocket)          : null;      socket = sslSocket;//给socket字段重新赋值。      source = Okio.buffer(Okio.source(socket));      sink = Okio.buffer(Okio.sink(socket));      handshake = unverifiedHandshake;      protocol = maybeProtocol != null          ? Protocol.get(maybeProtocol)          : Protocol.HTTP_1_1;      success = true;    } catch (AssertionError e) {      if (Util.isAndroidGetsocknameError(e)) throw new IOException(e);      throw e;    } finally {      if (sslSocket != null) {        Platform.get().afterHandshake(sslSocket);      }      if (!success) {        closeQuietly(sslSocket);      }    }  }

ssl的作用是对网络请求进行加密，让请求更安全。