1、okhttp工作的大致流程
- 當我們通過OkhttpClient創建一個Call，并發起同步或異步請求時。
- okhttp會通過Dispatcher對我們所有的RealCall（Call的具體實現類）進行統一管理，并通過execute()及enqueue()方法對同步或異步請求進行處理。
- execute()及enqueue()這兩個方法會最終調用RealCall中的getResponseWithInterceptorChain()方法，從攔截器鏈中獲取返回結果。
- 攔截器鏈中，依次通過RetryAndFollowUpInterceptor（重定向攔截器）、BridgeInterceptor（橋接攔截器）、CacheInterceptor（緩存攔截器）、ConnectInterceptor（連接攔截器）、CallServerInterceptor（網絡攔截器）對請求依次處理，與服務的建立連接后，獲取返回數據，再經過上述攔截器依次處理后，最后將結果返回給調用方。
- 同步請求就是執行請求的操作是阻塞式，直到 HTTP 響應返回。它對應 OKHTTP 中的 execute 方法。
- 異步請求就類似于非阻塞式的請求，它的執行結果一般都是通過接口回調的方式告知調用者。它對應 OKHTTP 中的 enqueue 方法。
OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder()
.url("http://www.test.com")
.build();
Call call = okHttpClient.newCall(request);
//1.異步請求，通過接口回調告知用戶 http 的異步執行結果
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
System.out.println(e.getMessage());
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (response.isSuccessful()) {
System.out.println(response.body().string());
}
}
});
//2.同步請求
Response response = call.execute();
if (response.isSuccessful()) {
System.out.println(response.body().string());
}
2、異步請求實現流程
//get的異步請求
public void getAsync(View view) {
//定義okhttp對象
OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder().url("http://www.test.com").build();
Call call = okHttpClient.newCall(request);
//異步請求：不用創建子線程
//enqueue()并不會阻塞代碼的執行,不需要與服務器請求完成之后,才會執行后面的代碼
//而且enqueue內部會為我們創建子線程
call.enqueue(new Callback() {
@Override
public void onFailure(@NotNull Call call, @NotNull IOException e) {
}
@Override
public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
Log.i("TAG", "onResponse: " + (Looper.getMainLooper().getThread() == Thread.currentThread()));//為false 表示這是在子線程，需要切換到主線程才能操作UI
if (response.isSuccessful()){
Log.i(TAG,"getAsync："+response.body().string());
}
}
});
}
call的異步調用是通過RealCall.enqueue()實現的。而請求結果通過Callback回調到主線程。
（1）RealCall.enqueue()
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
transmitter.callStart();
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}將用戶創建的callback作為參數傳入AsyncCall()構造函數。AsyncCall 繼承于Runnable。
（2）AsyncCall
final class AsyncCall extends NamedRunnable {
private volatile AtomicInteger callsPerHost = new AtomicInteger(0);
...
/**
* 該方法是在dispather需要執行此請求的時候，分配給它線程池，此異步請求便在這個線程池中執行網絡請求。
*/
void executeOn(ExecutorService executorService) {
...
boolean success = false;
try {
//異步的關鍵：將請求放到線程池中執行。
executorService.execute(this);
success = true;
} catch (RejectedExecutionException e) {
...
success = false;
} finally {
if (!success) {
client.dispatcher().finished(this); // 執行失敗會通過Dispatcher進行finished，以后再也不會用此AsyncCall。
}
}
}
@Override protected void execute() {
boolean signalledCallback = false;
transmitter.timeoutEnter();
try {
Response response = getResponseWithInterceptorChain();
signalledCallback = true;
//請求成功時，回調Response給到用戶
responseCallback.onResponse(RealCall.this, response);
} catch (IOException e) {
...
//請求錯誤時，回調錯誤接口給到用戶
responseCallback.onFailure(RealCall.this, e);
} finally {
//結束一次請求。
client.dispatcher().finished(this);
}
}
} AsyncCall繼承于Runnable，它提供了將Call放到線程池執行的能力，實現了請求的異步流程。
（3）Dispatcher.enqueue()
//準備進行異步調用的請求。
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
//正在執行的異步請求。
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
void enqueue(AsyncCall call) {
synchronized (this) {
//將異步請求加入到雙端隊列中
readyAsyncCalls.add(call);
// 尋找是否有同Host的請求，如果有進行復用
if (!call.get().forWebSocket) {
AsyncCall existingCall = findExistingCallWithHost(call.host());
if (existingCall != null) call.reuseCallsPerHostFrom(existingCall);
}
}
//將符合條件的Ready的異步請求轉入runningAsyncCalls，并執行
promoteAndExecute();
}
- 將此請求登記到Dispatcher的預備雙端隊列中。
- 以此次的請求的Host來查找可服用的異步請求，如果存在，進行復用。
- 嘗試將剛剛加入預備隊的請求執行。
（4）Dipatcher.finish()
private <T> void finished(Deque<T> calls, T call) {
Runnable idleCallback;
synchronized (this) {
...
//一個請求完成后，檢查此時是否有在等待執行的請求，并處理。
boolean isRunning = promoteAndExecute();
if (!isRunning && idleCallback != null) {
//通知此時已經沒有異步請求任務
idleCallback.run();
}
}- 調度器結束一次請求。
- 當一個異步任務完成后，調度器會觸發一次預備任務執行流程。讓之前因為最大請求數等限制而不能執行的請求有機會得到執行。
- 通過idleCallback.run()通知此時的調度器空閑狀態。
（5）Dipatcher.promoteAndExecute()
private boolean promoteAndExecute() {
...
List<AsyncCall> executableCalls = new ArrayList<>();
boolean isRunning;
synchronized (this) {
for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
AsyncCall asyncCall = i.next();
//檢查最大請求數限制和
if (runningAsyncCalls.size() >= maxRequests) break;
if (asyncCall.callsPerHost().get() >= maxRequestsPerHost) continue;
//滿足條件，便把預備隊的請求提升到執行隊列。
i.remove();
asyncCall.callsPerHost().incrementAndGet();
executableCalls.add(asyncCall);
runningAsyncCalls.add(asyncCall);
}
isRunning = runningCallsCount() > 0;
}
//將可執行的異步請求放進線程池執行
for (int i = 0, size = executableCalls.size(); i < size; i++) {
AsyncCall asyncCall = executableCalls.get(i);
//
asyncCall.executeOn(executorService());
}
return isRunning;- 該方法是對預備隊列里的請求提升至執行隊列并執行的一次嘗試。
- 如果不能執行，他啟動時機將會延后到其他請求結束。
3、同步請求
public static final MediaType JSON
= MediaType.get("application/json; charset=utf-8");
OkHttpClient client = new OkHttpClient();
String post(String url, String json) throws IOException {
RequestBody body = RequestBody.create(json, JSON);
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
try (Response response = client.newCall(request).execute()) {
return response.body().string();
}
}
- 通過Builder模式構建Request。
- 調用client.newCall()，通過request生成一個Call對象。他的實現類是RealCall。
- 隨后調用RealCall.execute()，進行同步請求。
（1）RealCall.execute()
@Override public Response execute() throws IOException {
synchronized (this) {
// 如果該請求已經執行過，報錯。
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
transmitter.timeoutEnter();
transmitter.callStart();
try {
//獲取 client 里面的調度器 Dispatcher 并記錄這個請求。
client.dispatcher().executed(this);
//通過責任鏈的方式將發起請求并返回結果。這里是同步動作，會阻塞。
return getResponseWithInterceptorChain();
} finally {
//請求完后需要把這個請求從調度器中移走
client.dispatcher().finished(this);
}
}- 判斷Call的合法性。
- 將RealCall傳進Client里面的Dispatcher.executed()里，而Dispatcher是在 OkHttpClient 被的構建函數里被創建并作為成員變量的。
- 開啟責任鏈模式，進行請求相關邏輯。
- 執行完成后，調度器對這個請求進行收尾工作。
（2）Dispatcher.executed()
/** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
（3）RealCall.getResponseWithInterceptorChain()
Response getResponseWithInterceptorChain() throws IOException {
// 將請求的具體邏輯進行分層，并采用責任鏈的方式進行構造。
List<Interceptor> interceptors = new ArrayList<>();
// 用戶自已的請求攔截器
interceptors.addAll(client.interceptors());
//重試和重定向攔截器
interceptors.add(new RetryAndFollowUpInterceptor(client));
//橋攔截器
interceptors.add(new BridgeInterceptor(client.cookieJar()));
//緩存邏輯攔截器
interceptors.add(new CacheInterceptor(client.internalCache()));
//網絡連接邏輯攔截器
interceptors.add(new ConnectInterceptor(client));
if (!forWebSocket) {
interceptors.addAll(client.networkInterceptors());
}
// 網絡請求攔截器，真正網絡通行的地方，這個攔截器處理過后會生成一個Response
interceptors.add(new CallServerInterceptor(forWebSocket));
//依照如上配置，構建出一個請求的處理邏輯責任鏈，特別注意：這條鏈開始于下標位置為的0攔截器。
Interceptor.Chain chain = new RealInterceptorChain(interceptors, transmitter, null, 0,
originalRequest, this, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
boolean calledNoMoreExchanges = false;
try {
//按下處理邏輯鏈條的開關。
Response response = chain.proceed(originalRequest);
if (transmitter.isCanceled()) {
closeQuietly(response);
throw new IOException("Canceled");
}
//返回請求結果
return response;
} catch (IOException e) {
calledNoMoreExchanges = true;
throw transmitter.noMoreExchanges(e);
} finally {
if (!calledNoMoreExchanges) {
transmitter.noMoreExchanges(null);
}
}
}- 將用戶自定義的攔截器先加入集合中。
- 加入一次請求中需要用的攔截器，這些攔截器代表一次完整的網絡請求邏輯被分了幾層以及他們的先后順序。從代碼中我們不難看出他們的流程是：重試/重定向邏輯->網絡橋邏輯->緩存邏輯->建立網絡連接邏輯->網絡通行邏輯。
- 用以上攔截器集合構建出一條邏輯處理的攔截鏈，并將這條鏈需要使用的攔截器下標賦值為0，從第一個開始。
- 調用chain.proceed()啟動這條鏈的處理流程。
- 使用責任鏈的設計模式來處理一次網絡請求中的邏輯可以有效的劃分邏輯層。而前一個攔截器可以根據實際的處理情況來決定下一攔截器是否應該繼續處理。
（4）RealInterceptorChain.proceed()
RealInterceptorChain.java
public Response proceed(Request request, Transmitter transmitter, @Nullable Exchange exchange)
throws IOException {
if (index >= interceptors.size()) throw new AssertionError();
calls++;
...
/**
* index+1：構建出新的攔截鏈，不過新的攔截鏈的處理攔截器是下標為index+1的
* 實現了責任鏈中，處理邏輯的流轉。
*/
RealInterceptorChain next = new RealInterceptorChain(interceptors, transmitter, exchange,
index + 1, request, call, connectTimeout, readTimeout, writeTimeout);
//此時index = 0;所以拿到了第一個攔截器，并且調用他的intercept 方法進行具體邏輯處理。
Interceptor interceptor = interceptors.get(index);
//當前攔截器對網絡請求進行處理。
Response response = interceptor.intercept(next);
// Confirm that the next interceptor made its required call to chain.proceed().
if (exchange != null && index + 1 < interceptors.size() && next.calls != 1) {
throw new IllegalStateException("network interceptor " + interceptor
+ " must call proceed() exactly once");
}
// 省略對response合法性的檢查代碼
...
return response;
}
- 先index+1，構建index指向下一個攔截器的責任鏈。
- 在鏈中取出下標當前index（此時為0）的攔截器，并調用intercept(next)進行此次攔截器邏輯的真正處理。這里注意，傳遞進去的參數正是1中構建出來的next責任鏈。
- 在Interceptor.intercept()方法內部進行自身的邏輯處理以后，會調用next.proceed()進行一次傳遞，由下一個攔截器進行處理。而此次請求也是這樣在各個攔截器中被 處理->傳遞->處理->...->返回結果。
4、異步和同步總結
同步
- RealCall.execute() ?? Dispatcher.execute() ---runningSyncCalls（異步請求執行隊列）添加 call 對象。
- getResponseWithInterceptorChain() 返回 Response 對象。
- Dispatcher.finished()。
異步
- RealCall. enqueue() ?? Dispatcher. enqueue()---readyAsyncCalls（異步請求就緒隊列）添加 call 對象。
- readyAsyncCalls（異步請求就緒隊列），將滿足條件的添加到臨時隊列和runningAsyncCalls （異步請求的執行隊列）。
- getResponseWithInterceptorChain() 返回 Response 對象；。
- Dispatcher.finished()。
