Android OKHttp系列2-RetryAndFollowUpInterceptor

文章将会被同步至微信公众号：Android部落格

概述

失败重试以及重定向

流程图如下：

（1）StreamAllocation

在RetryAndFollowUpInterceptor的intercept方法中初始化了一个StreamAllocation对象。

StreamAllocation streamAllocation = new StreamAllocation(client.connectionPool(),
    createAddress(request.url()), call, eventListener, callStackTrace);

createAddress

方法创建了Address对象，如下：

return new Address(url.host(), url.port(), client.dns(), client.socketFactory(),
    sslSocketFactory, hostnameVerifier, certificatePinner, client.proxyAuthenticator(),
    client.proxy(), client.protocols(), client.connectionSpecs(), client.proxySelector());

其中proxySelector的默认初始化在OKHttpClient的内部类Builder中：

proxySelector = ProxySelector.getDefault();
public static ProxySelector getDefault() {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        sm.checkPermission(SecurityConstants.GET_PROXYSELECTOR_PERMISSION);
    }
    return theProxySelector;
}

StreamAllocation构造函数

public StreamAllocation(ConnectionPool connectionPool, Address address, Call call,
  EventListener eventListener, Object callStackTrace) {
    this.connectionPool = connectionPool;
    this.address = address;
    this.call = call;
    this.eventListener = eventListener;
    this.routeSelector = new RouteSelector(address, routeDatabase(), call, eventListener);
    this.callStackTrace = callStackTrace;
}

可以看到最终路由选择是在RouteSelector类中，

/** Prepares the proxy servers to try. */
private void resetNextProxy(HttpUrl url, Proxy proxy) {
    if (proxy != null) {
      // If the user specifies a proxy, try that and only that.
      proxies = Collections.singletonList(proxy);
    } else {
      // Try each of the ProxySelector choices until one connection succeeds.
      List<Proxy> proxiesOrNull = address.proxySelector().select(url.uri());
      proxies = proxiesOrNull != null && !proxiesOrNull.isEmpty()
          ? Util.immutableList(proxiesOrNull)
          : Util.immutableList(Proxy.NO_PROXY);
    }
    nextProxyIndex = 0;
}

默认是系统的路由策略，也可以自己继承ProxySelector虚拟类自定义路由策略。

（2） while循环

在while循环中不断的判断其余拦截器的返回，如果请求失败则尝试重试连接。
针对请求返回的Response在followUpRequest方法中重新构建Request并返回请求。
重点看看followUpRequest方法，在该方法中差异化处理状态码Response.code，并根据不同的code对请求Header做了处理。Http状态码列表如下（https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Status/）：

此处处理的状态码有：

• HTTP_PROXY_AUTH（407）需要代理身份认证，在请求之初如果不做认证处理的话，默认为Authenticator.NONE,如果要做认证处理，需要实现Authenticator接口，并实现authenticate方法，并返回携带认证信息的Request。

client.proxyAuthenticator().authenticate(route, userResponse)

public interface Authenticator {
  /** An authenticator that knows no credentials and makes no attempt to authenticate. */
  Authenticator NONE = new Authenticator() {
    @Override public Request authenticate(Route route, Response response) {
      return null;
    }
  };

  /**
   * Returns a request that includes a credential to satisfy an authentication challenge in {@code
   * response}. Returns null if the challenge cannot be satisfied.
   */
  @Nullable Request authenticate(Route route, Response response) throws IOException;
}

• HTTP_PROXY_AUTH（401） 要求用户身份认证，跟407不一样的是，这个状态码不是代理身份认证，处理方式是：

client.authenticator().authenticate(route, userResponse)

• HTTP_PERM_REDIRECT or HTTP_TEMP_REDIRECT（308/307）
  永久重定向或临时重定向，

if (!method.equals("GET") && !method.equals("HEAD")) {
    return null;
}

对于非GET和HEAD请求方法，不能再去修改请求方法做重定向。307 或308状态码可以确保请求方法和消息主体不会发生变化。

• HTTP_MULT_CHOICE or HTTP_MOVED_PERM or HTTP_MOVED_TEMP or HTTP_SEE_OTHER （300/301/302/303）

请求的资源被移到了新的URI，需要用新的URI重新发起请求。按照源码的思路，重新获取Response的request，对于可以携带request body的方法，则填写body，否则置空。同时如果不携带body的请求，将请求头的以下三个信息去掉然后重新返回组织过的Request：

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

• HTTP_CLIENT_TIMEOUT（408）
  服务器等待客户端发送的请求时间过长，导致超时，此时如果Response中的头部Retry-After返回的重试时间大于0，则不会重试直接返回null，否则返回Response.request重试。

if (retryAfter(userResponse, 0) > 0) {
  return null;
}

private int retryAfter(Response userResponse, int defaultDelay) {
    String header = userResponse.header("Retry-After");
    
    if (header == null) {
      return defaultDelay;
    }
    
    // https://tools.ietf.org/html/rfc7231#section-7.1.3
    // currently ignores a HTTP-date, and assumes any non int 0 is a delay
    if (header.matches("\\d+")) {
      return Integer.valueOf(header);
    }
    
    return Integer.MAX_VALUE;
}

• HTTP_UNAVAILABLE（503）503 Service Unavailable 是一种HTTP协议的服务器端错误状态代码，它表示服务器尚未处于可以接受请求的状态。通常造成这种情况的原因是由于服务器停机维护或者已超载。注意在发送该响应的时候，应该同时发送一个对用户友好的页面来解释问题发生的原因。该种响应应该用于临时状况下，与之同时，在可行的情况下，应该在 Retry-After 首部字段中包含服务恢复的预期时间。缓存相关的首部在与该响应一同发送时应该小心使用，因为503状态码通常应用于临时状况下，而此类响应一般不应该进行缓存。
  按照源码的意思，除非Response的Retry-After值为0，否则不会返回Request重试。

if (retryAfter(userResponse, Integer.MAX_VALUE) == 0) {
  // specifically received an instruction to retry without delay
  return userResponse.request();
}

（3）开始重试

对返回码处理完毕之后，有一些情况会重新构造Request方法返回用于重试，并且有20次的限制:

if (++followUpCount > MAX_FOLLOW_UPS) {
    streamAllocation.release();
    throw new ProtocolException("Too many follow-up requests: " + followUpCount);
}

同时，对于返回的Request与之前的相比，不相同的话，会重新构造StreamAllocation并请求:

if (!sameConnection(response, followUp.url())) {
    streamAllocation.release();
    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?");
}

对于是否是同一个连接的判断依据是sameConnection方法：

private boolean sameConnection(Response response, HttpUrl followUp) {
    HttpUrl url = response.request().url();
    return url.host().equals(followUp.host())
        && url.port() == followUp.port()
        && url.scheme().equals(followUp.scheme());
}

判断依据是host，port和scheme(http/https).

最后利用重新创建的Request开始新一轮的连接，如果构建用于重试的Request为null的话，直接返回Response。

微信公众号：