OKHttp学习(一)—OKHttp的工作原理

while (true) {
if (canceled) {
streamAllocation.release();
throw new IOException(“Canceled”);
}
Response response;
boolean releaseConnection = true;
try {
//1.调用下一个拦截器
response = realChain.proceed(request, streamAllocation, null, null);
releaseConnection = false;
} catch (RouteException e) {
// 失败后尝试重新发送请求
if (!recover(e.getLastConnectException(), transmitter, false, request)) {
throw e.getFirstConnectException();
}
continue;
} catch (IOException e) {
// 失败后尝试重新发送请求
boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
if (!recover(e, transmitter, requestSendStarted, request)) throw e;
continue;
}
//…
//2.检测response是否合法
Request followUp = followUpRequest(response);
if (followUp == null) {
if (!forWebSocket) {
streamAllocation.release();
}
//3.返回response，请求完成
return response;
}
//最多尝试20次
if (++followUpCount > MAX_FOLLOW_UPS) {
streamAllocation.release();
throw new ProtocolException("Too many follow-up requests: " + followUpCount);
}
//4.重新设置请求
request = followUp;
priorResponse = response;
}
}

在RetryAndFollowUpInterceptor中我们可以看到请求的重试是由一个无限循环保持的，同时在代码里还限制了请求的次数，最多尝试20次。RetryAndFollowUpInterceptor的具体逻辑是：

1. 开启循环，继续调用下一个拦截器直到返回结果；
2. 当请求内部抛出异常时，判定是否需要重试;如果符合重试条件，则重新发送请求；
3. 通过followUpRequest()方法检查response是否合法，检查逻辑是根据HTTP返回码检测（具体逻辑可以查看通过followUpRequest()方法）。如果合法followUp为null，则返回结果，否则进行下一步；
4. 重新设置request，设置response(用于接下来重新构造response),执行第1步。

BridgeInterceptor

我们看看BridgeInterceptor做了哪些事。

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”);
}
boolean transparentGzip = false;
if (userRequest.header(“Accept-Encoding”) == null && userRequest.header(“Range”) == null) {
transparentGzip = true;
requestBuilder.header(“Accept-Encoding”, “gzip”);
}
List 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());
}
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);
String contentType = networkResponse.header(“Content-Type”);
responseBuilder.body(new RealResponseBody(contentType, -1L, Okio.buffer(responseBody)));
}
return responseBuilder.build();
}

从代码里可以看到，在BridgeInterceptor中出了HTTP的请求头，设置了请求头的各种参数，比如：Content-Type、Connection、User-Agent、GZIP等。

CacheInterceptor

缓存拦截器主要是处理HTTP请求缓存的，通过缓存拦截器可以有效的使用缓存减少网络请求。

public Response intercept(Chain chain) throws IOException {
Response cacheCandidate = cache != null? cache.get(chain.request()): null;//1.取缓存
long now = System.currentTimeMillis();
CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get(); //2.验证缓存
Request networkRequest = strategy.networkRequest;
Response cacheResponse = strategy.cacheResponse; //获取缓存

if (cache != null) {
cache.trackResponse(strategy);
}
// If we’re forbidden from using the network and the cache is insufficient, fail.
//这里表示禁止使用缓存
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.
//3.直接返回缓存
if (networkRequest == null) {
return cacheResponse.newBuilder()
.cacheResponse(stripBody(cacheResponse))
.build();
}
Response networkResponse = null;
try {
//4.没有缓存，执行下一个拦截器
networkResponse = chain.proceed(networkRequest);
}

// 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();
//5.更新缓存
cache.update(cacheResponse, response);
return response;
} else {
closeQuietly(cacheResponse.body());
}
}
//…
if (cache != null) {
if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
// Offer this request to the cache.
//6.保存缓存
CacheRequest cacheRequest = cache.put(response);
return cacheWritingResponse(cacheRequest, response);
}
}
return response;
}

在上面的代码中可以看到，OkHttp首先会取出缓存，然后经过验证处理判断缓存是否可用。流程如下：

1. 根据请求（以Request为键值）取出缓存；
2. 验证缓存是否可用？可用，则直接返回缓存，否则进行下一步；
3. 继续执行下一个拦截器，直到但会结果；
4. 如果之前有缓存，则更新缓存，否则新增缓存。

