OkHttpClient mOkHttpClient = new OkHttpClient();

OkHttpClient.Builder builder = new OkHttpClient.Builder().connectTimeout().writeTimeout().readTimeout().cache().addInterceptor().connectionPool().dns()...;OkHttpClient   mOkHttpClient = builder.build();

public OkHttpClient() {this(new Builder());}
public Builder newBuilder() {return new Builder(this);}public static final class Builder {public Builder() {dispatcher = new Dispatcher(); //请求的调度器protocols = DEFAULT_PROTOCOLS; // 默认支持的协议connectionSpecs = DEFAULT_CONNECTION_SPECS; // 默认连接配置eventListenerFactory = EventListener.factory(EventListener.NONE); // 对于请求和回调的监听proxySelector = ProxySelector.getDefault(); // 代理服务器的选择cookieJar = CookieJar.NO_COOKIES; // 默认没有 Cookie socketFactory = SocketFactory.getDefault(); // Socket 的工厂hostnameVerifier = OkHostnameVerifier.INSTANCE; //主机名认证certificatePinner = CertificatePinner.DEFAULT; // 安全认证相关的配置proxyAuthenticator = Authenticator.NONE; // 安全认证相关的配置authenticator = Authenticator.NONE; // 安全认证相关的配置connectionPool = new ConnectionPool();  //连接池dns = Dns.SYSTEM;   // DNS 域名解析系统followSslRedirects = true; // 允许SSL重定向followRedirects = true; //  允许重定向retryOnConnectionFailure = true;  // 允许失败重连connectTimeout = 10_000;   // 连接超时 ， 10 sreadTimeout = 10_000;   //  读取 超时 ，10 s writeTimeout = 10_000;  // 写入超时，10spingInterval = 0; //ping  间隔时间，这是 WebSocket 长连接的活性检测的间隔时间 }

Request.Builder requestBuilder = new Request.Builder().url(url);requestBuilder.method("GET", null);Request request = requestBuilder.build();

public final class Request {final HttpUrl url;final String method;final Headers headers;final RequestBody body;final Object tag;private volatile CacheControl cacheControl; // Lazily initialized.Request(Builder builder) {this.url = builder.url;this.method = builder.method;this.headers = builder.headers.build();this.body = builder.body;this.tag = builder.tag != null ? builder.tag : this;}

okHttpClient.newCall(request).execute();

okHttpClient.newCall(request).enqueue(new Callback() {@Overridepublic void onFailure(Call call, IOException e) {}@Overridepublic void onResponse(Call call, Response response) throws IOException {}});

public final class Dispatcher {private int maxRequests = 64;  //最大并发的请求数 为 64 private int maxRequestsPerHost = 5;  //每个主机最大请求数为 默认为 5 private Runnable idleCallback;/** Executes calls. Created lazily. */private ExecutorService executorService;  //请求处理的线程池/** Ready async calls in the order they'll be run. */private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();   //异步处理的准备队列/** Running asynchronous calls. Includes canceled calls that haven't finished yet. */private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>(); //异步处理的执行队列/** Running synchronous calls. Includes canceled calls that haven't finished yet. */private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();  //同步处理的执行队列}

// okHttpClient 类中@Override public Call newCall(Request request) {return new RealCall(this, request, false /* for web socket */);}
// RealCall 类中，实现 Call 接口final class RealCall implements Call {...
@Override public Response execute() throws IOException {synchronized (this) {if (executed) throw new IllegalStateException("Already Executed");executed = true;}captureCallStackTrace();try {client.dispatcher().executed(this);  //添加到请求队列中Response result = getResponseWithInterceptorChain();  //拦截链，对应的一系列方法调用包括请求，得到响应后返回if (result == null) throw new IOException("Canceled");return result;} finally {client.dispatcher().finished(this); //结束这个请求}}
}
//Call 接口
public interface Call extends Cloneable {Request request();Response execute() throws IOException;void enqueue(Callback responseCallback);boolean isExecuted();boolean isCanceled();Call clone();interface Factory {Call newCall(Request request);}
}

/** Used by {@code Call#execute} to signal it is in-flight. */synchronized void executed(RealCall call) {runningSyncCalls.add(call);}
/** 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(); //对于 executed 方式，这里为false 所以不执行 promoteCallsrunningCallsCount = runningCallsCount();idleCallback = this.idleCallback;}if (runningCallsCount == 0 && idleCallback != null) {idleCallback.run();}}

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

public abstract class NamedRunnable implements Runnable {protected final String name;public NamedRunnable(String format, Object... args) {this.name = Util.format(format, args);}@Override public final void run() {String oldName = Thread.currentThread().getName();Thread.currentThread().setName(name);try {execute();} finally {Thread.currentThread().setName(oldName);}}protected abstract void execute();
}

// 实现 Runnable 接口
final class AsyncCall extends NamedRunnable {private final Callback responseCallback;AsyncCall(Callback responseCallback) {this.responseCallback = responseCallback;}@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 {responseCallback.onFailure(RealCall.this, e);}} finally {client.dispatcher().finished(this);  //结束这个 Call }}}

synchronized void enqueue(AsyncCall call) {if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {runningAsyncCalls.add(call);executorService().execute(call);} else {readyAsyncCalls.add(call);}}/** Returns the number of running calls that share a host with {@code call}. */private int runningCallsForHost(AsyncCall call) {int result = 0;for (AsyncCall c : runningAsyncCalls) {if (c.host().equals(call.host())) result++;}return result;}

/** Used by {@code AsyncCall#run} to signal completion. */void finished(AsyncCall call) {finished(runningAsyncCalls, call, true);}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();  因为 为 true 所以还要执行 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.}}

Response 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);return chain.proceed(originalRequest);}

public final class RealInterceptorChain implements Interceptor.Chain {...@Override public Response proceed(Request request) throws IOException {return proceed(request, streamAllocation, httpCodec, connection);}...public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,....// Call the next interceptor in the chain.// 获取下一个拦截器，并调用其 intercept 方法。RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec, connection, index + 1, request);Interceptor interceptor = interceptors.get(index);Response response = interceptor.intercept(next);....return response;}
}

public final class RetryAndFollowUpInterceptor implements Interceptor {@Override public Response intercept(Chain chain) throws IOException {Request request = chain.request();// 对请求前的处理streamAllocation = new StreamAllocation(client.connectionPool(), createAddress(request.url()), callStackTrace);int followUpCount = 0;Response priorResponse = null;while (true) {if (canceled) {streamAllocation.release();throw new IOException("Canceled");}Response response = null;boolean releaseConnection = true;try {//这里再去调用拦截器链的 proceed ，response = ((RealInterceptorChain) chain).proceed(request, streamAllocation, null, null);releaseConnection = false;}// 下面就是对 得到响应后的处理，这里就省略。}

/*** This interceptor recovers from failures and follows redirects as necessary. It may throw an* {@link IOException} if the call was canceled.*/
public final class RetryAndFollowUpInterceptor implements Interceptor {/**

/*** Bridges from application code to network code. First it builds a network request from a user* request. Then it proceeds to call the network. Finally it builds a user response from the network* response.*/
public final class BridgeInterceptor implements Interceptor {

@Override public Response intercept(Chain chain) throws IOException {Request userRequest = chain.request();Request.Builder requestBuilder = userRequest.newBuilder();RequestBody body = userRequest.body();if (body != null) {MediaType contentType = body.contentType();if (contentType != null) {requestBuilder.header("Content-Type", contentType.toString());}long contentLength = body.contentLength();if (contentLength != -1) {requestBuilder.header("Content-Length", Long.toString(contentLength));requestBuilder.removeHeader("Transfer-Encoding");} else {requestBuilder.header("Transfer-Encoding", "chunked");requestBuilder.removeHeader("Content-Length");}}if (userRequest.header("Host") == null) {requestBuilder.header("Host", hostHeader(userRequest.url(), false));}if (userRequest.header("Connection") == null) {requestBuilder.header("Connection", "Keep-Alive");}// If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing// the transfer stream.boolean transparentGzip = false;if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {transparentGzip = true;requestBuilder.header("Accept-Encoding", "gzip");}List<Cookie> cookies = cookieJar.loadForRequest(userRequest.url());if (!cookies.isEmpty()) {requestBuilder.header("Cookie", cookieHeader(cookies));}if (userRequest.header("User-Agent") == null) {requestBuilder.header("User-Agent", Version.userAgent());}//到这里网络请求前拦截的动作就已经完成，主要有：// 设置内容长度，内容编码// 设置gzip压缩//添加cookie//设置其他请求头首部，如 User-Agent,Host,Keep-alive 等。其中 Keep-Alive 是实现多路复用的必要步骤//下面就到下一个拦截器去获取真正的网络响应。Response networkResponse = chain.proceed(requestBuilder.build());// 获取网络的响应后，在这里也进行拦截，做一些处理，比如压缩，添加响应头等。HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());Response.Builder responseBuilder = networkResponse.newBuilder().request(userRequest);if (transparentGzip&& "gzip".equalsIgnoreCase(networkResponse.header("Content-Encoding"))&& HttpHeaders.hasBody(networkResponse)) {GzipSource responseBody = new GzipSource(networkResponse.body().source());Headers strippedHeaders = networkResponse.headers().newBuilder().removeAll("Content-Encoding").removeAll("Content-Length").build();responseBuilder.headers(strippedHeaders);responseBuilder.body(new RealResponseBody(strippedHeaders, Okio.buffer(responseBody)));}return responseBuilder.build();}

/** Serves requests from the cache and writes responses to the cache. */
public final class CacheInterceptor implements Interceptor {

@Override public Response intercept(Chain chain) throws IOException {Response cacheCandidate = cache != null? cache.get(chain.request()): null;long now = System.currentTimeMillis();// 获取定义响应读取的策略，分为仅从网络获取响应，仅从缓存获取响应，或者网络和缓存配合。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.}// If we're forbidden from using the network and the cache is insufficient, fail.//如果指定仅从缓存获取但是缓存没有就返回一个  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 we don't need the network, we're done.//如果没有指定从网络获取并且缓存不为空，那么就将缓存返回。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());}}// If we have a cache response too, then we're doing a conditional get.//必要的时候更新缓存，并返回if (cacheResponse != null) {if (networkResponse.code() == HTTP_NOT_MODIFIED) {Response response = cacheResponse.newBuilder().headers(combine(cacheResponse.headers(), networkResponse.headers())).sentRequestAtMillis(networkResponse.sentRequestAtMillis()).receivedResponseAtMillis(networkResponse.receivedResponseAtMillis()).cacheResponse(stripBody(cacheResponse)).networkResponse(stripBody(networkResponse)).build();networkResponse.body().close();// Update the cache after combining headers but before stripping the// Content-Encoding header (as performed by initContentStream()).cache.trackConditionalCacheHit();cache.update(cacheResponse, response);return response;} else {closeQuietly(cacheResponse.body());}}//如果没有缓存就将这个响应写入缓存。Response response = networkResponse.newBuilder().cacheResponse(stripBody(cacheResponse)).networkResponse(stripBody(networkResponse)).build();if (cache != null) {if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {// Offer this request to the cache.CacheRequest cacheRequest = cache.put(response);return cacheWritingResponse(cacheRequest, response);}if (HttpMethod.invalidatesCache(networkRequest.method())) {try {cache.remove(networkRequest);} catch (IOException ignored) {// The cache cannot be written.}}}return response;}

public final class Cache implements Closeable, Flushable {....final InternalCache internalCache = new InternalCache() {@Override public Response get(Request request) throws IOException {return Cache.this.get(request);}@Override public CacheRequest put(Response response) throws IOException {return Cache.this.put(response);}@Override public void remove(Request request) throws IOException {Cache.this.remove(request);}@Override public void update(Response cached, Response network) {Cache.this.update(cached, network);}@Override public void trackConditionalCacheHit() {Cache.this.trackConditionalCacheHit();}@Override public void trackResponse(CacheStrategy cacheStrategy) {Cache.this.trackResponse(cacheStrategy);}};// 缓存的核心类final DiskLruCache cache;}

/** Opens a connection to the target server and proceeds to the next interceptor. */
public final class ConnectInterceptor implements Interceptor {

@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);}

public HttpCodec newStream(OkHttpClient client, boolean doExtensiveHealthChecks) {try {找到一个合适的连接，可能复用已有连接也可能是重新创建的连接，返回的连接由连接池负责决定。RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,writeTimeout, connectionRetryEnabled, doExtensiveHealthChecks);HttpCodec resultCodec = resultConnection.newCodec(client, this);....}

public final class ConnectionPool {private static final Executor executor = new ThreadPoolExecutor(0 /* corePoolSize */,Integer.MAX_VALUE /* maximumPoolSize */, 60L /* keepAliveTime */, TimeUnit.SECONDS,new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp ConnectionPool", true));/** The maximum number of idle connections for each address. */private final int maxIdleConnections;private final long keepAliveDurationNs;private final Runnable cleanupRunnable = new Runnable() {@Override public void run() {......}};private final Deque<RealConnection> connections = new ArrayDeque<>();final RouteDatabase routeDatabase = new RouteDatabase();boolean cleanupRunning;....../***返回符合要求的可重用连接，如果没有返回NULL*/RealConnection get(Address address, StreamAllocation streamAllocation, Route route) {......}/** 去除重复连接。主要针对多路复用场景下，一个 address 只需要一个连接*/Socket deduplicate(Address address, StreamAllocation streamAllocation) {......}/** 将连接加入连接池*/void put(RealConnection connection) {......}/** 当有连接空闲时唤起cleanup线程清洗连接池*/boolean connectionBecameIdle(RealConnection connection) {......}/*** 扫描连接池，清除空闲连接*/long cleanup(long now) {......}/** 标记泄露连接*/private int pruneAndGetAllocationCount(RealConnection connection, long now) {......}
}

RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,writeTimeout, connectionRetryEnabled, doExtensiveHealthChecks);
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;}
/*** 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");// Attempt to use an already-allocated connection.RealConnection allocatedConnection = this.connection;if (allocatedConnection != null && !allocatedConnection.noNewStreams) {return allocatedConnection;}// Attempt to get a connection from the pool.Internal.instance.get(connectionPool, address, this, null);if (connection != null) {return connection;}selectedRoute = route;}// If we need a route, make one. This is a blocking operation.if (selectedRoute == null) {selectedRoute = routeSelector.next();}RealConnection result;synchronized (connectionPool) {if (canceled) throw new IOException("Canceled");// Now that we have an IP address, make another attempt at getting a connection from the pool.// This could match due to connection coalescing.Internal.instance.get(connectionPool, address, this, selectedRoute);if (connection != null) return connection;// Create a connection and assign it to this allocation immediately. This makes it possible// for an asynchronous cancel() to interrupt the handshake we're about to do.route = selectedRoute;refusedStreamCount = 0;result = new RealConnection(connectionPool, selectedRoute);acquire(result);}// Do TCP + TLS handshakes. This is a blocking operation.result.connect(connectTimeout, readTimeout, writeTimeout, connectionRetryEnabled);routeDatabase().connected(result.route());Socket socket = null;synchronized (connectionPool) {// Pool the connection.Internal.instance.put(connectionPool, result);// If another multiplexed connection to the same address was created concurrently, then// release this connection and acquire that one.if (result.isMultiplexed()) {socket = Internal.instance.deduplicate(connectionPool, address, this);result = connection;}}closeQuietly(socket);return result;}

/** This is the last interceptor in the chain. It makes a network call to the server. */
public final class CallServerInterceptor implements Interceptor {