前言

这一篇我们分析okhttp的重试机制，一般如果网络请求失败，我们会考虑连续请求多次，增大网络请求成功的概率，那么okhttp是怎么实现这个功能的呢？

正文

首先还是回到之前的InterceptorChain：

Response getResponseWithInterceptorChain() throws IOException {

// Build a full stack of interceptors.

List interceptors = new ArrayList<>();

interceptors.addAll(client.interceptors());

// 重试的Interceptor，在构造方法中创建

interceptors.add(retryAndFollowUpInterceptor);

// 其他的interceptor

...

return chain.proceed(originalRequest);

}

其中的RetryAndFollowUpInterceptor是负责重试的Interceptor，他处于责任链的顶端，负责网络请求的开始工作，也负责收尾的工作。

他的创建是在RealCall.java构造方法中:

private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {

this.client = client;

this.originalRequest = originalRequest;

this.forWebSocket = forWebSocket;

this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);

}

创建的时机就是我们调用OkhttpClient的newCall方法，每一次发起网络请求，我们都需要调用：

@Override public Call newCall(Request request) {

return RealCall.newRealCall(this, request, false /* for web socket */);

}

了解了他的创建过程，我们接着分析RetryAndFollowUpInterceptor的工作过程：

Request request = chain.request();

RealInterceptorChain realChain = (RealInterceptorChain) chain;

Call call = realChain.call();

// 我们设置的eventListener回调

EventListener eventListener = realChain.eventListener();

// 从参数上看，可以推测StreamAllocation中保存了此次网络请求的信息

// 连接池()，地址，网络请求，eventListenenr

StreamAllocation streamAllocation = new StreamAllocation(client.connectionPool(),

createAddress(request.url()), call, eventListener, callStackTrace);

this.streamAllocation = streamAllocation;

一开始，创建了StreamAllocation对象，他封装了网络请求相关的信息：连接池，地址信息，网络请求，事件回调，负责网络连接的连接、关闭，释放等操作。callStackTrace是一个Throwable对象，他主要是记录运行中异常信息，帮助我们识别网络请求的来源。

之后就进入到网络连接的循环，代码稍微有点长：

// 计数器

int followUpCount = 0;

Response priorResponse = null;

// 开始进入while循环

while (true) {

// 如果请求已经被取消了，释放连接池的资源

if (canceled) {

streamAllocation.release();

throw new IOException("Canceled");

}

Response response;

boolean releaseConnection = true;

try {

// 得到最终的网络请求结果

response = realChain.proceed(request, streamAllocation, null, null);

// 先不释放链接，因为可能要复用

releaseConnection = false;

}

// 连接地址失败的异常

catch (RouteException e) {

// The attempt to connect via a route failed. The request will not have been sent.

// 判断是否能够恢复，也就是是否要重试

if (!recover(e.getLastConnectException(), streamAllocation, false, request)) {

throw e.getLastConnectException();

}

releaseConnection = false;

// 继续

continue;

} catch (IOException e) {

// An attempt to communicate with a server failed. The request may have been sent.

// 判断网络请求是否已经开始

boolean requestSendStarted = !(e instanceof ConnectionShutdownException);

// 判断是否能够恢复，也就是是否要重试

if (!recover(e, streamAllocation, requestSendStarted, request)) throw e;

releaseConnection = false;

continue;

} finally {

// We're throwing an unchecked exception. Release any resources.

// 释放连接

if (releaseConnection) {

streamAllocation.streamFailed(null);

streamAllocation.release();

}

}

// Attach the prior response if it exists. Such responses never have a body.

// 如果不为空，保存到response中

if (priorResponse != null) {

response = response.newBuilder()

.priorResponse(priorResponse.newBuilder()

.body(null)

.build())

.build();

}

Request followUp;

try {

// 判断返回结果response，是否需要继续完善请求，例如证书验证等等

followUp = followUpRequest(response, streamAllocation.route());

} catch (IOException e) {

streamAllocation.release();

throw e;

}

// 如果不需要继续完善网络请求，返回response

if (followUp == null) {

if (!forWebSocket) {

streamAllocation.release();

}

return response;

}

// 关闭之前的连接

closeQuietly(response.body());

// 如果已经超过最大的网络请求追加数，释放连接，抛出协议异常

if (++followUpCount > MAX_FOLLOW_UPS) {

streamAllocation.release();

throw new ProtocolException("Too many follow-up requests: " + followUpCount);

}

// 如果body内容只能发送一次，释放连接

if (followUp.body() instanceof UnrepeatableRequestBody) {

streamAllocation.release();

throw new HttpRetryException("Cannot retry streamed HTTP body", response.code());

}

// 如果返回response的URL地址和追加请求的url地址不一致

if (!sameConnection(response, followUp.url())) {

// 释放之前你的url地址连接

streamAllocation.release();

// 创建新的网络请求封装对象StreamAllocation

streamAllocation = new StreamAllocation(client.connectionPool(),

createAddress(followUp.url()), call, eventListener, callStackTrace);

this.streamAllocation = streamAllocation;

} else if (streamAllocation.codec() != null) {

throw new IllegalStateException("Closing the body of " + response

+ " didn't close its backing stream. Bad interceptor?");

}

// 更新下一次的网络请求对象

request = followUp;

// 保存上一次的请求结果

priorResponse = response;

}