缓存拦截器主要的工作就是处理缓存，知道了大致流程后，我们接下来分析一下OkHttp是如何管理缓存的。首先我们分析缓存如何获取，在代码中可以看到通过cache.get()得到，我们直接跟代码看。

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

可以看到，缓存是通过InternalCache管理的，而InternalCache是Cache的内部了类，InternalCache又调用了Cache的方法。我们这里只分析一个get()方法。

@Nullable Response get(Request request) {
String key = key(request.url());
DiskLruCache.Snapshot snapshot;
Entry entry;
try {
snapshot = cache.get(key);
if (snapshot == null) {
return null;
}
} catch (IOException e) {
return null;
}
try {
entry = new Entry(snapshot.getSource(ENTRY_METADATA));
} catch (IOException e) {
Util.closeQuietly(snapshot);
return null;
}
Response response = entry.response(snapshot);
//…
return response;
}

可以看到，缓存是通过DiskLruCache管理，那么不难看出OkHttp的缓存使用了LRU算法管理缓存。接下来，我们分析下OkHttp如何验证缓存。

在上面的代码中，缓存最终来自于CacheStrategy。我们直接分析下那里的代码。

private CacheStrategy getCandidate() {
// No cached response.
if (cacheResponse == null) {
//1.没有缓存，直接返回没有缓存
return new CacheStrategy(request, null);
}

if (request.isHttps() && cacheResponse.handshake() == null) {
//2.没有进行TLS握手，直接返回没有缓存
return new CacheStrategy(request, null);
}

if (!isCacheable(cacheResponse, request)) {
//3.判断是否是可用缓存。这里是根据cache-control的属性配置来判断的
return new CacheStrategy(request, null);
}

CacheControl requestCaching = request.cacheControl();
if (requestCaching.noCache() || hasConditions(request)) {
//4.cache-control：no-cache不接受缓存的资源；根据请求头的"If-Modified-Since"或者"If-None-Match"判断，这两个属性需要到服务端验证后才能判断是否使用缓存，所以这里先不使用缓存
return new CacheStrategy(request, null);
}

CacheControl responseCaching = cacheResponse.cacheControl();
if (responseCaching.immutable()) {
//5.cache-control:imutable 表示响应正文不会随时间而改变，这里直接使用缓存
return new CacheStrategy(null, cacheResponse);
}

long ageMillis = cacheResponseAge();
long freshMillis = computeFreshnessLifetime();

if (requestCaching.maxAgeSeconds() != -1) {
freshMillis = Math.min(freshMillis, SECONDS.toMillis(requestCaching.maxAgeSeconds()));
}

long minFreshMillis = 0;
if (requestCaching.minFreshSeconds() != -1) {
minFreshMillis = SECONDS.toMillis(requestCaching.minFreshSeconds());
}

long maxStaleMillis = 0;
if (!responseCaching.mustRevalidate() && requestCaching.maxStaleSeconds() != -1) {
maxStaleMillis = SECONDS.toMillis(requestCaching.maxStaleSeconds());
}

if (!responseCaching.noCache() && ageMillis + minFreshMillis < freshMillis + maxStaleMillis) {
Response.Builder builder = cacheResponse.newBuilder();
if (ageMillis + minFreshMillis >= freshMillis) {
builder.addHeader(“Warning”, “110 HttpURLConnection “Response is stale””);
}
long oneDayMillis = 24 * 60 * 60 * 1000L;
if (ageMillis > oneDayMillis && isFreshnessLifetimeHeuristic()) {
builder.addHeader(“Warning”, “113 HttpURLConnection “Heuristic expiration””);
}
//6.这里根据时间计算缓存是否过期，如果不过期就使用缓存
return new CacheStrategy(null, builder.build());
}

String conditionName;
String conditionValue;
if (etag != null) {
conditionName = “If-None-Match”;
conditionValue = etag;
} else if (lastModified != null) {
conditionName = “If-Modified-Since”;
conditionValue = lastModifiedString;
} else if (servedDate != null) {
conditionName = “If-Modified-Since”;
conditionValue = servedDateString;
} else {
//7.没有缓存验证条件，需要请求服务端
return new CacheStrategy(request, null); // No condition! Make a regular request.
}

Headers.Builder conditionalRequestHeaders = request.headers().newBuilder();
Internal.instance.addLenient(conditionalRequestHeaders, conditionName, conditionValue);

Request conditionalRequest = request.newBuilder()
.headers(conditionalRequestHeaders.build())
.build();
//8.这里将上面的验证条件加入请求头，继续向服务端发起请求
return new CacheStrategy(conditionalRequest, cacheResponse);
}

