Android原生网络库HttpURLConnection分析—
2018-08-19 本文已影响47人
仰简
一、前言
目前做Android开发在网络框架上，大公司一般都维护着有自己的网络框架，而一般的应用都在使用Volley或者OkHttp，或者封装了OkHttp的Retrofit，那么为何还要来分析Android自带的网络框架呢。当然，Android大部分是来自于Java本身的库，只不过针对移动端做了更改和简化。自带网络框架虽然被大家所诟病，但其实是复杂的，庞大的，很多情况下都是非常贴近 HTTP 协议以及TCP/IP协议的。所谓越原始往往越接近真相。整个分析下来相信会有不错的收获。原生框架是一份不错的学习资料。
这里的Android原生网络框架的分析是基于 4.3 的，想必了解的人都知道了。Android从4.4开始就引入OkHttp但还不是作为唯一底层框架，而在5.0之后完全以OkHttp为底层网络框架了。
原生的网络框架有好几个包，关系上看起来有乱：
java.net：主要就是简单的HTTP协议实现，包括URL，HttpUrlConnection等，也是最基础的部分
java.security：安全相关，Http协议的实现，证书校验等
javax.crypto：加解密相关
javax.net：主要有 ssl 相关
javax.security: 也是安全相关的。与 **java.security **有什么关系呢？又有什么不同呢？各自负责的职责是什么？
ibcore.net：算是网络库的中间层封装
org.apache.harmony.xnet.provider.jsse: apache的包？有什么用？
这些是否有内在联系？带着这些疑问，开始Android原生网络库的分析之旅吧。
还是以网络连接、通信与断开为线索进行分析。
二、Http连接
1.示例
先来看一段官方通信示例代码。
// 1.打开 URLConnection
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
try {
// 2.设置参数
urlConnection.setDoOutput(true);
urlConnection.setChunkedStreamingMode(0);
// 3.获取输出流
OutputStream out = new BufferedOutputStream(urlConnection.getOutputStream());
// 4.写入参数
writeStream(out);
// 5.获取读入流
InputStream in = new BufferedInputStream(urlConnection.getInputStream());
// 6.读取数据
readStream(in);
} finally {
// 7.断开连接
urlConnection.disconnect();
}
代码很简单，但如注释时所述，共分了7个小步骤。但代码虽然短，可这里却有不少的疑问：
(1)可以注意到有disconnect()调用，但却没有connect()调用。那么openConnection()发起了真正的网络连接了吗？到底什么时候执行的TCP三次握手呢？
(2)disconnect()调用后，底层的TCP执行了4次挥手协议了吗？
带着这些疑问，先从 openConnection()看起吧。
2.openConnection()打开连接
OpenUrlConnection.jpg
URL的构建函数重载的比较多，这里只是简单传入一个url，最终会调用到如下这个版本的构建函数。
public URL(URL context, String spec, URLStreamHandler handler) throws MalformedURLException {
153 if (spec == null) {
154 throw new MalformedURLException();
155 }
156 if (handler != null) {
157 streamHandler = handler;
158 }
159 spec = spec.trim();
160 // 1.先解析出协议头，确定协议
161 protocol = UrlUtils.getSchemePrefix(spec);
162 int schemeSpecificPartStart = protocol != null ? (protocol.length() + 1) : 0;
163
164 // If the context URL has a different protocol, discard it because we can't use it.
165 if (protocol != null && context != null && !protocol.equals(context.protocol)) {
166 context = null;
167 }
168
169 // Inherit from the context URL if it exists.
170 if (context != null) {
171 set(context.protocol, context.getHost(), context.getPort(), context.getAuthority(),
172 context.getUserInfo(), context.getPath(), context.getQuery(),
173 context.getRef());
174 if (streamHandler == null) {
175 streamHandler = context.streamHandler;
176 }
177 } else if (protocol == null) {
178 throw new MalformedURLException("Protocol not found: " + spec);
179 }
180
181 if (streamHandler == null) {
// 2.关键调用。根据协议设置用来干活的 Handler
182 setupStreamHandler();
183 if (streamHandler == null) {
184 throw new MalformedURLException("Unknown protocol: " + protocol);
185 }
186 }
187
188 // Parse the URL. If the handler throws any exception, throw MalformedURLException instead.
189 try { // 解析url的全部部分，handler解析完成后，最后会通过URL#set（）方法将port,filepath,userinfo等都传回来的
190 streamHandler.parseURL(this, spec, schemeSpecificPartStart, spec.length());
191 } catch (Exception e) {
192 throw new MalformedURLException(e.toString());
193 }
194 }
如代码中的关键注释，构建函数的主要作用是确定协议，端口，文件路径，以用于处理实际事务的handler。这里就假设就是HTTP协议，那么其确定下来的Handler就是HttpHandler.
URLStreamHandler是一个抽象类，HttpHandler是其子类。parseURL这类公共操作在父类URLStreamHandler中完成，openConnection()因为会发生不同的行为，所以其在子类HttpHandler中完成。
public URLConnection openConnection() throws IOException {
471 return streamHandler.openConnection(this);
472 }
URL#openConnection()非常简单就是进一步调用相应Handler的openConnection()，这里调用的是HttpHandler#openConnection()
@Override protected URLConnection openConnection(URL url, Proxy proxy) throws IOException {
33 if (url == null || proxy == null) {
34 throw new IllegalArgumentException("url == null || proxy == null");
35 }
36 return new HttpURLConnectionImpl(url, getDefaultPort(), proxy);
37 }
这里最终构建了一个具体的实现类HttpURLConnectionImpl，它继承自HttpURLConnection，而HttpURLConnection又继承自URLConnection。构建函数并没有做什么特殊的事情，而是一级一级将url向父类传递直到URLConnection，并最终记录在URLConnection。同时这里还有一个需要提一下的是，这里还确定了默认端口为 80。
3.参数设置
setDoOutput(),setChunkedStreamingMode(),setDoInput()等这些只是设置一些参数，也并没有真正发起网络请求。稍微提一下setChunkedStreamingMode()，用来设置body的分块大小，系统建议默认值，即为 1024。
除了这些基础的参数可以进行设置，还一个关键的HTTP的request header参数的添加。
@Override public final void addRequestProperty(String field, String value) {
511 if (connected) {
512 throw new IllegalStateException("Cannot add request property after connection is made");
513 }
514 if (field == null) {
515 throw new NullPointerException("field == null");
516 }
517 rawRequestHeaders.add(field, value);
518 }
添加的field-value(通常描述是key-value)会被记录到rawRequestHeaders中，它所属的类是RawHeaders。另外一个要注意的是，它必须在连接之前就设置好，否则会引发异常。那么什么时候进行连接的呢，进一步看getOutputStream吧。
4.getOutputStream
getOutputStream.jpg
过程有点长，画的也有点细，分了20步，需要耐着点性子看，不要畏难也不要怕麻烦，其实挺简单的。
下面还是来分步骤更详细的了解其是如何建立起连接的。
@Override public final OutputStream getOutputStream() throws IOException {
197 connect();
198
199 OutputStream result = httpEngine.getRequestBody();
200 if (result == null) {
201 throw new ProtocolException("method does not support a request body: " + method);
202 } else if (httpEngine.hasResponse()) {
203 throw new ProtocolException("cannot write request body after response has been read");
204 }
205
206 return result;
207 }
根据前面的分析，getOutputStream调用的是HttpURLConnectionImpl的方法。在这里调用了内部方法 connect()
78 @Override public final void connect() throws IOException {
79 initHttpEngine();
80 try {
81 httpEngine.sendRequest();
82 } catch (IOException e) {
83 httpEngineFailure = e;
84 throw e;
85 }
86 }
这里仅有两个关键调用，initHttpEngine()以及httpEngine.sendRequest()先来看initHttpEngine()方法。
private void initHttpEngine() throws IOException {
235 if (httpEngineFailure != null) {
236 throw httpEngineFailure;
237 } else if (httpEngine != null) {
238 return;
239 }
240 // 记录 connected 状态为 true，记住不能再设置/添加Header参数了
241 connected = true;
242 try {
243 if (doOutput) { // 设置了 doOutput 且为 GET 方法的会被自动校正为 POST方法
244 if (method == HttpEngine.GET) {
245 // they are requesting a stream to write to. This implies a POST method
246 method = HttpEngine.POST;
247 } else if (method != HttpEngine.POST && method != HttpEngine.PUT) {
248 // If the request method is neither POST nor PUT, then you're not writing
249 throw new ProtocolException(method + " does not support writing");
250 }
251 }
// 该方法的关键，调用 newHttpEngine()
252 httpEngine = newHttpEngine(method, rawRequestHeaders, null, null);
253 } catch (IOException e) {
254 httpEngineFailure = e;
255 throw e;
256 }
257 }
这里的关键是记录了connected状态以及进一步调用 newHttpEngine()方法初始化HttpEngine实例。
259 /**
260 * Create a new HTTP engine. This hook method is non-final so it can be
261 * overridden by HttpsURLConnectionImpl.
262 */
263 protected HttpEngine newHttpEngine(String method, RawHeaders requestHeaders,
264 HttpConnection connection, RetryableOutputStream requestBody) throws IOException {
265 return new HttpEngine(this, method, requestHeaders, connection, requestBody);
266 }
newHttpEngine是一个可重载的方法，不同协议会有自己的 Engine。这里仅仅是构建了一个HttpEngine的具体对象实例，另外需要注意的关键点是 connection 是传入的 null。继续看 HttpEngine的构建函数。
187 public HttpEngine(HttpURLConnectionImpl policy, String method, RawHeaders requestHeaders,
188 HttpConnection connection, RetryableOutputStream requestBodyOut) throws IOException {
189 this.policy = policy;
190 this.method = method;
191 this.connection = connection;
192 this.requestBodyOut = requestBodyOut;
193
194 try {
195 uri = policy.getURL().toURILenient();
196 } catch (URISyntaxException e) {
197 throw new IOException(e);
198 }
199
200 this.requestHeaders = new RequestHeaders(uri, new RawHeaders(requestHeaders));
201 }
构建函数只是简单的记录相应的参数。但这里有几个重要的类是需要关注一下的，下面说说几个重要的类。
HttpEngine
它在这里是一个管理类，HTTP等协议相关的如发起连接，获取结果，断开连接等都通过该类来完成。此外，还有一个最重要的任务也是在这里完成，即生成请求行以及包装请求头，都在这里完成。
RequestHeaders、RawHeaders
RawHeaders记录的是比较原始的数据，如协议版本号，请求行以及请求Header参数的fieldname-value。可以看成就是个暂时记录数据的地方。
RequestHeaders是对RawHeaders的进一步解析，也是HTTP协议相关的。来看看其构造函数。
public RequestHeaders(URI uri, RawHeaders headers) {
65 this.uri = uri;
66 this.headers = headers;
67
68 HeaderParser.CacheControlHandler handler = new HeaderParser.CacheControlHandler() {
69 @Override public void handle(String directive, String parameter) {
70 if (directive.equalsIgnoreCase("no-cache")) {
71 noCache = true;
72 } else if (directive.equalsIgnoreCase("max-age")) {
73 maxAgeSeconds = HeaderParser.parseSeconds(parameter);
74 } else if (directive.equalsIgnoreCase("max-stale")) {
75 maxStaleSeconds = HeaderParser.parseSeconds(parameter);
76 } else if (directive.equalsIgnoreCase("min-fresh")) {
77 minFreshSeconds = HeaderParser.parseSeconds(parameter);
78 } else if (directive.equalsIgnoreCase("only-if-cached")) {
79 onlyIfCached = true;
80 }
81 }
82 };
83
84 for (int i = 0; i < headers.length(); i++) {
85 String fieldName = headers.getFieldName(i);
86 String value = headers.getValue(i);
87 if ("Cache-Control".equalsIgnoreCase(fieldName)) {
88 HeaderParser.parseCacheControl(value, handler);
89 } else if ("Pragma".equalsIgnoreCase(fieldName)) {
90 if (value.equalsIgnoreCase("no-cache")) {
91 noCache = true;
92 }
93 } else if ("If-None-Match".equalsIgnoreCase(fieldName)) {
94 ifNoneMatch = value;
95 } else if ("If-Modified-Since".equalsIgnoreCase(fieldName)) {
96 ifModifiedSince = value;
97 } else if ("Authorization".equalsIgnoreCase(fieldName)) {
98 hasAuthorization = true;
99 } else if ("Content-Length".equalsIgnoreCase(fieldName)) {
100 try {
101 contentLength = Integer.parseInt(value);
102 } catch (NumberFormatException ignored) {
103 }
104 } else if ("Transfer-Encoding".equalsIgnoreCase(fieldName)) {
105 transferEncoding = value;
106 } else if ("User-Agent".equalsIgnoreCase(fieldName)) {
107 userAgent = value;
108 } else if ("Host".equalsIgnoreCase(fieldName)) {
109 host = value;
110 } else if ("Connection".equalsIgnoreCase(fieldName)) {
111 connection = value;
112 } else if ("Accept-Encoding".equalsIgnoreCase(fieldName)) {
113 acceptEncoding = value;
114 } else if ("Content-Type".equalsIgnoreCase(fieldName)) {
115 contentType = value;
116 } else if ("Proxy-Authorization".equalsIgnoreCase(fieldName)) {
117 proxyAuthorization = value;
118 }
119 }
120 }
非常的长，但不要畏难或者被吓到。其实就是解析RawHeader中的Header字段，说白了就是处理数据，只不过处理的协议头的参数罢了。
到这里，终于构建好了 HttpEngine 类了，Header的参数也解析好了。下面就可以发请求了。好，来看 HttpEngine#sendRequest()。
207 /**
208 * Figures out what the response source will be, and opens a socket to that
209 * source if necessary. Prepares the request headers and gets ready to start
210 * writing the request body if it exists.
211 */
212 public final void sendRequest() throws IOException {
213 if (responseSource != null) {
214 return;
215 }
216 //1. 准备请求头的参数
217 prepareRawRequestHeaders();
// 2.初始化响应资源
218 initResponseSource();
219 if (responseCache instanceof ExtendedResponseCache) {
220 ((ExtendedResponseCache) responseCache).trackResponse(responseSource);
221 }
222
223 /*
224 * The raw response source may require the network, but the request
225 * headers may forbid network use. In that case, dispose of the network
226 * response and use a GATEWAY_TIMEOUT response instead, as specified
227 * by http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.4.
228 */
229 if (requestHeaders.isOnlyIfCached() && responseSource.requiresConnection()) {
230 if (responseSource == ResponseSource.CONDITIONAL_CACHE) {
231 IoUtils.closeQuietly(cachedResponseBody);
232 }
233 this.responseSource = ResponseSource.CACHE;
234 this.cacheResponse = GATEWAY_TIMEOUT_RESPONSE;
235 RawHeaders rawResponseHeaders = RawHeaders.fromMultimap(cacheResponse.getHeaders());
236 setResponse(new ResponseHeaders(uri, rawResponseHeaders), cacheResponse.getBody());
237 }
238
239 if (responseSource.requiresConnection()) {
// 3.发起 socket 请求
240 sendSocketRequest();
241 } else if (connection != null) {
242 HttpConnectionPool.INSTANCE.recycle(connection);
243 connection = null;
244 }
245 }
这里有三个的关键调用，在注释中有描述。下面一个一个来看吧。先看 prepareRawRequestHeaders()方法。
prepareRawRequestHeaders()
693 /**
694 * Populates requestHeaders with defaults and cookies.
695 *
696 * <p>This client doesn't specify a default {@code Accept} header because it
697 * doesn't know what content types the application is interested in.
698 */
699 private void prepareRawRequestHeaders() throws IOException {
700 requestHeaders.getHeaders().setStatusLine(getRequestLine());
701
702 if (requestHeaders.getUserAgent() == null) {
703 requestHeaders.setUserAgent(getDefaultUserAgent());
704 }
705
706 if (requestHeaders.getHost() == null) {
707 requestHeaders.setHost(getOriginAddress(policy.getURL()));
708 }
709
710 if (httpMinorVersion > 0 && requestHeaders.getConnection() == null) {
711 requestHeaders.setConnection("Keep-Alive");
712 }
713
714 if (requestHeaders.getAcceptEncoding() == null) {
715 transparentGzip = true;
716 requestHeaders.setAcceptEncoding("gzip");
717 }
718
719 if (hasRequestBody() && requestHeaders.getContentType() == null) {
720 requestHeaders.setContentType("application/x-www-form-urlencoded");
721 }
722
723 long ifModifiedSince = policy.getIfModifiedSince();
724 if (ifModifiedSince != 0) {
725 requestHeaders.setIfModifiedSince(new Date(ifModifiedSince));
726 }
727
728 CookieHandler cookieHandler = CookieHandler.getDefault();
729 if (cookieHandler != null) {
730 requestHeaders.addCookies(
731 cookieHandler.get(uri, requestHeaders.getHeaders().toMultimap()));
732 }
733 }
这里设置了请求行：如 GET url HTTP/1.1，设置UA，设置Host，设置 Connection 为 keep-alive，设置 accept-encoding 为gzip。设置 content-type 为 "application/x-www-form-urlencoded",设置 if-Modified-Since，添加发送给服务器的 cookie。
准备好了请求参数，下面来看一看initResponseSource()方法。
initResponseSource
private void initResponseSource() throws IOException {
// 默认为是从网络获取
252 responseSource = ResponseSource.NETWORK;
253 if (!policy.getUseCaches() || responseCache == null) {
254 return;
255 }
256 // 查看是否有缓存
257 CacheResponse candidate = responseCache.get(uri, method,
258 requestHeaders.getHeaders().toMultimap());
259 if (candidate == null) {
260 return;
261 }
262 // 有缓存的情况下取出响Header与body
263 Map<String, List<String>> responseHeadersMap = candidate.getHeaders();
264 cachedResponseBody = candidate.getBody();
// 对于不接受的缓存类型直接关掉被返回
265 if (!acceptCacheResponseType(candidate)
266 || responseHeadersMap == null
267 || cachedResponseBody == null) {
268 IoUtils.closeQuietly(cachedResponseBody);
269 return;
270 }
271 // 缓存可接受，从responseHeadersMap解析出RawHeaders，这个类在上面的分析中已经讲过了。现在看来它也同时用于记录 Response 的 Header
272 RawHeaders rawResponseHeaders = RawHeaders.fromMultimap(responseHeadersMap);
// 构建 ResponseHeaders
273 cachedResponseHeaders = new ResponseHeaders(uri, rawResponseHeaders);
274 long now = System.currentTimeMillis();
// 最后的 response 的实际来源
275 this.responseSource = cachedResponseHeaders.chooseResponseSource(now, requestHeaders);
276 if (responseSource == ResponseSource.CACHE) {//如果是cache，把刚才的 request 以及 response 包装成Response，这也是要返回给上层用户的结果。
277 this.cacheResponse = candidate;
278 setResponse(cachedResponseHeaders, cachedResponseBody);
279 } else if (responseSource == ResponseSource.CONDITIONAL_CACHE) {//条件缓存
280 this.cacheResponse = candidate;
281 } else if (responseSource == ResponseSource.NETWORK) {//网络则直接关闭缓存
282 IoUtils.closeQuietly(cachedResponseBody);
283 } else {
284 throw new AssertionError();
285 }
286 }
287
initResponseSource的主要作用决定请求的结果是由哪里来的。共有三种情况：网络，缓存，条件缓存。网络没什么好解释的，缓存被禁用或者没有自然就是要发起网络请了。
缓存，相应的类是ResponseCache，这是一个接口，其具体的子类为HttpResponseCache。关于这个类的细节实现没有必要再进一步分析，因为其和Volley还算比较深入的分析中的缓存差不太多，缓存算法也是 DiskLruCache，但这里的key有点差别，用的是 url 的md5编码，既安全又节省资源大小。
条件缓存，与Http协议的缓存密切相关。在chooseResponseSource()中最后会根据request的请求头参数来确定是否为条件缓存。
280 public boolean hasConditions() {
281 return ifModifiedSince != null || ifNoneMatch != null;
282 }
而它们所对应的字段就是"If-None-Match"和"If-Modified-Since"。
假设缓存里没有吧，那就要发起真正的网络请了。来看看 sendSocketRequest()方法。
sendSocketRequest
private void sendSocketRequest() throws IOException {
289 if (connection == null) {
290 connect();
291 }
292
293 if (socketOut != null || requestOut != null || socketIn != null) {
294 throw new IllegalStateException();
295 }
296
297 socketOut = connection.getOutputStream();
298 requestOut = socketOut;
299 socketIn = connection.getInputStream();
300
301 if (hasRequestBody()) {
302 initRequestBodyOut();
303 }
304 }
这里以 connection 来决定是否要发起内部的 connect()。connection是 HttpConnection的实例。进一步看看connect()的代码。
309 protected void connect() throws IOException {
310 if (connection == null) {
311 connection = openSocketConnection();
312 }
313 }
比较简单，进一步调用了 openSocketConnection()来构建一个 connection。
315 protected final HttpConnection openSocketConnection() throws IOException {
316 HttpConnection result = HttpConnection.connect(uri, getSslSocketFactory(),
317 policy.getProxy(), requiresTunnel(), policy.getConnectTimeout());
318 Proxy proxy = result.getAddress().getProxy();
319 if (proxy != null) {
320 policy.setProxy(proxy);
321 }
322 result.setSoTimeout(policy.getReadTimeout());
323 return result;
324 }
进一步调用HttpConnection的静态方法connect()来创建 HttpConnection。
public static HttpConnection connect(URI uri, SSLSocketFactory sslSocketFactory,
90 Proxy proxy, boolean requiresTunnel, int connectTimeout) throws IOException {
91 /*
92 * Try an explicitly-specified proxy.
93 */
94 if (proxy != null) {
95 Address address = (proxy.type() == Proxy.Type.DIRECT)
96 ? new Address(uri, sslSocketFactory)
97 : new Address(uri, sslSocketFactory, proxy, requiresTunnel);
98 return HttpConnectionPool.INSTANCE.get(address, connectTimeout);
99 }
100
101 /*
102 * Try connecting to each of the proxies provided by the ProxySelector
103 * until a connection succeeds.
104 */
105 ProxySelector selector = ProxySelector.getDefault();
106 List<Proxy> proxyList = selector.select(uri);
107 if (proxyList != null) {
108 for (Proxy selectedProxy : proxyList) {
109 if (selectedProxy.type() == Proxy.Type.DIRECT) {
110 // the same as NO_PROXY
111 // TODO: if the selector recommends a direct connection, attempt that?
112 continue;
113 }
114 try {
115 Address address = new Address(uri, sslSocketFactory,
116 selectedProxy, requiresTunnel);
117 return HttpConnectionPool.INSTANCE.get(address, connectTimeout);
118 } catch (IOException e) {
119 // failed to connect, tell it to the selector
120 selector.connectFailed(uri, selectedProxy.address(), e);
121 }
122 }
123 }
124
125 /*
126 * Try a direct connection. If this fails, this method will throw.
127 */
128 return HttpConnectionPool.INSTANCE.get(new Address(uri, sslSocketFactory), connectTimeout);
129 }
这一堆的代码，前面都是设置代理的，不管它。真正管用的是最后一句HttpConnectionPool.INSTANCE#get()。即从HttpConnectionPool里返回一个HttpConnection。补充一点，INSTANCE代表着HttpConnectionPool对象本身，其实现为一个单例类。进一步看看是如何 Get 的吧。
public HttpConnection get(HttpConnection.Address address, int connectTimeout)
64 throws IOException {
65 // First try to reuse an existing HTTP connection.
66 synchronized (connectionPool) {
67 List<HttpConnection> connections = connectionPool.get(address);
68 while (connections != null) {
69 HttpConnection connection = connections.remove(connections.size() - 1);
70 if (connections.isEmpty()) {
71 connectionPool.remove(address);
72 connections = null;
73 }
74 if (connection.isEligibleForRecycling()) {
75 // Since Socket is recycled, re-tag before using
76 Socket socket = connection.getSocket();
77 SocketTagger.get().tag(socket);
78 return connection;
79 }
80 }
81 }
82
83 /*
84 * We couldn't find a reusable connection, so we need to create a new
85 * connection. We're careful not to do so while holding a lock!
86 */
87 return address.connect(connectTimeout);
88 }
Get()是一个常见的缓存池的套路。先判断当前连接池里是否包含有同一Address的且没有被回收的连接，如果能找到就重新re-tag一下socket，再返回当前找到的HttpCoonection。如果没有找到就通过 address#connect()方法来创建一个。先不进行下一步来关注两个比较重要的点。
isEligibleForRecycling()方法的实现
248 /**
249 * Returns true if this connection is eligible to be reused for another
250 * request/response pair.
251 */
252 protected boolean isEligibleForRecycling() {
253 return !socket.isClosed()
254 && !socket.isInputShutdown()
255 && !socket.isOutputShutdown();
256 }
从代码中知道，未被回收的连接的判定条件是：socket未关闭，输入以及输出流未被关闭。
连接池的Key——Address
Address是HttpConnection的内部类。我们知道任何一个xx池之类的，都要有一个唯一的key用来判断是否为同一资源。这里使用Address对象，看起来有点奇怪。既然这么用了，那么它一定是重写了 equal()方法和hashcode()方法了。来看一看。
@Override public boolean equals(Object other) {
318 if (other instanceof Address) {
319 Address that = (Address) other;
320 return Objects.equal(this.proxy, that.proxy)
321 && this.uriHost.equals(that.uriHost)
322 && this.uriPort == that.uriPort
323 && Objects.equal(this.sslSocketFactory, that.sslSocketFactory)
324 && this.requiresTunnel == that.requiresTunnel;
325 }
326 return false;
327 }
328
329 @Override public int hashCode() {
330 int result = 17;
331 result = 31 * result + uriHost.hashCode();
332 result = 31 * result + uriPort;
333 result = 31 * result + (sslSocketFactory != null ? sslSocketFactory.hashCode() : 0);
334 result = 31 * result + (proxy != null ? proxy.hashCode() : 0);
335 result = 31 * result + (requiresTunnel ? 1 : 0);
336 return result;
337 }
果然是被重写了。从上面两个方法也可以看出，判断为同一Key，需要 host,port,sslfactory,proxy,tunel都是相等的才能算是同一key。
下面继续看HttpConnection是如何创建的以及创建完成后做了什么。前面有分析到，如果连接池里没有就会创建一个新的。而创建一个新的HttpConnection是通过HttpConnection的子类Address#connect()方法进行的。
public HttpConnection connect(int connectTimeout) throws IOException {
340 return new HttpConnection(this, connectTimeout);
341 }
挺简单的，直接new一个实例，那来看看HttpConnection的构建函数。
private HttpConnection(Address config, int connectTimeout) throws IOException {
62 this.address = config;
63
64 /*
65 * Try each of the host's addresses for best behavior in mixed IPv4/IPv6
66 * environments. See http://b/2876927
67 * TODO: add a hidden method so that Socket.tryAllAddresses can does this for us
68 */
69 Socket socketCandidate = null;
// 1.寻址，即通过 hostname查找 IP 地址，可能会查到多个。
70 InetAddress[] addresses = InetAddress.getAllByName(config.socketHost);
71 for (int i = 0; i < addresses.length; i++) {
//4. 创建用于执行TCP连接的套接字 Socket
72 socketCandidate = (config.proxy != null && config.proxy.type() != Proxy.Type.HTTP)
73 ? new Socket(config.proxy)
74 : new Socket();
75 try {
// 3. 发起套接字Socket的TCP请求连接
76 socketCandidate.connect(
77 new InetSocketAddress(addresses[i], config.socketPort), connectTimeout);
78 break;
79 } catch (IOException e) {
// 4.所有地址都试过了，弹尽粮绝了，报异常。
80 if (i == addresses.length - 1) {
81 throw e;
82 }
83 }
84 }
85
86 this.socket = socketCandidate;
87 }
虽然只是一个构造函数，但复杂度确不低，按照注释的步骤来详细的看一下。
寻址
调用的是InetAddress#getAllByName()，这是一个静态方法。
public static InetAddress[] getAllByName(String host) throws UnknownHostException {
214 return getAllByNameImpl(host).clone();
215 }
216
217 /**
218 * Returns the InetAddresses for {@code host}. The returned array is shared
219 * and must be cloned before it is returned to application code.
220 */
221 private static InetAddress[] getAllByNameImpl(String host) throws UnknownHostException {
// 为空则判定为回路地址，即 127.0.0.1
222 if (host == null || host.isEmpty()) {
223 return loopbackAddresses();
224 }
225
226 // Is it a numeric address?本身就是IP地址吗？是的话就不用继续找了。
227 InetAddress result = parseNumericAddressNoThrow(host);
228 if (result != null) {
229 result = disallowDeprecatedFormats(host, result);
230 if (result == null) {
231 throw new UnknownHostException("Deprecated IPv4 address format: " + host);
232 }
233 return new InetAddress[] { result };
234 }
235 // 前面的都不是，那就要进一步查找了。
236 return lookupHostByName(host).clone();
237 }
这里需要关注的是对内部方法lookupHostByName()的调用。
378 /**
379 * Resolves a hostname to its IP addresses using a cache.
380 *
381 * @param host the hostname to resolve.
382 * @return the IP addresses of the host.
383 */
384 private static InetAddress[] lookupHostByName(String host) throws UnknownHostException {
385 BlockGuard.getThreadPolicy().onNetwork();
386 // Do we have a result cached?
// 1.先从缓存里面找
387 Object cachedResult = addressCache.get(host);
388 if (cachedResult != null) {
389 if (cachedResult instanceof InetAddress[]) {
390 // A cached positive result.
391 return (InetAddress[]) cachedResult;
392 } else {
393 // A cached negative result.
394 throw new UnknownHostException((String) cachedResult);
395 }
396 }
397 try {
398 StructAddrinfo hints = new StructAddrinfo();
399 hints.ai_flags = AI_ADDRCONFIG;
400 hints.ai_family = AF_UNSPEC;
401 // If we don't specify a socket type, every address will appear twice, once
402 // for SOCK_STREAM and one for SOCK_DGRAM. Since we do not return the family
403 // anyway, just pick one.
// 2.缓存里面没有，调用native方法进一步查找。Libcore.os.getaddrinfo底层会发起DNS域名解析请求
404 hints.ai_socktype = SOCK_STREAM;
405 InetAddress[] addresses = Libcore.os.getaddrinfo(host, hints);
406 // TODO: should getaddrinfo set the hostname of the InetAddresses it returns?
407 for (InetAddress address : addresses) {
408 address.hostName = host;
409 }
410 addressCache.put(host, addresses);
411 return addresses;
412 } catch (GaiException gaiException) {
413 // If the failure appears to have been a lack of INTERNET permission, throw a clear
414 // SecurityException to aid in debugging this common mistake.
415 // http://code.google.com/p/android/issues/detail?id=15722
416 if (gaiException.getCause() instanceof ErrnoException) {
417 if (((ErrnoException) gaiException.getCause()).errno == EACCES) {
418 throw new SecurityException("Permission denied (missing INTERNET permission?)", gaiException);
419 }
420 }
421 // Otherwise, throw an UnknownHostException.
422 String detailMessage = "Unable to resolve host \"" + host + "\": " + Libcore.os.gai_strerror(gaiException.error);
423 addressCache.putUnknownHost(host, detailMessage);
424 throw gaiException.rethrowAsUnknownHostException(detailMessage);
425 }
426 }
寻址就是DNS域名解析，会先从缓存中查看是存在，如果没有则会由底层发起请求到DNS服务器来解析域名映射到实际用于通信的IP地址。
创建socket并发起TCP连接
Socket本身还只是一个包装类，它的connect()会继续调具体的实现类。由Socket的构造函数可知，它默认是PlainSocketImpl，也就是最后调用了它的connect()方法进行TCP连接。
56 this.impl = factory != null ? factory.createSocketImpl() : new PlainSocketImpl();
57 this.proxy = null;
58 }
到这里终于看到连接发出去了。原来构建一个HttpConnection就会发起TCP连接了。创建好了HttpConnection，方法就会原路返回，并最终返回输出流给到示例处调用 getOutputStream()的地方。
5.getInputStream()
getInputStream()与getOutputStream()的整个执行流程是大同小异的，有很多的共同部分，比如也可能发起网络连接，建立TCP的三次握手。
getInputStream.jpg
有了前面getOutputStream的基础，getInputStream就简单多了。
@Override public final InputStream getInputStream() throws IOException {
173 if (!doInput) {
174 throw new ProtocolException("This protocol does not support input");
175 }
176 // 获取 HttpEngine
177 HttpEngine response = getResponse();
178
179 /*
180 * if the requested file does not exist, throw an exception formerly the
181 * Error page from the server was returned if the requested file was
182 * text/html this has changed to return FileNotFoundException for all
183 * file types
184 */
185 if (getResponseCode() >= HTTP_BAD_REQUEST) {
186 throw new FileNotFoundException(url.toString());
187 }
188 // 从 HttpEngin 那里获取 InputStream
189 InputStream result = response.getResponseBody();
190 if (result == null) {
191 throw new IOException("No response body exists; responseCode=" + getResponseCode());
192 }
193 return result;
194 }
如注释第一步是获取HttpEngine，因为在getOutputStream阶段已经创建好了，所以不会再重新创建了，用现成的就好。第二步就是从HttpEngine那里拿到 response body。当然这里需要进一步分析的是 getResponse。
/**
269 * Aggressively tries to get the final HTTP response, potentially making
270 * many HTTP requests in the process in order to cope with redirects and
271 * authentication.
272 */
273 private HttpEngine getResponse() throws IOException {
274 initHttpEngine();
275
276 if (httpEngine.hasResponse()) {
277 return httpEngine;
278 }
279
280 while (true) {
281 try {
282 httpEngine.sendRequest();
283 httpEngine.readResponse();
284 } catch (IOException e) {
285 /*
286 * If the connection was recycled, its staleness may have caused
287 * the failure. Silently retry with a different connection.
288 */
289 OutputStream requestBody = httpEngine.getRequestBody();
290 if (httpEngine.hasRecycledConnection()
291 && (requestBody == null || requestBody instanceof RetryableOutputStream)) {
292 httpEngine.release(false);
293 httpEngine = newHttpEngine(method, rawRequestHeaders, null,
294 (RetryableOutputStream) requestBody);
295 continue;
296 }
297 httpEngineFailure = e;
298 throw e;
299 }
300 // 处理响应头，确定重试的策略。
301 Retry retry = processResponseHeaders();
302 if (retry == Retry.NONE) {
// 正常情况下不需要重试，因此这里也标记HttpConnection由HttpConnectionPool来自动释放。
303 httpEngine.automaticallyReleaseConnectionToPool();
304 return httpEngine;
305 }
306
307 /*
308 * The first request was insufficient. Prepare for another...
309 */
310 String retryMethod = method;
311 OutputStream requestBody = httpEngine.getRequestBody();
312
313 /*
314 * Although RFC 2616 10.3.2 specifies that a HTTP_MOVED_PERM
315 * redirect should keep the same method, Chrome, Firefox and the
316 * RI all issue GETs when following any redirect.
317 */
318 int responseCode = getResponseCode();
319 if (responseCode == HTTP_MULT_CHOICE || responseCode == HTTP_MOVED_PERM
320 || responseCode == HTTP_MOVED_TEMP || responseCode == HTTP_SEE_OTHER) {
321 retryMethod = HttpEngine.GET;
322 requestBody = null;
323 }
324
325 if (requestBody != null && !(requestBody instanceof RetryableOutputStream)) {
326 throw new HttpRetryException("Cannot retry streamed HTTP body",
327 httpEngine.getResponseCode());
328 }
329
330 if (retry == Retry.DIFFERENT_CONNECTION) {
331 httpEngine.automaticallyReleaseConnectionToPool();
332 } else {
333 httpEngine.markConnectionAsRecycled();
334 }
335 // 需要重试情况下，主动断开连接
336 httpEngine.release(true);
337 // 生成一个新的 HttpEngine
338 httpEngine = newHttpEngine(retryMethod, rawRequestHeaders,
339 httpEngine.getConnection(), (RetryableOutputStream) requestBody);
340 }
341 }
如前所述initHttpEngine()以及httpEngine.sendRequest在getOutputStream那里已经做了详细分析了，这里也不用再赘述了。
这里有HttpEngine中的两个方法需要关注，它与如何缓存响应数据以及如何重用连接有关。先来看readResponse()方法。
/**
794 * Flushes the remaining request header and body, parses the HTTP response
795 * headers and starts reading the HTTP response body if it exists.
796 */
797 public final void readResponse() throws IOException {
798 if (hasResponse()) {
799 return;
800 }
801
802 if (responseSource == null) {
803 throw new IllegalStateException("readResponse() without sendRequest()");
804 }
805
806 if (!responseSource.requiresConnection()) {
807 return;
808 }
809
810 if (sentRequestMillis == -1) {
811 int contentLength = requestBodyOut instanceof RetryableOutputStream
812 ? ((RetryableOutputStream) requestBodyOut).contentLength()
813 : -1;
814 writeRequestHeaders(contentLength);
815 }
816
817 if (requestBodyOut != null) {
818 requestBodyOut.close();
819 if (requestBodyOut instanceof RetryableOutputStream) {
820 ((RetryableOutputStream) requestBodyOut).writeToSocket(requestOut);
821 }
822 }
823
824 requestOut.flush();
825 requestOut = socketOut;
826 // 读取响应头
827 readResponseHeaders();
828 responseHeaders.setLocalTimestamps(sentRequestMillis, System.currentTimeMillis());
829
830 if (responseSource == ResponseSource.CONDITIONAL_CACHE) {
831 if (cachedResponseHeaders.validate(responseHeaders)) {
832 release(true);//如果是条件缓存且缓存有效则释放连接并标记为重用连接
833 ResponseHeaders combinedHeaders = cachedResponseHeaders.combine(responseHeaders);
834 setResponse(combinedHeaders, cachedResponseBody);
835 if (responseCache instanceof ExtendedResponseCache) {
836 ExtendedResponseCache httpResponseCache = (ExtendedResponseCache) responseCache;
837 httpResponseCache.trackConditionalCacheHit();
838 httpResponseCache.update(cacheResponse, getHttpConnectionToCache());
839 }
840 return;
841 } else {
842 IoUtils.closeQuietly(cachedResponseBody);
843 }
844 }
845
846 if (hasResponseBody()) {
// 将响应数据写入缓存
847 maybeCache(); // reentrant. this calls into user code which may call back into this!
848 }
849 // 获取响应体的输入流。
850 initContentStream(getTransferStream());
851 }
注释里面有几个关键的内部方法调用，一个一个来看吧。
readResponseHeaders读取响应行与响应头
5 private void readResponseHeaders() throws IOException {
576 RawHeaders headers;
577 do {
578 headers = new RawHeaders();
// 读取响应行
579 headers.setStatusLine(Streams.readAsciiLine(socketIn));
// 读取其他响应头参数，下面直接贴出来了
580 readHeaders(headers);
581 } while (headers.getResponseCode() == HTTP_CONTINUE);
582 setResponse(new ResponseHeaders(uri, headers), null);
583 }
624 private void readHeaders(RawHeaders headers) throws IOException {
625 // parse the result headers until the first blank line
626 String line;
// 直到读到空行为止，头与数据以空行分开
627 while (!(line = Streams.readAsciiLine(socketIn)).isEmpty()) {
628 headers.addLine(line);
629 }
630 // 解析 cookie
631 CookieHandler cookieHandler = CookieHandler.getDefault();
632 if (cookieHandler != null) {
633 cookieHandler.put(uri, headers.toMultimap());
634 }
635 }
关键的东西在代码里有注释了，主要是读响应行，读响应头并设置cookie。而响应头与响应数据之间的空格就是空行。其实请求的也是，如果包含有请求体时，请求头与请求体之间也是空行分开。
release，这里先不贴代码，后面会再继续分析，只要记住在条件缓存的情况下会释放connection，且带的参数为 true.
maybeCache，将响应数据写入HttpResponseCache，比较简单，不展开了。
getTransferStream，构建返回给调用者的 InputStream。终于拿到InputStream了。
readResponse()已经解析完了，然而在getResponse中还有工作需要做。其接下来会通过处理响应头来确认是否需要重试或者重试的策略，是否需要授权(401,可能需要用户名或者密码)，是否需要重定向次数已达到最大(5次)。不需要重试的情况下标记请求由请求池自动回收。需要重试的情况下，释放并重用连接，因为这里调用了HttpEngine#release()方法时传入的参数为 true。这里同样记住传入的参数为true
6.小结
连接所涉及的东西有点多，也可能有些乱，也记不住了，那先总结一波吧。
6.1openConnection()方法
该方法主要是根据协议确定对应的帮助类HttpHandler以及HttpURLConnectionImpl。之后的操作都基于HttpURLConnectionImpl来进行。
6.2参数设置
在getOutpuStream()以及getInputStream()或者显式直接调用connect()方法之前设置好参数，否则会报异常。这三个方法都会触发状态 connected 为 true。
6.3Http协议包装
在发出请求前，会构造好请求行，请求头参数一起发送给服务器。并且注意到在HTTP的版本大于 0 的情况下，默认开启了 keep-alive
6.4缓存
根据HTTP的缓存规则，在getInputStream阶段会对响应回来的数据即response进行缓存。缓存的内部算法采用的是DiskLRUCache实现，key 为对应 url 的MD5编码。
6.5连接池
对当前连接好的HTTP会通过连接池缓存起来，连接池里已经有相等的Address了就会进行重用。其中Address相等需要host,port,sslfactory,proxy,tunel都相等。连接池的全部内容这里其实还没有讲完，比如连接put以及回收。
6.6TCP连接
getOutpuStream()以及getInputStream()或者显式直接调用connect()方法最终都会触发TCP的连接，也就是我们需要的HTTP连接。
三、HTTP通信
所谓的通信，就是利用getOutputStream()获取输出流，从而将数据写到服务端。再利用getInputStream()获取输入流，读取从服务端返回的数据。
四、断开连接
disconnect.jpg
先来看disconnect()方法
@Override public final void disconnect() {
89 // Calling disconnect() before a connection exists should have no effect.
90 if (httpEngine != null) {
91 // We close the response body here instead of in
92 // HttpEngine.release because that is called when input
93 // has been completely read from the underlying socket.
94 // However the response body can be a GZIPInputStream that
95 // still has unread data.
96 if (httpEngine.hasResponse()) {
97 IoUtils.closeQuietly(httpEngine.getResponseBody());
98 }
99 httpEngine.release(false);
100 }
101 }
主要是进一步调用 HttpEngine#release()方法进行释放。另外需要注意的是关闭了responseBody，那这个又是什么呢？后面会详情讲解。
/**
483 * Releases this engine so that its resources may be either reused or
484 * closed.
485 */
486 public final void release(boolean reusable) {
487 // If the response body comes from the cache, close it.
// 从缓存取的结果直接关掉
488 if (responseBodyIn == cachedResponseBody) {
489 IoUtils.closeQuietly(responseBodyIn);
490 }
491
492 if (!connectionReleased && connection != null) {
493 connectionReleased = true;
494
495 // We cannot reuse sockets that have incomplete output.
// 输出数据流还没有关闭不能重用
496 if (requestBodyOut != null && !requestBodyOut.closed) {
497 reusable = false;
498 }
499
500 // If the request specified that the connection shouldn't be reused,
501 // don't reuse it. This advice doesn't apply to CONNECT requests because
502 // the "Connection: close" header goes the origin server, not the proxy.
// 请求协议头描述了connection为close的不能重用
503 if (requestHeaders.hasConnectionClose() && method != CONNECT) {
504 reusable = false;
505 }
506
507 // If the response specified that the connection shouldn't be reused, don't reuse it.
// 响应协议头描述了connection为close的不能重用
508 if (responseHeaders != null && responseHeaders.hasConnectionClose()) {
509 reusable = false;
510 }
511 // 不知道长度的输入流不能重用
512 if (responseBodyIn instanceof UnknownLengthHttpInputStream) {
513 reusable = false;
514 }
515
516 if (reusable && responseBodyIn != null) {
517 // We must discard the response body before the connection can be reused.
518 try {
519 Streams.skipAll(responseBodyIn);
520 } catch (IOException e) {
521 reusable = false;
522 }
523 }
524
525 if (!reusable) {
526 connection.closeSocketAndStreams();
527 connection = null;
528 } else if (automaticallyReleaseConnectionToPool) {
529 HttpConnectionPool.INSTANCE.recycle(connection);
530 connection = null;
531 }
532 }
533 }
中间一大段都可以先不用太关注，看看注释就行。看最后几句，注意这里的 reuseable 传递进来的是false，那么最后是一定会关闭连接的了。也就是说一旦执行disconnect()连接就会被关闭。
131 public void closeSocketAndStreams() {
132 IoUtils.closeQuietly(sslOutputStream);
133 IoUtils.closeQuietly(sslInputStream);
134 IoUtils.closeQuietly(sslSocket);
135 IoUtils.closeQuietly(outputStream);
136 IoUtils.closeQuietly(inputStream);
137 IoUtils.closeQuietly(socket);
138 }
最后把socket与输入输出流都关闭了。也就是说整个连接都断开了。那如果要保持连接一直是重用的，那就不能disconnect()了。这样又是否会有内存泄漏？
还记得前面提到过的吗？在两种情况下框架会自动发生重用，一个是重试情况下，一个条件缓存情况下。所以说这个连接重用还真的是弱呢。
关于HttpConnectionPool#recycle()方法来继续看代码。
public void recycle(HttpConnection connection) {
91 Socket socket = connection.getSocket();
92 try {
93 SocketTagger.get().untag(socket);
94 } catch (SocketException e) {
95 // When unable to remove tagging, skip recycling and close
96 System.logW("Unable to untagSocket(): " + e);
97 connection.closeSocketAndStreams();
98 return;
99 }
100 //
101 if (maxConnections > 0 && connection.isEligibleForRecycling()) {
102 HttpConnection.Address address = connection.getAddress();
103 synchronized (connectionPool) {
104 List<HttpConnection> connections = connectionPool.get(address);
105 if (connections == null) {
106 connections = new ArrayList<HttpConnection>();
107 connectionPool.put(address, connections);
108 }
// 未达到最大连接数
109 if (connections.size() < maxConnections) {
110 connection.setRecycled();
// 把连接加入到连接池
111 connections.add(connection);
112 return; // keep the connection open
113 }
114 }
115 }
116
117 // don't close streams while holding a lock!
// 不能重用就关闭
118 connection.closeSocketAndStreams();
119 }
在recycle()时判断是否已经达到最大连接数，如果没有就可以重用，否则就会关闭连接。这里还需要关注一下maxConnections，默认情况下每个URI最大的连接数为 5。如何得来的？需要关注一下HttpConnectionPool的构造函数。
private HttpConnectionPool() {
51 String keepAlive = System.getProperty("http.keepAlive");
52 if (keepAlive != null && !Boolean.parseBoolean(keepAlive)) {
53 maxConnections = 0;
54 return;
55 }
56
57 String maxConnectionsString = System.getProperty("http.maxConnections");
58 this.maxConnections = maxConnectionsString != null
59 ? Integer.parseInt(maxConnectionsString)
60 : 5;
61 }
也就是说需要系统设置了 http.keepAlive 这个参数为true，那么就可以进一步设置maxConnections的大小了。可以自己定义，也可以使用默认值为5.
五、总结
(1)至此，Android原生网络库，仅HTTP部分终于分析完了，还是学习不到少东西的。
(2)Android原生网络库只是HTTP协议在网络应用层的实现，有一定的封装，但本身并没有进行过多的扩展。
(3)这里面我们能看到最基本的一些Http协议相关的内容，如请求行，请求头以及请求体的封装，解析，默认参数设置等。当然也有对响应行，响应头以及响应体的解析，封装，默认处理等。对了，还有一个重要的，那就是cookie，也有相应的解析以及处理，包括请求和响应时。
(4)Android原生网络库同样也实现了响应内容的缓存，所用的算法也是DiskLRUCache
(5)关于重用，除了依赖Http的请求参数 keep-alive通知服务器希望连接之外，还依赖于系统对 http.keepalive的设定。而同一个url默认最多只能有5个连接。
