1、okhttp源码解析-整体流程
2、okhttp源码解析-拦截器RetryAndFllowUpInterceptor
3、okhttp源码解析-拦截器BridgeInterceptor
4、okhttp源码解析-拦截器CacheInterceptor
5、okhttp源码解析-拦截器ConnectInterceptor
6、okhttp源码解析-拦截器CallServerInterceptor
7、okhttp源码解析-Dispatcher任务管理器
RetryAndFllowUpInterceptor
这个拦截器主要用于重试连接、重定向等处理。
1、处理401/407状态码，补充Authorization，重试连接
- 401：
服务端发送WWW-Authenticate，
表示需要clent传Authorization信息头。
- 407：
与401响应类似，只不过客户端必须在代理服务器上进行身份验证。
代理服务器必须返回一个 Proxy-Authenticate 用以进行身份询问。
客户端可以返回一个 Proxy-Authorization 信息头用以验证
2、处理408，网络连接超时，重试连接。
3、处理30*状态码，重定向。
4、尝试连接次数最大数：20
为什么是20次尝试，代码注释的解释：
//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.
private static final int MAX_FOLLOW_UPS = 20;
1.流程示意图
RetryAndFllowUpInterceptor.png
2.代码思路
- 1、获取责任链返回的response结果。
response = realChain.proceed(request, streamAllocation, null, null);
- 2、判断上次循环的response（priorResponse）是否为空，不为空，说明连接已完成，直接生成response。
if (priorResponse != null) {
response = response.newBuilder()
.priorResponse(priorResponse.newBuilder()
.body(null)
.build())
.build();
}
- 3、获取需要重连的Request，followUp。如果followUp为空说明无须重试连接。不为空继续循环，重试连接。
Request followUp = followUpRequest(response);
if (followUp == null) {
if (!forWebSocket) {
streamAllocation.release();
}
return response;
}
- 4.1整体方法说明
@Override public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
int followUpCount = 0;
Response priorResponse = null;
//开始循环
while (true) {
...
// 获取责任链的结果，response
response = realChain.proceed(request, streamAllocation, null, null);
releaseConnection = false;
...
// Attach the prior response if it exists. Such responses never have a body.
// 上次循环后设置的priorResponse，不为空直接创建response。
if (priorResponse != null) {
response = response.newBuilder()
.priorResponse(priorResponse.newBuilder()
.body(null)
.build())
.build();
}
Request followUp = followUpRequest(response);
if (followUp == null) {
if (!forWebSocket) {
streamAllocation.release();
}
return response;
}
closeQuietly(response.body());
// 重试次数超过20次，结束循环
if (++followUpCount > MAX_FOLLOW_UPS) {
streamAllocation.release();
throw new ProtocolException("Too many follow-up requests: " + followUpCount);
}
...
request = followUp;
priorResponse = response;
}
}
- 4.2followUpRequest()方式实现。
- 处理401、407需要Authorization的情况，并返回Request，重试连接。
- 处理408，请求超时情况。并返回Request，重试连接
- 处理30*，重定向情况。并返回Request，重试连接。
- 其他情况视为通过，直接返回null，结束重试。
private Request followUpRequest(Response userResponse) throws IOException {
int responseCode = userResponse.code();
final String method = userResponse.request().method();
switch (responseCode) {
// 401 服务器请求Authorization认证。
// 服务端发送WWW-Authenticate，
// 表示需要clent传Authorization信息头。
case HTTP_PROXY_AUTH:
Proxy selectedProxy = route != null
? route.proxy()
: client.proxy();
if (selectedProxy.type() != Proxy.Type.HTTP) {
throw new ProtocolException("Received HTTP_PROXY_AUTH (407) code while not using proxy");
}
return client.proxyAuthenticator().authenticate(route, userResponse);
//407 代理服务器Authorization认证
// 代理服务器必须返回一个 Proxy-Authenticate // 用以进行身份询问。
// 客户端可以返回一个 Proxy-Authorization
case HTTP_UNAUTHORIZED:
return client.authenticator().authenticate(route, userResponse);
//30* 重定向处理
case HTTP_PERM_REDIRECT:
case HTTP_TEMP_REDIRECT:
// "If the 307 or 308 status code is received in response to a request other than GET
// or HEAD, the user agent MUST NOT automatically redirect the request"
if (!method.equals("GET") && !method.equals("HEAD")) {
return null;
}
// fall-through
case HTTP_MULT_CHOICE:
case HTTP_MOVED_PERM:
case HTTP_MOVED_TEMP:
case HTTP_SEE_OTHER:
// Does the client allow redirects?
if (!client.followRedirects()) return null;
String location = userResponse.header("Location");
if (location == null) return null;
HttpUrl url = userResponse.request().url().resolve(location);
// Don't follow redirects to unsupported protocols.
if (url == null) return null;
// If configured, don't follow redirects between SSL and non-SSL.
boolean sameScheme = url.scheme().equals(userResponse.request().url().scheme());
if (!sameScheme && !client.followSslRedirects()) return null;
// Most redirects don't include a request body.
Request.Builder requestBuilder = userResponse.request().newBuilder();
if (HttpMethod.permitsRequestBody(method)) {
final boolean maintainBody = HttpMethod.redirectsWithBody(method);
if (HttpMethod.redirectsToGet(method)) {
requestBuilder.method("GET", null);
} else {
RequestBody requestBody = maintainBody ? userResponse.request().body() : null;
requestBuilder.method(method, requestBody);
}
if (!maintainBody) {
requestBuilder.removeHeader("Transfer-Encoding");
requestBuilder.removeHeader("Content-Length");
requestBuilder.removeHeader("Content-Type");
}
}
// When redirecting across hosts, drop all authentication headers. This
// is potentially annoying to the application layer since they have no
// way to retain them.
if (!sameConnection(userResponse, url)) {
requestBuilder.removeHeader("Authorization");
}
return requestBuilder.url(url).build();
// 408 请求超时
case HTTP_CLIENT_TIMEOUT:
// 408's are rare in practice, but some servers like HAProxy use this response code. The
// spec says that we may repeat the request without modifications. Modern browsers also
// repeat the request (even non-idempotent ones.)
if (!client.retryOnConnectionFailure()) {
// The application layer has directed us not to retry the request.
return null;
}
if (userResponse.request().body() instanceof UnrepeatableRequestBody) {
return null;
}
if (userResponse.priorResponse() != null
&& userResponse.priorResponse().code() == HTTP_CLIENT_TIMEOUT) {
// We attempted to retry and got another timeout. Give up.
return null;
}
return userResponse.request();
//默认情况，直接返回null，结束重试循环
default:
return null;
}
}