从上面的代码可以看到，OkHttp经过很多判断才能确定是否使用缓存。判断过程可以总结为：

1. 没有缓存，直接返回没有缓存.
2. HTTPS没有进行TLS握手，直接返回没有缓存.
3. 判断是否是可用缓存。这里是根据cache-control的属性配置来判断的.
4. cache-control：no-cache不接受缓存的资源；根据请求头的"If-Modified-Since"或者"If-None-Match"判断，这两个属性需要到服务端验证后才能判断是否使用缓存，所以这里先不使用缓存.
5. cache-control:imutable 表示响应正文不会随时间而改变，这里直接使用缓存
6. 这里根据时间计算缓存是否过期，如果不过期就使用缓存
7. 没有缓存验证条件，需要请求服务端
8. 将上面的验证条件（“If-None-Match”，“If-Modified-Since”）加入请求头，继续向服务端发起请求

在上面的验证过程中主要通过Cache-Control中的属性判断缓存是否可用，如果可用则直接返回缓存，否则像服务端继续发送请求判断缓存是否过期。

ConnectInterceptor

ConnectInterceptor的作用就是建立一个与服务端的连接。

public Response intercept(Chain chain) throws IOException {
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Request request = realChain.request();
StreamAllocation streamAllocation = realChain.streamAllocation();
boolean doExtensiveHealthChecks = !request.method().equals(“GET”);
HttpCodec httpCodec = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
RealConnection connection = streamAllocation.connection();

return realChain.proceed(request, streamAllocation, httpCodec, connection);
}

在上面的代码中，可以看到连接来自于StreamAllocation的newStream()方法。

public HttpCodec newStream(
OkHttpClient client, Interceptor.Chain chain, boolean doExtensiveHealthChecks) {
int connectTimeout = chain.connectTimeoutMillis();
int readTimeout = chain.readTimeoutMillis();
int writeTimeout = chain.writeTimeoutMillis();
boolean connectionRetryEnabled = client.retryOnConnectionFailure();

try {
RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
writeTimeout, connectionRetryEnabled, doExtensiveHealthChecks);
HttpCodec resultCodec = resultConnection.newCodec(client, chain, this);

synchronized (connectionPool) {
codec = resultCodec;
return resultCodec;
}
} catch (IOException e) {
throw new RouteException(e);
}
}

可以看到在newStream()方法中会继续寻找连接。我们继续分析代码可以看到，OkHttp的连接是维护在一个连接池中的。

private RealConnection findConnection(int connectTimeout, int readTimeout, int writeTimeout,
boolean connectionRetryEnabled) throws IOException {
boolean foundPooledConnection = false;
RealConnection result = null;
Route selectedRoute = null;
Connection releasedConnection;
Socket toClose;
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. We need to be careful here because our
// already-allocated connection may have been restricted from creating new streams.
releasedConnection = this.connection;
toClose = releaseIfNoNewStreams();
if (this.connection != null) {
// We had an already-allocated connection and it’s good.
result = this.connection;
releasedConnection = null;
}
if (!reportedAcquired) {
// If the connection was never reported acquired, don’t report it as released!
releasedConnection = null;
}

if (result == null) {
// Attempt to get a connection from the pool.
Internal.instance.get(connectionPool, address, this, null);
if (connection != null) {
foundPooledConnection = true;
result = connection;
} else {
selectedRoute = route;
}
}
}
closeQuietly(toClose);

if (releasedConnection != null) {
eventListener.connectionReleased(call, releasedConnection);
}
if (foundPooledConnection) {
eventListener.connectionAcquired(call, result);
}
if (result != null) {
// If we found an already-allocated or pooled connection, we’re done.
return result;
}

// If we need a route selection, make one. This is a blocking operation.
boolean newRouteSelection = false;
if (selectedRoute == null && (routeSelection == null || !routeSelection.hasNext())) {
newRouteSelection = true;
routeSelection = routeSelector.next();
}

