gradle依賴

implementation ’com.squareup.okhttp3:okhttp:3.11.0’

implementation ’com.squareup.okio:okio:1.15.0’

/** *這里拿get請求來 * 異步的get請求 */ public void okhttpAsyn() {//設置超時的時間OkHttpClient.Builder builder = new OkHttpClient.Builder().connectTimeout(15, TimeUnit.SECONDS).writeTimeout(20, TimeUnit.SECONDS).readTimeout(20, TimeUnit.SECONDS);OkHttpClient okHttpClient = builder.build();Request request = new Request.Builder().get() //設置請求模式.url('https://www.baidu.com/').build();Call call = okHttpClient.newCall(request);call.enqueue(new Callback() { @Override public void onFailure(Call call, IOException e) {Log.d('MainActivity', '-----------onFailure-----------'); } @Override public void onResponse(Call call, Response response) throws IOException {Log.d('MainActivity', '----onResponse----' + response.body().toString());runOnUiThread(new Runnable() { @Override public void run() {Toast.makeText(MainActivity.this, '請求成功', Toast.LENGTH_LONG).show(); }}); }}); }OkHttp源碼分析

從OkHttp的基本使用中，我們看到，通過okHttpClient.newCall()方法，拿到這個call對象，我們看看newCall是怎么走的

/** * Prepares the {@code request} to be executed at some point in the future. */ @Override public Call newCall(Request request) { return RealCall.newRealCall(this, request, false /* for web socket */); } static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) { // Safely publish the Call instance to the EventListener. RealCall call = new RealCall(client, originalRequest, forWebSocket); call.eventListener = client.eventListenerFactory().create(call); return call; }

從這里的源碼知道，okHttpClient.newCall()實際上返回的是RealCall對象，而call.enqueue()，實際上是調用的了RealCall中的enqueue()方法，我們看看enqueue()方法方法怎么走。

@Override public void enqueue(Callback responseCallback) { synchronized (this) { if (executed) throw new IllegalStateException('Already Executed'); executed = true; } captureCallStackTrace(); eventListener.callStart(this); client.dispatcher().enqueue(new AsyncCall(responseCallback)); }

可以看到client.dispatcher().enqueue(new AsyncCall(responseCallback));這句代碼，也就是說，最終是有的請求是有dispatcher來完成，我們看看dispatcher。

/* * Copyright (C) 2013 Square, Inc. * * Licensed under the Apache License, Version 2.0 (the 'License'); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an 'AS IS' BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package okhttp3;import java.util.ArrayDeque;import java.util.ArrayList;import java.util.Collections;import java.util.Deque;import java.util.Iterator;import java.util.List;import java.util.concurrent.ExecutorService;import java.util.concurrent.SynchronousQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;import javax.annotation.Nullable;import okhttp3.RealCall.AsyncCall;import okhttp3.internal.Util;/** * Policy on when async requests are executed. * * <p>Each dispatcher uses an {@link ExecutorService} to run calls internally. If you supply your * own executor, it should be able to run {@linkplain #getMaxRequests the configured maximum} number * of calls concurrently. */public final class Dispatcher { //最大請求的并發數 private int maxRequests = 64; //每個主機最大請求數 private int maxRequestsPerHost = 5; private @Nullable Runnable idleCallback; /** 消費線程池 */ private @Nullable ExecutorService executorService; /** 準備運行的異步請求隊列 */ private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>(); /** 正在運行的異步請求隊列 */ private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>(); /** 正在運行的同步請求隊列 */ private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>(); /** 構造方法 */ public Dispatcher(ExecutorService executorService) { this.executorService = executorService; } public Dispatcher() { } public synchronized ExecutorService executorService() { if (executorService == null) { executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), Util.threadFactory('OkHttp Dispatcher', false)); } return executorService; } /** * *設置并發執行最大的請求數量 * <p>If more than {@code maxRequests} requests are in flight when this is invoked, those requests * will remain in flight. */ public synchronized void setMaxRequests(int maxRequests) { if (maxRequests < 1) { throw new IllegalArgumentException('max < 1: ' + maxRequests); } this.maxRequests = maxRequests; promoteCalls(); } //獲取到最大請求的數量 public synchronized int getMaxRequests() { return maxRequests; } /** * 設置每個主機并發執行的請求的最大數量 * <p>If more than {@code maxRequestsPerHost} requests are in flight when this is invoked, those * requests will remain in flight. * * <p>WebSocket connections to hosts <b>do not</b> count against this limit. */ public synchronized void setMaxRequestsPerHost(int maxRequestsPerHost) { if (maxRequestsPerHost < 1) { throw new IllegalArgumentException('max < 1: ' + maxRequestsPerHost); } this.maxRequestsPerHost = maxRequestsPerHost; promoteCalls(); } //獲取每個主機最大并發數量 public synchronized int getMaxRequestsPerHost() { return maxRequestsPerHost; } /** * Set a callback to be invoked each time the dispatcher becomes idle (when the number of running * calls returns to zero). * * <p>Note: The time at which a {@linkplain Call call} is considered idle is different depending * on whether it was run {@linkplain Call#enqueue(Callback) asynchronously} or * {@linkplain Call#execute() synchronously}. Asynchronous calls become idle after the * {@link Callback#onResponse onResponse} or {@link Callback#onFailure onFailure} callback has * returned. Synchronous calls become idle once {@link Call#execute() execute()} returns. This * means that if you are doing synchronous calls the network layer will not truly be idle until * every returned {@link Response} has been closed. */ public synchronized void setIdleCallback(@Nullable Runnable idleCallback) { this.idleCallback = idleCallback; } synchronized void enqueue(AsyncCall call) { if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) { runningAsyncCalls.add(call); executorService().execute(call); } else { readyAsyncCalls.add(call); } } /** * Cancel all calls currently enqueued or executing. Includes calls executed both {@linkplain * Call#execute() synchronously} and {@linkplain Call#enqueue asynchronously}. */ public synchronized void cancelAll() { for (AsyncCall call : readyAsyncCalls) { call.get().cancel(); } for (AsyncCall call : runningAsyncCalls) { call.get().cancel(); } for (RealCall call : runningSyncCalls) { call.cancel(); } } private void promoteCalls() { if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity. if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote. for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) { AsyncCall call = i.next(); if (runningCallsForHost(call) < maxRequestsPerHost) {i.remove();runningAsyncCalls.add(call);executorService().execute(call); } if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity. } } //----------------省略若干代碼-----------------------}

我們來找到這段代碼

synchronized void enqueue(AsyncCall call) { if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) { runningAsyncCalls.add(call); executorService().execute(call); } else { readyAsyncCalls.add(call); } }

當正在運行的異步請求隊列中的數量小于64并且正在運行的請求主機數小于5時則把請求加載到runningAsyncCalls中并在線程池中執行，否則就再入到readyAsyncCalls中進行緩存等待。而runningAsyncCalls這個請求隊列存放的就是AsyncCall對象，而這個AsyncCall就是RealCall的內部類，也就是說executorService().execute(call);實際上走的是RealCall類中的execute()方法.

@Override protected void execute() { boolean signalledCallback = false; try {Response response = getResponseWithInterceptorChain();if (retryAndFollowUpInterceptor.isCanceled()) { signalledCallback = true; responseCallback.onFailure(RealCall.this, new IOException('Canceled'));} else { signalledCallback = true; responseCallback.onResponse(RealCall.this, response);} } catch (IOException e) {if (signalledCallback) { // Do not signal the callback twice! Platform.get().log(INFO, 'Callback failure for ' + toLoggableString(), e);} else { eventListener.callFailed(RealCall.this, e); responseCallback.onFailure(RealCall.this, e);} } finally {client.dispatcher().finished(this); } }

這部分的代碼，相信很多人都能夠看的明白，無非就是一些成功，失敗的回調，這段代碼，最重要的是esponse response = getResponseWithInterceptorChain();和client.dispatcher().finished(this);我們先來看看client.dispatcher().finished(this);這句代碼是怎么執行的。

/** Used by {@code AsyncCall#run} to signal completion. */ void finished(AsyncCall call) { finished(runningAsyncCalls, call, true); } /** Used by {@code Call#execute} to signal completion. */ void finished(RealCall call) { finished(runningSyncCalls, call, false); } private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) { int runningCallsCount; Runnable idleCallback; synchronized (this) { if (!calls.remove(call)) throw new AssertionError('Call wasn’t in-flight!'); if (promoteCalls) promoteCalls(); runningCallsCount = runningCallsCount(); idleCallback = this.idleCallback; } if (runningCallsCount == 0 && idleCallback != null) { idleCallback.run(); } }private void promoteCalls() { if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity. if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote. for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) { AsyncCall call = i.next(); if (runningCallsForHost(call) < maxRequestsPerHost) {i.remove();runningAsyncCalls.add(call);executorService().execute(call); } if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity. } }

由于client.dispatcher().finished(this);這句代碼是放到finally中執行的，所以無論什么情況，都會執行上面的promoteCalls()方法，而從promoteCalls()方法中可以看出通過遍歷來獲取到下一個請求從而執行下一個網絡請求。

回過頭來，我們看看這一句代碼Response response = getResponseWithInterceptorChain(); 通過getResponseWithInterceptorChain();來獲取到response，然后回調返回。很明顯getResponseWithInterceptorChain()這句代碼里面進行了網絡請求。我們看看是怎么執行的。

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 (!forWebSocket) { interceptors.addAll(client.networkInterceptors()); } interceptors.add(new CallServerInterceptor(forWebSocket)); Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,originalRequest, this, eventListener, client.connectTimeoutMillis(),client.readTimeoutMillis(), client.writeTimeoutMillis()); return chain.proceed(originalRequest); }}

