1 介紹
在我們所處的互聯網世界中，HTTP協議算得上是使用最廣泛的網絡協議。
OKHttp是一款高效的HTTP客戶端，支持同一地址的鏈接共享同一個socket，通過連接池來減小響應延遲，還有透明的GZIP壓縮，請求緩存等優勢。
如果您的服務器配置了多個IP地址，當第一個IP連接失敗的時候，OkHttp會自動嘗試下一個IP。OkHttp還處理了代理服務器問題和SSL握手失敗問題。
值得一提的是：Android4.4原生的HttpUrlConnection底層已經替換成了okhttp實現了。
public final class URL implements Serializable {
...
public URLConnection openConnection() throws IOException {
return this.handler.openConnection(this);
}
}
這個handler，在源碼中判斷到如果是HTTP協議，就會創建HtppHandler：
public final class HttpHandler extends URLStreamHandler {
@Override protected URLConnection openConnection(URL url) throws IOException {
// 調用了OKHttpClient()的方法
return new OkHttpClient().open(url);
}
@Override protected URLConnection openConnection(URL url, Proxy proxy) throws IOException {
if (url == null || proxy == null) {
throw new IllegalArgumentException("url == null || proxy == null");
}
return new OkHttpClient().setProxy(proxy).open(url);
}
@Override protected int getDefaultPort() {
return 80;
}
}
2 基本使用方式
在OKHttp，每次網絡請求就是一個Request，我們在Request里填寫我們需要的url，header等其他參數，再通過Request構造出Call，Call內部去請求服務器，得到回復，并將結果告訴調用者。同時okhttp提供了同步和異步兩種方式進行網絡操作。
2.1 同步
OkHttpClient client = new OkHttpClient();
String run(String url) throws IOException {
Request request = new Request.Builder()
.url(url)
.build();
Response response = client.newCall(request).execute();
return response.body().string();
}
直接execute執行得到Response，通過Response可以得到code,message等信息。android本身是不允許在UI線程做網絡請求操作，需要在子線程中執行。
2.2 異步
Request request = new Request.Builder()
.url("http://www.baidu.com")
.build();
client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Request request, IOException e) {
}
@Override
public void onResponse(Response response) throws IOException {
//NOT UI Thread
if(response.isSuccessful()){
System.out.println(response.code());
System.out.println(response.body().string());
}
}
});
在同步的基礎上講execute改成enqueue，并且傳入回調接口，但接口回調回來的代碼是在非UI線程的，因此如果有更新UI的操作必須切到主線程。
3 整體結構
3.1 處理網絡響應的攔截器機制
無論是同步的call.execute()還是異步的call.enqueue()，最后都是殊途同歸地走到call.getResponseWithInterceptorChain(boolean forWebSocket)方法。
private Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List<Interceptor> interceptors = new ArrayList<>();
interceptors.addAll(client.interceptors());
interceptors.add(retryAndFollowUpInterceptor);
interceptors.add(new BridgeInterceptor(client.cookieJar()));
interceptors.add(new CacheInterceptor(client.internalCache()));
interceptors.add(new ConnectInterceptor(client));
if (!retryAndFollowUpInterceptor.isForWebSocket()) {
interceptors.addAll(client.networkInterceptors());
}
interceptors.add(new CallServerInterceptor(
retryAndFollowUpInterceptor.isForWebSocket()));
Interceptor.Chain chain = new RealInterceptorChain(
interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);
}
可以發現okhttp在處理網絡響應時采用的是攔截器機制。okhttp用ArrayList對interceptors進行管理，interceptors將依次被調用。
如上圖：
橙色框內是okhttp自帶的Interceptors的實現類，它們都是在
call.getResponseWithInterceptorChain()中被添加入 InterceptorChain中，實際上這幾個Interceptor都是在okhttp3后才被引入，它們非常重要，負責了重連、組裝請求頭部、讀/寫緩存、建立socket連接、向服務器發送請求/接收響應的全部過程。在okhttp3之前，這些行為都封裝在HttpEngine類中。okhttp3之后，HttpEngine已經被刪去，取而代之的是這5個Interceptor，可以說一次網絡請求中的細節被解耦放在不同的Interceptor中，不同Interceptor只負責自己的那一環節工作（對Request或者Response進行獲取/處理），使得攔截器模式完全貫穿整個網絡請求。
-
用戶可以添加自定義的Interceptor，okhttp把攔截器分為應用攔截器和網絡攔截器
public class OkHttpClient implements Cloneable, Call.Factory { final List<Interceptor> interceptors; final List<Interceptor> networkInterceptors; ...... }- 調用OkHttpClient.Builder的
addInterceptor()可以添加應用攔截器，只會被調用一次，可以處理網絡請求回來的最終Response - 調用
addNetworkInterceptor()可以添加network攔截器，處理所有的網絡響應（一次請求如果發生了redirect ，那么這個攔截器的邏輯可能會被調用兩次）
- 調用OkHttpClient.Builder的
Interceptor解析
由上面的分析可以知道，okhttp框架內自帶了5個Interceptor的實現:
- RetryAndFollowUpInterceptor，重試那些失敗或者redirect的請求。
- BridgeInterceptor，請求之前對響應頭做了一些檢查，并添加一些頭，然后在請求之后對響應做一些處理（gzip解壓or設置cookie）。
- CacheInterceptor，根據用戶是否有設置cache，如果有的話，則從用戶的cache中獲取當前請求的緩存。
- ConnectInterceptor，復用連接池中的連接，如果沒有就與服務器建立新的socket連接。
- CallServerInterceptor，負責發送請求和獲取響應。
下圖是在Interceptor Chain中的數據流：
官方文檔關于Interceptor的解釋是：
Observes, modifies, and potentially short-circuits requests going out and the corresponding responses coming back in. Typically interceptors add, remove, or transform headers on the request or response.
通過Interceptors可以 觀察，修改或者攔截請求/響應。一般攔截器添加，刪除或修改 請求/響應的header。
Interceptor是一個接口，里面只有一個方法：
public interface Interceptor {
Response intercept(Chain chain) throws IOException;
}
實現Interceptor需要注意兩點（包括源碼內置的Interceptor也是嚴格遵循以下兩點）：
- 通過intercept()方法里的
Chain參數可以拿到request，這樣子就可以對request進行統一的修改（例如BridgeInterceptor對所有request的頭部進行了設置），或者根據request去做一些事情。 - 在intercept()方法中通過
chain.proceed(request)得到Response，從而攔截了網絡響應進行修改，或者根據response去做一些事情。
4 關鍵代碼
以下是HTTP客戶端向服務器發送報文的過程：
- 從URL中解析出服務器的IP地址和端口號
- 在客戶端和服務器之間建立一條TCP/IP連接
- 開始傳輸HTTP報文
HTTP是個應用層協議。HTTP無需操心網絡通信的具體細節；它把聯網的細節都交給了通用、可靠的因特網傳輸協議TCP/IP。TCP/IP隱藏了各種網絡和硬件的特點及弱點，使各種類型的計算機和網絡都能夠進行可靠的通信。
簡單來說，HTTP協議位于TCP的上層。HTTP使用TCP來傳輸其報文數據。
如果你使用okhttp請求一個URL，具體的工作如下：
- 框架使用URL和配置好的OkHttpClient創建一個address。此地址指定我們將如何連接到網絡服務器。
- 框架通過address從連接池中取回一個連接。
- 如果沒有在池中找到連接，ok會選擇一個route嘗試連接。這通常意味著使用一個DNS請求， 以獲取服務器的IP地址。如果需要，ok還會選擇一個TLS版本和代理服務器。
- 如果獲取到一個新的route，它會與服務器建立一個直接的socket連接、使用TLS安全通道（基于HTTP代理的HTTPS），或直接TLS連接。它的TLS握手是必要的。
- 開始發送HTTP請求并讀取響應。
如果有連接出現問題，OkHttp將選擇另一條route，然后再試一次。這樣的好處是當服務器地址的一個子集不可達時，OkHttp能夠自動恢復。而且當連接池過期或者TLS版本不受支持時，這種方式非常有用。
一旦響應已經被接收到，該連接將被返回到池中，以便它可以在將來的請求中被重用。連接在池中閑置一段時間后，它會被趕出。
下面就說說這五個步驟的關鍵代碼：
4.1 建立連接 —— ConnectInterceptor
上面所述前四個步驟都在ConnectInterceptor中。
HTTP是建立在TCP協議之上，HTTP協議的瓶頸及其優化技巧都是基于TCP協議本身的特性。比如TCP建立連接時也要在第三次握手時才能捎帶 HTTP 請求報文，達到真正的建立連接，但是這些連接無法復用會導致每次請求都經歷三次握手和慢啟動。
正是由于TCP在建立連接的初期有慢啟動（slow start）的特性，所以連接的重用總是比新建連接性能要好。
而okhttp的一大特點就是通過連接池來減小響應延遲。如果連接池中沒有可用的連接，則會與服務器建立連接，并將socket的io封裝到HttpStream（發送請求和接收response）中，這些都在ConnectInterceptor中完成。
具體在StreamAllocation.findConnection()方法中，下面是具體邏輯：
/**
* 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) {
......
// Attempt to get a connection from the pool.
RealConnection pooledConnection =
Internal.instance.get(connectionPool, address, this);// 1
......
if (selectedRoute == null) {
selectedRoute = routeSelector.next();//2
......
}
RealConnection newConnection = new RealConnection(selectedRoute);//3
......
synchronized (connectionPool) {//4
Internal.instance.put(connectionPool, newConnection);
this.connection = newConnection;
if (canceled) throw new IOException("Canceled");
}
newConnection.connect(connectTimeout, readTimeout, writeTimeout, address.connectionSpecs(),
connectionRetryEnabled);//5
return newConnection;
}
下面具體說說每一步做了什么：
-
線程池中取得連接
RealConnection pooledConnection = pool.get(address, streamAllocation)//StreamAllocation.java RealConnection get(Address address, StreamAllocation streamAllocation) {3 for (RealConnection connection : connections) { if (connection.allocations.size() < connection.allocationLimit && address.equals(connection.route().address)//根據url來命中connection && !connection.noNewStreams) { streamAllocation.acquire(connection);//將可用的連接放入 return connection; } } return null; } -
如果selectedRoute為空，則選擇下一條路由Route
selectedRoute = routeSelector.next();//RouteSelector.java public final class RouteSelector { 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; } 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; } private void resetNextInetSocketAddress(Proxy proxy) throws IOException { ...... List<InetAddress> addresses = address.dns().lookup(socketHost); //調用dns查詢域名對應的ip ... } }瀏覽器需要知道目標服務器的 IP地址和端口號 才能建立連接。將域名解析為 IP地址 的這個系統就是 DNS。
debug_dns.png -
以前面創建的route為參數新建一個RealConnection
RealConnection newConnection = new RealConnection(selectedRoute);public RealConnection(Route route) { this.route = route; } 添加到連接池
public final class ConnectionPool {
void put(RealConnection connection) {
assert (Thread.holdsLock(this));
if (!cleanupRunning) {
cleanupRunning = true;
executor.execute(cleanupRunnable);
//這里很重要，把閑置超過keepAliveDurationNs時間的connection從連接池中移除。
//具體細節看ConnectionPool 的cleanupRunnable里的run()邏輯
}
connections.add(connection);
}
}
- 調用RealConnection的connect()方法，實際上是
buildConnection()構建連接。
//RealConnection.java
private void buildConnection(int connectTimeout, int readTimeout, int writeTimeout,
ConnectionSpecSelector connectionSpecSelector) throws IOException {
connectSocket(connectTimeout, readTimeout); //建立socket連接
establishProtocol(readTimeout, writeTimeout, connectionSpecSelector);
}
調用connectSocket連接socket。
調用establishProtocol根據HTTP協議版本做一些不同的事情：SSL握手等等。
重點來了！ connectSocket(connectTimeout, readTimeout); 里的邏輯實際上是：
public final class RealConnection extends FramedConnection.Listener implements Connection {
public void connectSocket(Socket socket, InetSocketAddress address,
int connectTimeout) throws IOException {
socket.connect(address, connectTimeout); //Http是基于TCP的，自然底層也是建立了socket連接
...
source = Okio.buffer(Okio.source(rawSocket));
sink = Okio.buffer(Okio.sink(rawSocket)); //用Okio封裝了socket的輸入和輸出流
}
public final class Okio {
public static Source source(Socket socket) throws IOException {
if(socket == null) {
throw new IllegalArgumentException("socket == null");
} else {
AsyncTimeout timeout = timeout(socket);
Source source = source((InputStream)socket.getInputStream(), (Timeout)timeout);
return timeout.source(source);
}
}
public static Sink sink(Socket socket) throws IOException {
if(socket == null) {
throw new IllegalArgumentException("socket == null");
} else {
AsyncTimeout timeout = timeout(socket);
Sink sink = sink((OutputStream)socket.getOutputStream(), (Timeout)timeout);
return timeout.sink(sink);
}
}
}
- 構建HttpStream
resultConnection.socket().setSoTimeout(readTimeout);
resultConnection.source.timeout().timeout(readTimeout, MILLISECONDS);
resultConnection.sink.timeout().timeout(writeTimeout, MILLISECONDS);
resultStream = new Http1xStream(
client, this, resultConnection.source, resultConnection.sink);
至此，HttpStream就構建好了，通過它可以發送請求和接收response。
4.2 發送request/接收Response —— CallServerInterceptor
CallServerInterceptor的intercept()方法里 負責發送請求和獲取響應，實際上都是由HttpStream類去完成具體的工作。
Http1XStream
一個socket連接用來發送HTTP/1.1消息，這個類嚴格按照以下生命周期：
-
writeRequestHeaders()發送request header - 打開一個
sink來寫request body，然后關閉sink - readResponseHeaders()讀取response頭部
- 打開一個
source來讀取response body，然后關閉source
4.2.1 writeRequest
HTTP報文是由一行一行的簡單字符串組成的，都是純文本，不是二進制代碼，可以很方便地進行讀寫。
public final class Http1xStream implements HttpStream {
/** Returns bytes of a request header for sending on an HTTP transport. */
public void writeRequest(Headers headers, String requestLine) throws IOException {
if (state != STATE_IDLE) throw new IllegalStateException("state: " + state);
sink.writeUtf8(requestLine).writeUtf8("\r\n");
for (int i = 0, size = headers.size(); i < size; i++) {
sink.writeUtf8(headers.name(i))
.writeUtf8(": ")
.writeUtf8(headers.value(i))
.writeUtf8("\r\n");
}
sink.writeUtf8("\r\n");
state = STATE_OPEN_REQUEST_BODY;
}
}
public final class Headers {
private final String[] namesAndValues;
/** Returns the field at {@code position}. */
public String name(int index) {
return namesAndValues[index * 2];
}
/** Returns the value at {@code index}. */
public String value(int index) {
return namesAndValues[index * 2 + 1];
}
}
4.2.2 readResponse
public final class Http1xStream implements HttpStream {
//讀取Response Header
public Response.Builder readResponse() throws IOException {
......
while (true) {
StatusLine statusLine = StatusLine.parse(source.readUtf8LineStrict());//1 從InputStream上讀入一行數據
Response.Builder responseBuilder = new Response.Builder()
.protocol(statusLine.protocol)
.code(statusLine.code)
.message(statusLine.message)
.headers(readHeaders());
if (statusLine.code != HTTP_CONTINUE) {
state = STATE_OPEN_RESPONSE_BODY;
return responseBuilder;
}
}
}
//讀取Response Body，獲得
@Override public ResponseBody openResponseBody(Response response) throws IOException {
Source source = getTransferStream(response);
return new RealResponseBody(response.headers(), Okio.buffer(source));
}
}
-
解析HTTP報文，得到HTTP協議版本。
public final class StatusLine { public static StatusLine parse(String statusLine/*HTTP/1.1 200 OK*/) throws IOException { // H T T P / 1 . 1 2 0 0 T e m p o r a r y R e d i r e c t // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 // Parse protocol like "HTTP/1.1" followed by a space. int codeStart; Protocol protocol; if (statusLine.startsWith("HTTP/1.")) { .......
-
讀取ResponseHeader
/** Reads headers or trailers. */ public Headers readHeaders() throws IOException { Headers.Builder headers = new Headers.Builder(); // parse the result headers until the first blank line for (String line; (line = source.readUtf8LineStrict()).length() != 0; ) { Internal.instance.addLenient(headers, line); } return headers.build(); }
-
讀取ResponseBody，讀取InputStream獲得byte數組，至此就完全得到了客戶端請求服務端接口 的響應內容。
public abstract class ResponseBody implements Closeable { public final byte[] bytes() throws IOException { ...... try { bytes = source.readByteArray(); } finally { Util.closeQuietly(source); } ...... return bytes; } /** * Returns the response as a string decoded with the charset of the Content-Type header. If that * header is either absent or lacks a charset, this will attempt to decode the response body as * UTF-8. */ public final String string() throws IOException { return new String(bytes(), charset().name()); }
5 總結
從上面關于okhttp發送網絡請求及接受網絡響應的過程的分析，可以發現 okhttp并不是Volley和Retrofit這種二次封裝的網絡框架，而是基于最原始的java socket連接自己去實現了HTTP協議，就連Android源碼也將其收錄在內，堪稱網絡編程的典范。結合HTTP協議相關書籍與okhttp的源碼實踐相結合進行學習，相信可以對HTTP協議有具體且深入的掌握。