synchronized (connectionPool) {
if (canceled) throw new IOException(“Canceled”);

if (newRouteSelection) {
// Now that we have a set of IP addresses, make another attempt at getting a connection from
// the pool. This could match due to connection coalescing.
List routes = routeSelection.getAll();
for (int i = 0, size = routes.size(); i < size; i++) {
Route route = routes.get(i);
Internal.instance.get(connectionPool, address, this, route);
if (connection != null) {
foundPooledConnection = true;
result = connection;
this.route = route;
break;
}
}
}

if (!foundPooledConnection) {
if (selectedRoute == null) {
selectedRoute = routeSelection.next();
}

// 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, false);
}
}

// If we found a pooled connection on the 2nd time around, we’re done.
if (foundPooledConnection) {
eventListener.connectionAcquired(call, result);
return result;
}

// Do TCP + TLS handshakes. This is a blocking operation.
result.connect(
connectTimeout, readTimeout, writeTimeout, connectionRetryEnabled, call, eventListener);
routeDatabase().connected(result.route());

Socket socket = null;
synchronized (connectionPool) {
reportedAcquired = true;

// 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);

eventListener.connectionAcquired(call, result);
return result;
}

以上是OkHttp获取连接的主要逻辑，方法比较复杂，我们这里总结一下获取连接的流程，具体的细节可以自行查看。

1. 首先会尝试从连接池中获取一个连接，获取连接的参数是地址。如果获取到连接，则返回，否则进行下一步；
2. 如果需要选择线路，则继续尝试获取连接。如果获取到连接，则返回，否则进行下一步；
3. 创建一个新的连接，然后建立与服务端的TCP连接。
4. 将连接加入连接池。

CallServerInterceptor

CallServerInterceptor是最后一个拦截器，理所当然这个拦截器负责向服务端发送数据。

public Response intercept(Chain chain) throws IOException {
//…
//写入请求头数据
httpCodec.writeRequestHeaders(request);
realChain.eventListener().requestHeadersEnd(realChain.call(), request);
Response.Builder responseBuilder = null;

最后

简历首选内推方式，速度快，效率高啊！然后可以在拉钩，boss，脉脉，大街上看看。简历上写道熟悉什么技术就一定要去熟悉它，不然被问到不会很尴尬！做过什么项目，即使项目体量不大，但也一定要熟悉实现原理！不是你负责的部分，也可以看看同事是怎么实现的，换你来做你会怎么做？做过什么，会什么是广度问题，取决于项目内容。但做过什么，达到怎样一个境界，这是深度问题，和个人学习能力和解决问题的态度有关了。大公司看深度，小公司看广度。大公司面试你会的，小公司面试他们用到的你会不会，也就是岗位匹配度。

面试过程一定要有礼貌！即使你觉得面试官不尊重你，经常打断你的讲解，或者你觉得他不如你，问的问题缺乏专业水平，你也一定要尊重他，谁叫现在是他选择你，等你拿到offer后就是你选择他了。

另外，描述问题一定要慢！不要一下子讲一大堆，慢显得你沉稳、自信，而且你还有时间反应思路接下来怎么讲更好。现在开发过多依赖ide，所以会有个弊端，当我们在面试讲解很容易不知道某个方法怎么读，这是一个硬伤…所以一定要对常见的关键性的类名、方法名、关键字读准，有些面试官不耐烦会说“你到底说的是哪个？”这时我们会容易乱了阵脚。正确的发音+沉稳的描述+好听的嗓音决对是一个加分项！

最重要的是心态！心态！心态！重要事情说三遍！面试时间很短，在短时间内对方要摸清你的底子还是比较不现实的，所以，有时也是看眼缘，这还是个看脸的时代。

希望大家都能找到合适自己满意的工作！

进阶学习视频

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！
个弊端，当我们在面试讲解很容易不知道某个方法怎么读，这是一个硬伤…所以一定要对常见的关键性的类名、方法名、关键字读准，有些面试官不耐烦会说“你到底说的是哪个？”这时我们会容易乱了阵脚。正确的发音+沉稳的描述+好听的嗓音决对是一个加分项！

最重要的是心态！心态！心态！重要事情说三遍！面试时间很短，在短时间内对方要摸清你的底子还是比较不现实的，所以，有时也是看眼缘，这还是个看脸的时代。

希望大家都能找到合适自己满意的工作！

进阶学习视频

[外链图片转存中…(img-ECRQDPpu-1715165756395)]

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

[外链图片转存中…(img-BNiyQU9C-1715165756399)]
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！