從上面代碼可以知道，緩存，網絡請求，都封裝成攔截器的形式。攔截器主要用來觀察，修改以及可能短路的請求輸出和響應的回來。最后return chain.proceed，而chain是通過new RealInterceptorChain來獲取到的，我們來看看RealInterceptorChain對象，然后找到proceed()方法。

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec, RealConnection connection) throws IOException { if (index >= interceptors.size()) throw new AssertionError(); calls++; // If we already have a stream, confirm that the incoming request will use it. if (this.httpCodec != null && !this.connection.supportsUrl(request.url())) { throw new IllegalStateException('network interceptor ' + interceptors.get(index - 1) + ' must retain the same host and port'); } // If we already have a stream, confirm that this is the only call to chain.proceed(). if (this.httpCodec != null && calls > 1) { throw new IllegalStateException('network interceptor ' + interceptors.get(index - 1) + ' must call proceed() exactly once'); } // 調用下一個攔截器 RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,writeTimeout); Interceptor interceptor = interceptors.get(index); Response response = interceptor.intercept(next); //調用攔截器中的intercept()方法 // Confirm that the next interceptor made its required call to chain.proceed(). if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) { throw new IllegalStateException('network interceptor ' + interceptor + ' must call proceed() exactly once'); } // Confirm that the intercepted response isn’t null. if (response == null) { throw new NullPointerException('interceptor ' + interceptor + ' returned null'); } if (response.body() == null) { throw new IllegalStateException( 'interceptor ' + interceptor + ' returned a response with no body'); } return response; }

從上面的代碼可以看出來，chain.proceed主要是講集合中的攔截器遍歷出來，然后通過調用每一個攔截器中的intercept()方法，然后獲取到response結果，返回。

我們看看CacheInterceptor這個類，找到intercept()方法。

@Override public Response intercept(Chain chain) throws IOException { Response cacheCandidate = cache != null? cache.get(chain.request()): null; long now = System.currentTimeMillis(); //創建CacheStrategy.Factory對象，進行緩存配置 CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get(); //網絡請求 Request networkRequest = strategy.networkRequest; //緩存響應 Response cacheResponse = strategy.cacheResponse; if (cache != null) { //記錄當前請求是網絡發起還是緩存發起 cache.trackResponse(strategy); } if (cacheCandidate != null && cacheResponse == null) { closeQuietly(cacheCandidate.body()); // The cache candidate wasn’t applicable. Close it. } // 不進行網絡請求并且緩存不存在或者過期則返回504錯誤 if (networkRequest == null && cacheResponse == null) { return new Response.Builder() .request(chain.request()) .protocol(Protocol.HTTP_1_1) .code(504) .message('Unsatisfiable Request (only-if-cached)') .body(Util.EMPTY_RESPONSE) .sentRequestAtMillis(-1L) .receivedResponseAtMillis(System.currentTimeMillis()) .build(); } // 不進行網絡請求，而且緩存可以使用，直接返回緩存 if (networkRequest == null) { return cacheResponse.newBuilder() .cacheResponse(stripBody(cacheResponse)) .build(); } //進行網絡請求 Response networkResponse = null; try { networkResponse = chain.proceed(networkRequest); } finally { // If we’re crashing on I/O or otherwise, don’t leak the cache body. if (networkResponse == null && cacheCandidate != null) {closeQuietly(cacheCandidate.body()); } } //---------省略若干代碼------------- return response; }

上面我做了很多注釋，基本的流程是有緩存就取緩存里面的，沒有緩存就請求網絡。我們來看看網絡請求的類CallServerInterceptor

/* * Copyright (C) 2016 Square, Inc. * * Licensed under the Apache License, Version 2.0 (the 'License'); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an 'AS IS' BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package okhttp3.internal.http;import java.io.IOException;import java.net.ProtocolException;import okhttp3.Interceptor;import okhttp3.Request;import okhttp3.Response;import okhttp3.internal.Util;import okhttp3.internal.connection.RealConnection;import okhttp3.internal.connection.StreamAllocation;import okio.Buffer;import okio.BufferedSink;import okio.ForwardingSink;import okio.Okio;import okio.Sink;/** This is the last interceptor in the chain. It makes a network call to the server. */public final class CallServerInterceptor implements Interceptor { private final boolean forWebSocket; public CallServerInterceptor(boolean forWebSocket) { this.forWebSocket = forWebSocket; } @Override public Response intercept(Chain chain) throws IOException { RealInterceptorChain realChain = (RealInterceptorChain) chain; HttpCodec httpCodec = realChain.httpStream(); StreamAllocation streamAllocation = realChain.streamAllocation(); RealConnection connection = (RealConnection) realChain.connection(); Request request = realChain.request(); long sentRequestMillis = System.currentTimeMillis(); realChain.eventListener().requestHeadersStart(realChain.call()); httpCodec.writeRequestHeaders(request); realChain.eventListener().requestHeadersEnd(realChain.call(), request); Response.Builder responseBuilder = null; if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) { // If there’s a 'Expect: 100-continue' header on the request, wait for a 'HTTP/1.1 100 // Continue' response before transmitting the request body. If we don’t get that, return // what we did get (such as a 4xx response) without ever transmitting the request body. if ('100-continue'.equalsIgnoreCase(request.header('Expect'))) {httpCodec.flushRequest();realChain.eventListener().responseHeadersStart(realChain.call());responseBuilder = httpCodec.readResponseHeaders(true); } if (responseBuilder == null) {// Write the request body if the 'Expect: 100-continue' expectation was met.realChain.eventListener().requestBodyStart(realChain.call());long contentLength = request.body().contentLength();CountingSink requestBodyOut = new CountingSink(httpCodec.createRequestBody(request, contentLength));BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);request.body().writeTo(bufferedRequestBody);bufferedRequestBody.close();realChain.eventListener() .requestBodyEnd(realChain.call(), requestBodyOut.successfulCount); } else if (!connection.isMultiplexed()) {// If the 'Expect: 100-continue' expectation wasn’t met, prevent the HTTP/1 connection// from being reused. Otherwise we’re still obligated to transmit the request body to// leave the connection in a consistent state.streamAllocation.noNewStreams(); } } httpCodec.finishRequest(); if (responseBuilder == null) { realChain.eventListener().responseHeadersStart(realChain.call()); responseBuilder = httpCodec.readResponseHeaders(false); } Response response = responseBuilder.request(request).handshake(streamAllocation.connection().handshake()).sentRequestAtMillis(sentRequestMillis).receivedResponseAtMillis(System.currentTimeMillis()).build(); int code = response.code(); if (code == 100) { // server sent a 100-continue even though we did not request one. // try again to read the actual response responseBuilder = httpCodec.readResponseHeaders(false); response = responseBuilder .request(request) .handshake(streamAllocation.connection().handshake()) .sentRequestAtMillis(sentRequestMillis) .receivedResponseAtMillis(System.currentTimeMillis()) .build(); code = response.code(); } realChain.eventListener() .responseHeadersEnd(realChain.call(), response); if (forWebSocket && code == 101) { // Connection is upgrading, but we need to ensure interceptors see a non-null response body. response = response.newBuilder() .body(Util.EMPTY_RESPONSE) .build(); } else { response = response.newBuilder() .body(httpCodec.openResponseBody(response)) .build(); } if ('close'.equalsIgnoreCase(response.request().header('Connection'))|| 'close'.equalsIgnoreCase(response.header('Connection'))) { streamAllocation.noNewStreams(); } if ((code == 204 || code == 205) && response.body().contentLength() > 0) { throw new ProtocolException( 'HTTP ' + code + ' had non-zero Content-Length: ' + response.body().contentLength()); } return response; }}

到這里，基本上okhttp的整個流程就出來了，當然，這里只是一個整體的大概流程，如果要摳的很細，那就不是一篇文章能夠說明的了了。現在回過頭來再看一眼流程圖，是不是感覺特別明朗了。

以上就是解析Android框架之OkHttp3源碼的詳細內容，更多關于Android框架之OkHttp3源碼的資料請關注好吧啦網其它相關文章！