followUpCount是用来记录我们发起网络请求的次数的，为什么我们发起一个网络请求，可能okhttp会发起多次呢？例如https的证书验证，我们需要经过：发起 -> 验证 -> 响应，三个步骤需要发起至少两次的请求，或者我们的网络请求被重定向，在我们第一次请求得到了新的地址后，再向新的地址发起网络请求。

但是多次相应的次数是有限制的，我们看一下okhttp的注释是怎么解释的：

/**

* How many redirects and auth challenges should we attempt? Chrome follows 21 redirects; Firefox,

* curl, and wget follow 20; Safari follows 16; and HTTP/1.0 recommends 5.

*/

不同的浏览器推荐的次数是不同的，还特别强调了HTTP 1.0协议推荐5次。不过我们一般也不会设置这么多次，这会导致网络请求的效率很低。

在网络请求中，不同的异常，重试的次数也不同，okhttp捕获了两种异常：RouteException和IOException。

RouteException：所有网络连接失败的异常，包括IOException中的连接失败异常；

IOException：除去连接异常的其他的IO异常。

这个时候我们需要判断是否需要重试：

private boolean recover(IOException e, StreamAllocation streamAllocation,

boolean requestSendStarted, Request userRequest) {

streamAllocation.streamFailed(e);

// The application layer has forbidden retries.

// 如果设置了不需要重试，直接返回false

if (!client.retryOnConnectionFailure()) return false;

// We can't send the request body again.

// 如果网络请求已经开始，并且body内容只可以发送一次

if (requestSendStarted && userRequest.body() instanceof UnrepeatableRequestBody)

return false;

// This exception is fatal.

// 判断异常类型，是否要继续尝试，

// 不会重试的类型：协议异常、Socketet异常并且网络情况还没开始，ssl认证异常

if (!isRecoverable(e, requestSendStarted)) return false;

// No more routes to attempt.

// 已经没有其他可用的路由地址了

if (!streamAllocation.hasMoreRoutes()) return false;

// For failure recovery, use the same route selector with a new connection.

// 其他情况返回true

return true;

}

其中的路由地址我们先忽略，这个之后我们还会讨论。假定没有其他路由地址的情况下：

1、连接失败，并不会重试；

2、如果连接成功，因为特定的IO异常(例如认证失败)，也不会重试

其实这两种情况是可以理解的，如果连接异常，例如无网络状态，重试也只是毫秒级的任务，不会有特别明显的效果，如果是网络很慢，到了超时时间，应该让用户及时了解失败的原因，如果一味重试，用户就会等待多倍的超时时间，用户体验并不好。认证失败的情况就更不用多说了。

如果我们非要重试多次怎么办？

自定义Interceptor，增加计数器，重试到你满意就可以了：

/**

* 重试拦截器

*/

public class RetryInterceptor implements Interceptor {

/**

* 最大重试次数

*/

private int maxRetry;

RetryInterceptor(int maxRetry) {

this.maxRetry = maxRetry;

}

@Override

public Response intercept(@NonNull Chain chain) throws IOException {

Request request = chain.request();

Response response = null;

int count = 0;

while (count < maxRetry) {

try {

//发起网络请求

response = chain.proceed(request);

// 得到结果跳出循环

break;

} catch (Exception e) {

count ++;

response = null;

}

}

if(response == null){

throw Exception

}

return response;

}

}

这是一份伪代码，具体的逻辑大家可以自行完善。

总结

到这里okhttp的重试机制就分析结束了，我们发现只有在特定情况下，okhttp才会重试，如果想要自定义重试机制，可以设置Intercptor来解决这个问题。

接下来我们了解和研究一下okhttp的Dns。