OkHttp3中的代理与路由
tttmusic
8年前
<p>路由是什么呢？路由即是网络数据包在网络中的传输路径，或者说数据包在传输过程中所经过的网络节点，比如路由器，代理服务器之类的。</p> <p>那像OkHttp3这样的网络库对于数据包的路由需要做些什么事呢？用户可以为终端设置代理服务器，HTTP/HTTPS代理或SOCK代理。OkHttp3中的路由相关逻辑，需要从系统中获取用户设置的代理服务器的地址，将HTTP请求转换为代理协议的数据包，发给代理服务器，然后等待代理服务器帮助完成了网络请求之后，从代理服务器读取响应数据返回给用户。只有这样，用户设置的代理才能生效。如果网络库无视用户设置的代理服务器，直接进行DNS并做网络请求，则用户设置的代理服务器不生效。</p> <p>这里就来看一下OkHttp3中路由相关的处理。</p> <h2><strong>路由选择</strong></h2> <p>如同Internet上的其它设备一样，每个路由节点都有自己的IP地址，加上端口号，则可以确定唯一的路由服务。以域名描述的HTTP/HTTPS代理服务器地址，可能对应于多个实际的代理服务器主机，因而一个代理服务器可能包含有多条路由。而SOCK代理服务器，则有着唯一确定的IP地址和端口号。</p> <p>OkHttp3借助于RouteSelector来选择路由节点，并维护路由的信息。</p> <pre> <code class="language-java">public final class RouteSelector { private final Address address; private final RouteDatabase routeDatabase; /* The most recently attempted route. */ private Proxy lastProxy; private InetSocketAddress lastInetSocketAddress; /* State for negotiating the next proxy to use. */ private List<Proxy> proxies = Collections.emptyList(); private int nextProxyIndex; /* State for negotiating the next socket address to use. */ private List<InetSocketAddress> inetSocketAddresses = Collections.emptyList(); private int nextInetSocketAddressIndex; /* State for negotiating failed routes */ private final List<Route> postponedRoutes = new ArrayList<>(); public RouteSelector(Address address, RouteDatabase routeDatabase) { this.address = address; this.routeDatabase = routeDatabase; resetNextProxy(address.url(), address.proxy()); } /** * Returns true if there's another route to attempt. Every address has at least one route. */ public boolean hasNext() { return hasNextInetSocketAddress() || hasNextProxy() || hasNextPostponed(); } public Route next() throws IOException { // Compute the next route to attempt. if (!hasNextInetSocketAddress()) { if (!hasNextProxy()) { if (!hasNextPostponed()) { throw new NoSuchElementException(); } return nextPostponed(); } lastProxy = nextProxy(); } lastInetSocketAddress = nextInetSocketAddress(); Route route = new Route(address, lastProxy, lastInetSocketAddress); if (routeDatabase.shouldPostpone(route)) { postponedRoutes.add(route); // We will only recurse in order to skip previously failed routes. They will be tried last. return next(); } return route; } /** * Clients should invoke this method when they encounter a connectivity failure on a connection * returned by this route selector. */ public void connectFailed(Route failedRoute, IOException failure) { if (failedRoute.proxy().type() != Proxy.Type.DIRECT && address.proxySelector() != null) { // Tell the proxy selector when we fail to connect on a fresh connection. address.proxySelector().connectFailed( address.url().uri(), failedRoute.proxy().address(), failure); } routeDatabase.failed(failedRoute); } /** Prepares the proxy servers to try. */ private void resetNextProxy(HttpUrl url, Proxy proxy) { if (proxy != null) { // If the user specifies a proxy, try that and only that. proxies = Collections.singletonList(proxy); } else { // Try each of the ProxySelector choices until one connection succeeds. If none succeed // then we'll try a direct connection below. proxies = new ArrayList<>(); List<Proxy> selectedProxies = address.proxySelector().select(url.uri()); if (selectedProxies != null) proxies.addAll(selectedProxies); // Finally try a direct connection. We only try it once! proxies.removeAll(Collections.singleton(Proxy.NO_PROXY)); proxies.add(Proxy.NO_PROXY); } nextProxyIndex = 0; } /** Returns true if there's another proxy to try. */ private boolean hasNextProxy() { return nextProxyIndex < proxies.size(); } /** Returns the next proxy to try. May be PROXY.NO_PROXY but never null. */ private Proxy nextProxy() throws IOException { if (!hasNextProxy()) { throw new SocketException("No route to " + address.url().host() + "; exhausted proxy configurations: " + proxies); } Proxy result = proxies.get(nextProxyIndex++); resetNextInetSocketAddress(result); return result; } /** Prepares the socket addresses to attempt for the current proxy or host. */ private void resetNextInetSocketAddress(Proxy proxy) throws IOException { // Clear the addresses. Necessary if getAllByName() below throws! inetSocketAddresses = new ArrayList<>(); String socketHost; int socketPort; if (proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.SOCKS) { socketHost = address.url().host(); socketPort = address.url().port(); } else { SocketAddress proxyAddress = proxy.address(); if (!(proxyAddress instanceof InetSocketAddress)) { throw new IllegalArgumentException( "Proxy.address() is not an " + "InetSocketAddress: " + proxyAddress.getClass()); } InetSocketAddress proxySocketAddress = (InetSocketAddress) proxyAddress; socketHost = getHostString(proxySocketAddress); socketPort = proxySocketAddress.getPort(); } if (socketPort < 1 || socketPort > 65535) { throw new SocketException("No route to " + socketHost + ":" + socketPort + "; port is out of range"); } if (proxy.type() == Proxy.Type.SOCKS) { inetSocketAddresses.add(InetSocketAddress.createUnresolved(socketHost, socketPort)); } else { // Try each address for best behavior in mixed IPv4/IPv6 environments. List<InetAddress> addresses = address.dns().lookup(socketHost); for (int i = 0, size = addresses.size(); i < size; i++) { InetAddress inetAddress = addresses.get(i); inetSocketAddresses.add(new InetSocketAddress(inetAddress, socketPort)); } } nextInetSocketAddressIndex = 0; } /** * Obtain a "host" from an {@link InetSocketAddress}. This returns a string containing either an * actual host name or a numeric IP address. */ // Visible for testing static String getHostString(InetSocketAddress socketAddress) { InetAddress address = socketAddress.getAddress(); if (address == null) { // The InetSocketAddress was specified with a string (either a numeric IP or a host name). If // it is a name, all IPs for that name should be tried. If it is an IP address, only that IP // address should be tried. return socketAddress.getHostName(); } // The InetSocketAddress has a specific address: we should only try that address. Therefore we // return the address and ignore any host name that may be available. return address.getHostAddress(); } /** Returns true if there's another socket address to try. */ private boolean hasNextInetSocketAddress() { return nextInetSocketAddressIndex < inetSocketAddresses.size(); } /** Returns the next socket address to try. */ private InetSocketAddress nextInetSocketAddress() throws IOException { if (!hasNextInetSocketAddress()) { throw new SocketException("No route to " + address.url().host() + "; exhausted inet socket addresses: " + inetSocketAddresses); } return inetSocketAddresses.get(nextInetSocketAddressIndex++); } /** Returns true if there is another postponed route to try. */ private boolean hasNextPostponed() { return !postponedRoutes.isEmpty(); } /** Returns the next postponed route to try. */ private Route nextPostponed() { return postponedRoutes.remove(0); } }</code></pre> <p>RouteSelector 主要做了这样一些事情：</p> <ol> <li>在 RouteSelector 对象创建时，获取并保存用户设置的所有的代理。这里主要通过 ProxySelector ，根据uri来得到系统中的所有代理，并保存在Proxy列表proxies中。</li> <li>给调用者提供接口，来选择可用的路由。调用者通过next()可以获取 RouteSelector 中维护的下一个可用路由。调用者在连接失败时，可以再次调用这个接口来获取下一个路由。这个接口会逐个地返回每个代理的每个代理主机服务给调用者。在所有的代理的每个代理主机都被访问过了之后，还会返回曾经连接失败的路由。</li> <li>维护路由节点的信息。 RouteDatabase 用于维护连接失败的路由的信息，以避免浪费时间去连接一些不可用的路由。 RouteDatabase 中的路由信息主要由 RouteSelector 来维护。</li> </ol> <p>RouteDatabase 是一个简单的容器：</p> <pre> <code class="language-java">package okhttp3.internal.connection; import java.util.LinkedHashSet; import java.util.Set; import okhttp3.Route; /** * A blacklist of failed routes to avoid when creating a new connection to a target address. This is * used so that OkHttp can learn from its mistakes: if there was a failure attempting to connect to * a specific IP address or proxy server, that failure is remembered and alternate routes are * preferred. */ public final class RouteDatabase { private final Set<Route> failedRoutes = new LinkedHashSet<>(); /** Records a failure connecting to {@code failedRoute}. */ public synchronized void failed(Route failedRoute) { failedRoutes.add(failedRoute); } /** Records success connecting to {@code failedRoute}. */ public synchronized void connected(Route route) { failedRoutes.remove(route); } /** Returns true if {@code route} has failed recently and should be avoided. */ public synchronized boolean shouldPostpone(Route route) { return failedRoutes.contains(route); } }</code></pre> <p>OkHttp3主要用(Address, Proxy, InetSocketAddress)的三元组来描述路由信息：</p> <pre> <code class="language-java">package okhttp3; import java.net.InetSocketAddress; import java.net.Proxy; /** * The concrete route used by a connection to reach an abstract origin server. When creating a * connection the client has many options: * * <ul> * <li><strong>HTTP proxy:</strong> a proxy server may be explicitly configured for the client. * Otherwise the {@linkplain java.net.ProxySelector proxy selector} is used. It may return * multiple proxies to attempt. * <li><strong>IP address:</strong> whether connecting directly to an origin server or a proxy, * opening a socket requires an IP address. The DNS server may return multiple IP addresses * to attempt. * </ul> * * <p>Each route is a specific selection of these options. */ public final class Route { final Address address; final Proxy proxy; final InetSocketAddress inetSocketAddress; public Route(Address address, Proxy proxy, InetSocketAddress inetSocketAddress) { if (address == null) { throw new NullPointerException("address == null"); } if (proxy == null) { throw new NullPointerException("proxy == null"); } if (inetSocketAddress == null) { throw new NullPointerException("inetSocketAddress == null"); } this.address = address; this.proxy = proxy; this.inetSocketAddress = inetSocketAddress; } public Address address() { return address; } /** * Returns the {@link Proxy} of this route. * * <strong>Warning:</strong> This may disagree with {@link Address#proxy} when it is null. When * the address's proxy is null, the proxy selector is used. */ public Proxy proxy() { return proxy; } public InetSocketAddress socketAddress() { return inetSocketAddress; } /** * Returns true if this route tunnels HTTPS through an HTTP proxy. See <a * href="http://www.ietf.org/rfc/rfc2817.txt">RFC 2817, Section 5.2</a>. */ public boolean requiresTunnel() { return address.sslSocketFactory != null && proxy.type() == Proxy.Type.HTTP; } @Override public boolean equals(Object obj) { if (obj instanceof Route) { Route other = (Route) obj; return address.equals(other.address) && proxy.equals(other.proxy) && inetSocketAddress.equals(other.inetSocketAddress); } return false; } @Override public int hashCode() { int result = 17; result = 31 * result + address.hashCode(); result = 31 * result + proxy.hashCode(); result = 31 * result + inetSocketAddress.hashCode(); return result; } }</code></pre> <p>在StreamAllocation中建立连接时，会通过 RouteSelector 获取可用路由。</p> <p>在OkHttp3中， ProxySelector 对象主要由OkHttpClient维护。</p> <pre> <code class="language-java">public class OkHttpClient implements Cloneable, Call.Factory { ...... final ProxySelector proxySelector; private OkHttpClient(Builder builder) { this.dispatcher = builder.dispatcher; this.proxy = builder.proxy; this.protocols = builder.protocols; this.connectionSpecs = builder.connectionSpecs; this.interceptors = Util.immutableList(builder.interceptors); this.networkInterceptors = Util.immutableList(builder.networkInterceptors); this.proxySelector = builder.proxySelector; ...... public ProxySelector proxySelector() { return proxySelector; } ...... public Builder() { dispatcher = new Dispatcher(); protocols = DEFAULT_PROTOCOLS; connectionSpecs = DEFAULT_CONNECTION_SPECS; proxySelector = ProxySelector.getDefault(); ...... Builder(OkHttpClient okHttpClient) { this.dispatcher = okHttpClient.dispatcher; this.proxy = okHttpClient.proxy; this.protocols = okHttpClient.protocols; this.connectionSpecs = okHttpClient.connectionSpecs; this.interceptors.addAll(okHttpClient.interceptors); this.networkInterceptors.addAll(okHttpClient.networkInterceptors); this.proxySelector = okHttpClient.proxySelector;</code></pre> <p>在创建OkHttpClient时，可以通过为OkHttpClient.Builder设置 ProxySelector 来定制 ProxySelector 。若没有指定，则所有的为默认 ProxySelector 。OpenJDK 1.8版默认的 ProxySelector 为 sun.net.spi.DefaultProxySelector ：</p> <pre> <code class="language-java">public abstract class ProxySelector { /** * The system wide proxy selector that selects the proxy server to * use, if any, when connecting to a remote object referenced by * an URL. * * @see #setDefault(ProxySelector) */ private static ProxySelector theProxySelector; static { try { Class<?> c = Class.forName("sun.net.spi.DefaultProxySelector"); if (c != null && ProxySelector.class.isAssignableFrom(c)) { theProxySelector = (ProxySelector) c.newInstance(); } } catch (Exception e) { theProxySelector = null; } } /** * Gets the system-wide proxy selector. * * @throws SecurityException * If a security manager has been installed and it denies * {@link NetPermission}{@code ("getProxySelector")} * @see #setDefault(ProxySelector) * @return the system-wide {@code ProxySelector} * @since 1.5 */ public static ProxySelector getDefault() { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(SecurityConstants.GET_PROXYSELECTOR_PERMISSION); } return theProxySelector; }</code></pre> <p>在Android平台上，默认 ProxySelector 所用的则是 <a href="/misc/goto?guid=4959718204922714467" rel="nofollow,noindex">另外的实现</a> ：</p> <pre> <code class="language-java">public abstract class ProxySelector { private static ProxySelector defaultSelector = new ProxySelectorImpl(); /** * Returns the default proxy selector, or null if none exists. */ public static ProxySelector getDefault() { return defaultSelector; } /** * Sets the default proxy selector. If {@code selector} is null, the current * proxy selector will be removed. */ public static void setDefault(ProxySelector selector) { defaultSelector = selector; }</code></pre> <p>Android平台下，默认的 ProxySelector ProxySelectorImpl，其 <a href="/misc/goto?guid=4959718205008181940" rel="nofollow,noindex">实现(不同版本的Android，实现不同，这里是android-6.0.1_r61的实现)</a> 如下：</p> <pre> <code class="language-java">package java.net; import java.io.IOException; import java.util.Collections; import java.util.List; final class ProxySelectorImpl extends ProxySelector { @Override public void connectFailed(URI uri, SocketAddress sa, IOException ioe) { if (uri == null || sa == null || ioe == null) { throw new IllegalArgumentException(); } } @Override public List<Proxy> select(URI uri) { return Collections.singletonList(selectOneProxy(uri)); } private Proxy selectOneProxy(URI uri) { if (uri == null) { throw new IllegalArgumentException("uri == null"); } String scheme = uri.getScheme(); if (scheme == null) { throw new IllegalArgumentException("scheme == null"); } int port = -1; Proxy proxy = null; String nonProxyHostsKey = null; boolean httpProxyOkay = true; if ("http".equalsIgnoreCase(scheme)) { port = 80; nonProxyHostsKey = "http.nonProxyHosts"; proxy = lookupProxy("http.proxyHost", "http.proxyPort", Proxy.Type.HTTP, port); } else if ("https".equalsIgnoreCase(scheme)) { port = 443; nonProxyHostsKey = "https.nonProxyHosts"; // RI doesn't support this proxy = lookupProxy("https.proxyHost", "https.proxyPort", Proxy.Type.HTTP, port); } else if ("ftp".equalsIgnoreCase(scheme)) { port = 80; // not 21 as you might guess nonProxyHostsKey = "ftp.nonProxyHosts"; proxy = lookupProxy("ftp.proxyHost", "ftp.proxyPort", Proxy.Type.HTTP, port); } else if ("socket".equalsIgnoreCase(scheme)) { httpProxyOkay = false; } else { return Proxy.NO_PROXY; } if (nonProxyHostsKey != null && isNonProxyHost(uri.getHost(), System.getProperty(nonProxyHostsKey))) { return Proxy.NO_PROXY; } if (proxy != null) { return proxy; } if (httpProxyOkay) { proxy = lookupProxy("proxyHost", "proxyPort", Proxy.Type.HTTP, port); if (proxy != null) { return proxy; } } proxy = lookupProxy("socksProxyHost", "socksProxyPort", Proxy.Type.SOCKS, 1080); if (proxy != null) { return proxy; } return Proxy.NO_PROXY; } /** * Returns the proxy identified by the {@code hostKey} system property, or * null. */ private Proxy lookupProxy(String hostKey, String portKey, Proxy.Type type, int defaultPort) { String host = System.getProperty(hostKey); if (host == null || host.isEmpty()) { return null; } int port = getSystemPropertyInt(portKey, defaultPort); return new Proxy(type, InetSocketAddress.createUnresolved(host, port)); } private int getSystemPropertyInt(String key, int defaultValue) { String string = System.getProperty(key); if (string != null) { try { return Integer.parseInt(string); } catch (NumberFormatException ignored) { } } return defaultValue; } /** * Returns true if the {@code nonProxyHosts} system property pattern exists * and matches {@code host}. */ private boolean isNonProxyHost(String host, String nonProxyHosts) { if (host == null || nonProxyHosts == null) { return false; } // construct pattern StringBuilder patternBuilder = new StringBuilder(); for (int i = 0; i < nonProxyHosts.length(); i++) { char c = nonProxyHosts.charAt(i); switch (c) { case '.': patternBuilder.append("\\."); break; case '*': patternBuilder.append(".*"); break; default: patternBuilder.append(c); } } // check whether the host is the nonProxyHosts. String pattern = patternBuilder.toString(); return host.matches(pattern); } }</code></pre> <p>可以看到，在Android平台上，主要是从System properties中获取的代理服务器的主机及其端口号，会过滤掉不能进行代理的主机的访问。</p> <p>回到OkHttp中，在RetryAndFollowUpInterceptor中，创建Address对象时，从OkHttpClient对象获取ProxySelector。Address对象会被用于创建StreamAllocation对象，StreamAllocation在建立连接时，从Address对象中获取ProxySelector以选择路由。</p> <pre> <code class="language-java">public final class RetryAndFollowUpInterceptor implements Interceptor { ...... 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()); }</code></pre> <h2><strong>代理协议</strong></h2> <p>OkHttp3发送给HTTP代理服务器的HTTP请求，与直接发送给HTTP服务器的HTTP请求有什么样的区别呢，还是说两者其实毫无差别呢？也就是HTTP代理的协议是什么样的呢？这里我们就通过对代码进行分析来仔细地看一下。</p> <p>如我们在 <a href="/misc/goto?guid=4959718205097160254" rel="nofollow,noindex">OkHttp3 HTTP请求执行流程分析</a> 中看到的，OkHttp3对HTTP请求是通过Interceptor链来处理的。</p> <p>RetryAndFollowUpInterceptor 创建 StreamAllocation 对象，处理http的重定向及出错重试。对后续Interceptor的执行的影响为修改Request并创建StreamAllocation对象。</p> <p>BridgeInterceptor 补全缺失的一些http header。对后续Interceptor的执行的影响主要为修改了Request。</p> <p>CacheInterceptor 处理http缓存。对后续Interceptor的执行的影响为，若缓存中有所需请求的响应，则后续Interceptor不再执行。</p> <p>ConnectInterceptor 借助于前面分配的 StreamAllocation 对象建立与服务器之间的连接，并选定交互所用的协议是HTTP 1.1还是HTTP 2。对后续Interceptor的执行的影响为，创建了HttpStream和connection。</p> <p>CallServerInterceptor 作为Interceptor链中的最后一个Interceptor，用于处理IO，与服务器进行数据交换。</p> <p>OkHttp3对代理的处理是在 ConnectInterceptor 和 CallServerInterceptor 中完成的。再来看 ConnectInterceptor 的定义：</p> <pre> <code class="language-java">package okhttp3.internal.connection; import java.io.IOException; import okhttp3.Interceptor; import okhttp3.OkHttpClient; import okhttp3.Request; import okhttp3.Response; import okhttp3.internal.http.HttpCodec; import okhttp3.internal.http.RealInterceptorChain; /** Opens a connection to the target server and proceeds to the next interceptor. */ public final class ConnectInterceptor implements Interceptor { public final OkHttpClient client; public ConnectInterceptor(OkHttpClient client) { this.client = client; } @Override public Response intercept(Chain chain) throws IOException { RealInterceptorChain realChain = (RealInterceptorChain) chain; Request request = realChain.request(); StreamAllocation streamAllocation = realChain.streamAllocation(); // We need the network to satisfy this request. Possibly for validating a conditional GET. boolean doExtensiveHealthChecks = !request.method().equals("GET"); HttpCodec httpCodec = streamAllocation.newStream(client, doExtensiveHealthChecks); RealConnection connection = streamAllocation.connection(); return realChain.proceed(request, streamAllocation, httpCodec, connection); } }</code></pre> <p>ConnectInterceptor 利用前面的Interceptor创建的StreamAllocation对象，创建stream HttpCodec，以及RealConnection connection。然后把这些对象传给链中后继的Interceptor，也就是 CallServerInterceptor 处理。</p> <p>为了厘清StreamAllocation的两个操作的详细执行过程，这里再回过头来看一下 StreamAllocation 对象的创建。StreamAllocation对象在 RetryAndFollowUpInterceptor 中创建：</p> <pre> <code class="language-java">@Override public Response intercept(Chain chain) throws IOException { Request request = chain.request(); streamAllocation = new StreamAllocation( client.connectionPool(), createAddress(request.url()), callStackTrace);</code></pre> <p>创建 StreamAllocation 对象时，传入的ConnectionPool来自于OkHttpClient，创建的Address主要用于描述HTTP服务的目标地址相关的信息。</p> <pre> <code class="language-java">public final class StreamAllocation { public final Address address; private Route route; private final ConnectionPool connectionPool; private final Object callStackTrace; // State guarded by connectionPool. private final RouteSelector routeSelector; private int refusedStreamCount; private RealConnection connection; private boolean released; private boolean canceled; private HttpCodec codec; public StreamAllocation(ConnectionPool connectionPool, Address address, Object callStackTrace) { this.connectionPool = connectionPool; this.address = address; this.routeSelector = new RouteSelector(address, routeDatabase()); this.callStackTrace = callStackTrace; }</code></pre> <p>创建 StreamAllocation 对象时，除了创建 RouteSelector 之外，并没有其它特别的地方。</p> <p>然后来看 ConnectInterceptor 中用来创建HttpCodec的newStream()方法：</p> <pre> <code class="language-java">public final class StreamAllocation { ...... public HttpCodec newStream(OkHttpClient client, boolean doExtensiveHealthChecks) { int connectTimeout = client.connectTimeoutMillis(); int readTimeout = client.readTimeoutMillis(); int writeTimeout = client.writeTimeoutMillis(); boolean connectionRetryEnabled = client.retryOnConnectionFailure(); try { RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout, writeTimeout, connectionRetryEnabled, doExtensiveHealthChecks); HttpCodec resultCodec; if (resultConnection.http2Connection != null) { resultCodec = new Http2Codec(client, this, resultConnection.http2Connection); } else { resultConnection.socket().setSoTimeout(readTimeout); resultConnection.source.timeout().timeout(readTimeout, MILLISECONDS); resultConnection.sink.timeout().timeout(writeTimeout, MILLISECONDS); resultCodec = new Http1Codec( client, this, resultConnection.source, resultConnection.sink); } synchronized (connectionPool) { codec = resultCodec; return resultCodec; } } catch (IOException e) { throw new RouteException(e); } }</code></pre> <p>这个方法的执行流程为：</p> <ol> <li>建立连接。<br> 通过调用findHealthyConnection()方法来建立连接，后面我们通过分析这个方法的实现来了解连接的具体含义。</li> <li>用前面创建的连接来创建HttpCodec。<br> 对于HTTP/1.1创建Http1Codec，对于HTTP/2则创建Http2Codec。HttpCodec用于处理与HTTP具体协议相关的部分。比如HTTP/1.1是基于文本的协议，而HTTP/2则是基于二进制格式的协议，HttpCodec用于将请求编码为对应协议要求的传输格式，并在得到响应时，对数据进行解码。</li> </ol> <p>然后来看 findHealthyConnection() 中创建连接的过程：</p> <pre> <code class="language-java">/** * Finds a connection and returns it if it is healthy. If it is unhealthy the process is repeated * until a healthy connection is found. */ private RealConnection findHealthyConnection(int connectTimeout, int readTimeout, int writeTimeout, boolean connectionRetryEnabled, boolean doExtensiveHealthChecks) throws IOException { while (true) { RealConnection candidate = findConnection(connectTimeout, readTimeout, writeTimeout, connectionRetryEnabled); // If this is a brand new connection, we can skip the extensive health checks. synchronized (connectionPool) { if (candidate.successCount == 0) { return candidate; } } // Do a (potentially slow) check to confirm that the pooled connection is still good. If it // isn't, take it out of the pool and start again. if (!candidate.isHealthy(doExtensiveHealthChecks)) { noNewStreams(); continue; } return candidate; } }</code></pre> <p>在这个方法中，是找到一个连接，然后判断其是否可用。如果可用则将找到的连接返回给调用者，否则寻找下一个连接。寻找连接可能是建立一个新的连接，也可能是复用连接池中的一个连接。</p> <p>接着来看寻找连接的过程 findConnection() ：</p> <pre> <code class="language-java">/** * Returns a connection to host a new stream. This prefers the existing connection if it exists, * then the pool, finally building a new connection. */ private RealConnection findConnection(int connectTimeout, int readTimeout, int writeTimeout, boolean connectionRetryEnabled) throws IOException { Route selectedRoute; synchronized (connectionPool) { if (released) throw new IllegalStateException("released"); if (codec != null) throw new IllegalStateException("codec != null"); if (canceled) throw new IOException("Canceled"); RealConnection allocatedConnection = this.connection; if (allocatedConnection != null && !allocatedConnection.noNewStreams) { return allocatedConnection; } // Attempt to get a connection from the pool. RealConnection pooledConnection = Internal.instance.get(connectionPool, address, this); if (pooledConnection != null) { this.connection = pooledConnection; return pooledConnection; } selectedRoute = route; } if (selectedRoute == null) { selectedRoute = routeSelector.next(); synchronized (connectionPool) { route = selectedRoute; refusedStreamCount = 0; } } RealConnection newConnection = new RealConnection(selectedRoute); synchronized (connectionPool) { acquire(newConnection); Internal.instance.put(connectionPool, newConnection); this.connection = newConnection; if (canceled) throw new IOException("Canceled"); } newConnection.connect(connectTimeout, readTimeout, writeTimeout, address.connectionSpecs(), connectionRetryEnabled); routeDatabase().connected(newConnection.route()); return newConnection; }</code></pre> <p>这个过程大体为：</p> <ol> <li>检查上次分配的连接是否可用，若可用则，则将上次分配的连接返回给调用者。</li> <li>上次分配的连接不存在，或不可用，则从连接池中查找一个连接，查找的依据就是Address，也就是连接的对端地址，以及路由等信息。Internal.instance指向OkHttpClient的一个内部类的对象，Internal.instance.get()实际会通过ConnectionPool的 get(Address address, StreamAllocation streamAllocation) 方法来尝试获取RealConnection。<br> 若能从连接池中找到所需要的连接，则将连接返回给调用者。</li> <li>从连接池中没有找到所需要的连接，则会首先选择路由。</li> <li>然后创建新的连接RealConnection对象。</li> <li>acquire新创建的连接RealConnection对象，并将它放进连接池。不太确定这个地方的synchronized是不是太长了。貌似只有Internal.instance.put(connectionPool, newConnection)涉及到了全局对象的访问，而其它操作并没有。</li> <li>调用newConnection.connect()建立连接。</li> </ol> <p>这里再来看一下在ConnectionPool的get()操作执行的过程：</p> <pre> <code class="language-java">private final Deque<RealConnection> connections = new ArrayDeque<>(); final RouteDatabase routeDatabase = new RouteDatabase(); boolean cleanupRunning; /** Returns a recycled connection to {@code address}, or null if no such connection exists. */ RealConnection get(Address address, StreamAllocation streamAllocation) { assert (Thread.holdsLock(this)); for (RealConnection connection : connections) { if (connection.allocations.size() < connection.allocationLimit && address.equals(connection.route().address) && !connection.noNewStreams) { streamAllocation.acquire(connection); return connection; } } return null; }</code></pre> <p>ConnectionPool连接池是连接的容器，这里用了一个Deque来保存所有的连接RealConnection。而get的过程就是，遍历保存的所有连接来匹配address。同时connection.allocations.size()要满足connection.allocationLimit的限制。</p> <p>在找到了所需要的连接之后，会acquire该连接。</p> <p>acquire连接的过程又是什么样的呢？</p> <pre> <code class="language-java">public final class StreamAllocation { ...... /** * Use this allocation to hold {@code connection}. Each call to this must be paired with a call to * {@link #release} on the same connection. */ public void acquire(RealConnection connection) { assert (Thread.holdsLock(connectionPool)); connection.allocations.add(new StreamAllocationReference(this, callStackTrace)); }</code></pre> <p>基本上就是给RealConnection的allocations添加一个到该StreamAllocation的引用。这样看来，同一个连接RealConnection似乎同时可以为多个HTTP请求服务。而我们知道，多个HTTP/1.1请求是不能在同一个连接上交叉处理的。那这又是怎么回事呢？</p> <p>我们来看connection.allocationLimit的更新设置。RealConnection中如下的两个地方会设置这个值：</p> <pre> <code class="language-java">public final class RealConnection extends Http2Connection.Listener implements Connection { ...... 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.HTTP_2) { socket.setSoTimeout(0); // Framed connection timeouts are set per-stream. Http2Connection http2Connection = new Http2Connection.Builder(true) .socket(socket, route.address().url().host(), source, sink) .listener(this) .build(); http2Connection.start(); // Only assign the framed connection once the preface has been sent successfully. this.allocationLimit = http2Connection.maxConcurrentStreams(); this.http2Connection = http2Connection; } else { this.allocationLimit = 1; } } /** When settings are received, adjust the allocation limit. */ @Override public void onSettings(Http2Connection connection) { allocationLimit = connection.maxConcurrentStreams(); }</code></pre> <p>可以看到，若不是HTTP/2的连接，则allocationLimit的值总是1。由此可见，StreamAllocation以及RealConnection的allocations/allocationLimit这样的设计，主要是为了实现HTTP/2 multi stream的特性。否则的话，大概为RealConnection用一个inUse标记就可以了。</p> <p>那</p> <p>回到StreamAllocation的 findConnection() ，来看新创建的RealConnection对象建立连接的过程，即RealConnection的connect()：</p> <pre> <code class="language-java">public final class RealConnection extends Http2Connection.Listener implements Connection { private final Route route; /** The low-level TCP socket. */ private Socket rawSocket; /** * The application layer socket. Either an {@link SSLSocket} layered over {@link #rawSocket}, or * {@link #rawSocket} itself if this connection does not use SSL. */ public Socket socket; private Handshake handshake; private Protocol protocol; public volatile Http2Connection http2Connection; public int successCount; public BufferedSource source; public BufferedSink sink; public int allocationLimit; public final List<Reference<StreamAllocation>> allocations = new ArrayList<>(); public boolean noNewStreams; public long idleAtNanos = Long.MAX_VALUE; public RealConnection(Route route) { this.route = route; } public void connect(int connectTimeout, int readTimeout, int writeTimeout, List<ConnectionSpec> connectionSpecs, boolean connectionRetryEnabled) { if (protocol != null) throw new IllegalStateException("already connected"); RouteException routeException = null; ConnectionSpecSelector connectionSpecSelector = new ConnectionSpecSelector(connectionSpecs); if (route.address().sslSocketFactory() == null) { if (!connectionSpecs.contains(ConnectionSpec.CLEARTEXT)) { throw new RouteException(new UnknownServiceException( "CLEARTEXT communication not enabled for client")); } String host = route.address().url().host(); if (!Platform.get().isCleartextTrafficPermitted(host)) { throw new RouteException(new UnknownServiceException( "CLEARTEXT communication to " + host + " not permitted by network security policy")); } } while (protocol == null) { try { if (route.requiresTunnel()) { buildTunneledConnection(connectTimeout, readTimeout, writeTimeout, connectionSpecSelector); } else { buildConnection(connectTimeout, readTimeout, writeTimeout, connectionSpecSelector); } } catch (IOException e) { closeQuietly(socket); closeQuietly(rawSocket); socket = null; rawSocket = null; source = null; sink = null; handshake = null; protocol = null; if (routeException == null) { routeException = new RouteException(e); } else { routeException.addConnectException(e); } if (!connectionRetryEnabled || !connectionSpecSelector.connectionFailed(e)) { throw routeException; } } } }</code></pre> <p>根据路由的类型，来执行不同的创建连接的过程。对于需要创建隧道连接的路由，执行buildTunneledConnection()，而对于普通连接，则执行buildConnection()。</p> <p>如何判断是否要建立隧道连接呢？来看</p> <pre> <code class="language-java">/** * Returns true if this route tunnels HTTPS through an HTTP proxy. See <a * href="http://www.ietf.org/rfc/rfc2817.txt">RFC 2817, Section 5.2</a>. */ public boolean requiresTunnel() { return address.sslSocketFactory != null && proxy.type() == Proxy.Type.HTTP; }</code></pre> <p>可以看到，通过代理服务器，来做https请求的连接(http/1.1的https和http2)需要建立隧道连接，而其它的连接则不需要建立隧道连接。</p> <p>用于建立隧道连接的buildTunneledConnection()的过程：</p> <pre> <code class="language-java">/** * Does all the work to build an HTTPS connection over a proxy tunnel. The catch here is that a * proxy server can issue an auth challenge and then close the connection. */ private void buildTunneledConnection(int connectTimeout, int readTimeout, int writeTimeout, ConnectionSpecSelector connectionSpecSelector) throws IOException { Request tunnelRequest = createTunnelRequest(); HttpUrl url = tunnelRequest.url(); int attemptedConnections = 0; int maxAttempts = 21; while (true) { if (++attemptedConnections > maxAttempts) { throw new ProtocolException("Too many tunnel connections attempted: " + maxAttempts); } connectSocket(connectTimeout, readTimeout); tunnelRequest = createTunnel(readTimeout, writeTimeout, tunnelRequest, url); if (tunnelRequest == null) break; // Tunnel successfully created. // The proxy decided to close the connection after an auth challenge. We need to create a new // connection, but this time with the auth credentials. closeQuietly(rawSocket); rawSocket = null; sink = null; source = null; } establishProtocol(readTimeout, writeTimeout, connectionSpecSelector); }</code></pre> <p>基本上是两个过程：</p> <ol> <li>建立隧道连接。</li> <li>建立Protocol。</li> </ol> <p>建立隧道连接的过程，又分为了几个过程：</p> <ul> <li>创建隧道请求</li> <li>建立Socket连接</li> <li>发送请求建立隧道</li> </ul> <p>隧道请求是一个常规的HTTP请求，只是请求的内容有点特殊。初始的隧道请求如：</p> <pre> <code class="language-java">/** * Returns a request that creates a TLS tunnel via an HTTP proxy. Everything in the tunnel request * is sent unencrypted to the proxy server, so tunnels include only the minimum set of headers. * This avoids sending potentially sensitive data like HTTP cookies to the proxy unencrypted. */ private Request createTunnelRequest() { return new Request.Builder() .url(route.address().url()) .header("Host", Util.hostHeader(route.address().url(), true)) .header("Proxy-Connection", "Keep-Alive") .header("User-Agent", Version.userAgent()) // For HTTP/1.0 proxies like Squid. .build(); }</code></pre> <p>建立socket连接的过程如下：</p> <pre> <code class="language-java">private void connectSocket(int connectTimeout, int readTimeout) 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); rawSocket.setSoTimeout(readTimeout); try { 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)); sink = Okio.buffer(Okio.sink(rawSocket)); }</code></pre> <p>主要是创建一个到代理服务器或HTTP服务器的Socket连接。socketFactory最终来自于OkHttpClient，对于OpenJDK 8而言，默认为DefaultSocketFactory：</p> <pre> <code class="language-java">/** * Returns a copy of the environment's default socket factory. * * @return the default <code>SocketFactory</code> */ public static SocketFactory getDefault() { synchronized (SocketFactory.class) { if (theFactory == null) { // // Different implementations of this method SHOULD // work rather differently. For example, driving // this from a system property, or using a different // implementation than JavaSoft's. // theFactory = new DefaultSocketFactory(); } } return theFactory; }</code></pre> <p>创建隧道的过程是这样子的：</p> <pre> <code class="language-java">/** * To make an HTTPS connection over an HTTP proxy, send an unencrypted CONNECT request to create * the proxy connection. This may need to be retried if the proxy requires authorization. */ private Request createTunnel(int readTimeout, int writeTimeout, Request tunnelRequest, HttpUrl url) throws IOException { // Make an SSL Tunnel on the first message pair of each SSL + proxy connection. String requestLine = "CONNECT " + Util.hostHeader(url, true) + " HTTP/1.1"; while (true) { Http1Codec tunnelConnection = new Http1Codec(null, null, source, sink); source.timeout().timeout(readTimeout, MILLISECONDS); sink.timeout().timeout(writeTimeout, MILLISECONDS); tunnelConnection.writeRequest(tunnelRequest.headers(), requestLine); tunnelConnection.finishRequest(); Response response = tunnelConnection.readResponse().request(tunnelRequest).build(); // The response body from a CONNECT should be empty, but if it is not then we should consume // it before proceeding. long contentLength = HttpHeaders.contentLength(response); if (contentLength == -1L) { contentLength = 0L; } Source body = tunnelConnection.newFixedLengthSource(contentLength); Util.skipAll(body, Integer.MAX_VALUE, TimeUnit.MILLISECONDS); body.close(); switch (response.code()) { case HTTP_OK: // Assume the server won't send a TLS ServerHello until we send a TLS ClientHello. If // that happens, then we will have buffered bytes that are needed by the SSLSocket! // This check is imperfect: it doesn't tell us whether a handshake will succeed, just // that it will almost certainly fail because the proxy has sent unexpected data. if (!source.buffer().exhausted() || !sink.buffer().exhausted()) { throw new IOException("TLS tunnel buffered too many bytes!"); } return null; case HTTP_PROXY_AUTH: tunnelRequest = route.address().proxyAuthenticator().authenticate(route, response); if (tunnelRequest == null) throw new IOException("Failed to authenticate with proxy"); if ("close".equalsIgnoreCase(response.header("Connection"))) { return tunnelRequest; } break; default: throw new IOException( "Unexpected response code for CONNECT: " + response.code()); } } }</code></pre> <p>主要HTTP 的 CONNECT 方法建立隧道。</p> <p>而建立常规的连接的过程则为：</p> <pre> <code class="language-java">/** Does all the work necessary to build a full HTTP or HTTPS connection on a raw socket. */ private void buildConnection(int connectTimeout, int readTimeout, int writeTimeout, ConnectionSpecSelector connectionSpecSelector) throws IOException { connectSocket(connectTimeout, readTimeout); establishProtocol(readTimeout, writeTimeout, connectionSpecSelector); }</code></pre> <p>建立socket连接，然后建立Protocol。建立Protocol的过程为：</p> <pre> <code class="language-java">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.HTTP_2) { socket.setSoTimeout(0); // Framed connection timeouts are set per-stream. Http2Connection http2Connection = new Http2Connection.Builder(true) .socket(socket, route.address().url().host(), source, sink) .listener(this) .build(); http2Connection.start(); // Only assign the framed connection once the preface has been sent successfully. this.allocationLimit = http2Connection.maxConcurrentStreams(); this.http2Connection = http2Connection; } else { this.allocationLimit = 1; } }</code></pre> <p>HTTP/2协议的协商过程在connectTls()的过程中完成。</p> <p>总结一下OkHttp3的连接RealConnection的含义，或者说是ConnectInterceptor从StreamAllocation中获取的RealConnection对象的状态：</p> <ol> <li>对于不使用HTTP代理的HTTP请求，为一个到HTTP服务器的Socket连接。后续直接向该Socket连接中写入常规的HTTP请求，并从中读取常规的HTTP响应。</li> <li>对于不使用代理的https请求，为一个到https服务器的Socket连接，但经过了TLS握手，协议协商等过程。后续直接向该Socket连接中写入常规的请求，并从中读取常规的响应。</li> <li>对于使用HTTP代理的HTTP请求，为一个到HTTP代理服务器的Socket连接。后续直接向该Socket连接中写入常规的HTTP请求，并从中读取常规的HTTP响应。</li> <li>对于使用代理的https请求，为一个到代理服务器的隧道连接，但经过了TLS握手，协议协商等过程。后续直接向该Socket连接中写入常规的请求，并从中读取常规的响应。</li> </ol> <p> </p> <p> </p> <p>来自：http://www.jianshu.com/p/5c98999bc34f</p> <p> </p>