原始碼分析三：OkHttp—RetryAndFollowUpInterceptor

引言

上一篇部落格籠統的講了各個攔截器：

• RetryAndFollowUpInterceptor
• BridgeInterceptor
  
• CacheInterceptor
  
• ConnectInterceptor
  
• CallServerInterceptor
  

從這邊部落格開始單獨分析每個攔截器的原始碼。首先是RetryAndFollowUpInterceptor。

這個攔截器它的作用主要是負責請求的重定向操作，用於處理網路請求中，請求失敗後的重試機制。

核心功能

• 連線失敗重試(Retry)

  在發生 RouteException 或者 IOException 後，會捕獲建聯或者讀取的一些異常，根據一定的策略判斷是否是可恢復的，如果可恢復會重新建立 StreamAllocation 開始新的一輪請求

• 繼續發起請求(Follow up)

  主要有這幾種型別

  • 3xx 重定向
  • 401，407 未授權，呼叫 Authenticator 進行授權後繼續發起新的請求
  • 408 客戶端請求超時，如果 Request 的請求體沒有被 UnrepeatableRequestBody 標記，會繼續發起新的請求

其中 Follow up 的次數受到MAX_FOLLOW_UP 約束，在 OkHttp 中為 20 次，這樣可以防止重定向死迴圈。

原始碼分析

這裡詳細分析重定向機制，關於RealCall的構造方法，原始碼如下所示

RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
  final EventListener.Factory eventListenerFactory = client.eventListenerFactory();

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

  // TODO(jwilson): this is unsafe publication and not threadsafe.
  this.eventListener = eventListenerFactory.create(this);
}複製程式碼

根據之前攔截器的介紹，會執行RetryAndFollowUpInterceptor的intercept方法。

@Override public Response intercept(Chain chain) throws IOException {
  Request request = chain.request();

  streamAllocation = new StreamAllocation(
      client.connectionPool(), createAddress(request.url()), callStackTrace);
   // （1）“建立StreamAllocation”
  int followUpCount = 0;
  Response priorResponse = null;
  while (true) {
    if (canceled) {
      streamAllocation.release();
      throw new IOException("Canceled");
    }
    //(2)進入迴圈，檢查請求是否已被取消


    Response response = null;
    boolean releaseConnection = true;
    try {
      response = ((RealInterceptorChain) chain).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(), 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, requestSendStarted, request)) throw e;
      releaseConnection = false;
      continue;
    } finally {
      
      if (releaseConnection) {
        streamAllocation.streamFailed(null);
        streamAllocation.release();
      }
    }
    //（3）“執行RealInterceptorChain.procced,並捕獲異常來判斷是否可以重定向”

    // Attach the prior response if it exists. Such responses never have a body.
    if (priorResponse != null) {
      response = response.newBuilder()
          .priorResponse(priorResponse.newBuilder()
                  .body(null)
                  .build())
          .build();
    }
    
    Request followUp = followUpRequest(response);
    //（4）“是否需要進行重定向”

    if (followUp == null) {
      if (!forWebSocket) {
        streamAllocation.release();
      }
      return response;
    }
    //（5）“不需要重定向，直接返回response，結束。否則到6”
    closeQuietly(response.body());

    if (++followUpCount > MAX_FOLLOW_UPS) {
      streamAllocation.release();
      throw new ProtocolException("Too many follow-up requests: " + followUpCount);
    }
    
    if (followUp.body() instanceof UnrepeatableRequestBody) {
      streamAllocation.release();
      throw new HttpRetryException("Cannot retry streamed HTTP body", response.code());
    }
    // （6）“重定向安全檢查”

    if (!sameConnection(response, followUp.url())) {
      streamAllocation.release();
      streamAllocation = new StreamAllocation(
          client.connectionPool(), createAddress(followUp.url()), callStackTrace);
    //（7）“根據新的請求建立連線”
    } 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;
  }
}複製程式碼

可以看出主要攔截處理過程是個while迴圈，如果沒有重定向則返回response，有則按迴圈內處理。

主要有以下5步：

1. 建立StreamAllocation
   
2. 進入迴圈，檢查請求是否已被取消
3. 執行RealInterceptorChain.procced,並捕獲異常來判斷是否可以重定向
4. 是否需要進行重定向
   
5. 不需要重定向，直接返回response，結束。否則到6
   
6. 重定向安全檢查
   
7. 根據新的請求建立連線

Request request = chain.request();

streamAllocation = new StreamAllocation(
    client.connectionPool(), createAddress(request.url()), callStackTrace);複製程式碼

private Address createAddress(HttpUrl url) {
  SSLSocketFactory sslSocketFactory = null;
  HostnameVerifier hostnameVerifier = null;
  CertificatePinner certificatePinner = null;
  if (url.isHttps()) {
    sslSocketFactory = client.sslSocketFactory();
    hostnameVerifier = client.hostnameVerifier();
    certificatePinner = client.certificatePinner();
  }

  return new Address(url.host(), url.port(), client.dns(), client.socketFactory(),
      sslSocketFactory, hostnameVerifier, certificatePinner, client.proxyAuthenticator(),
      client.proxy(), client.protocols(), client.connectionSpecs(), client.proxySelector());
}複製程式碼

if (canceled) {
  streamAllocation.release();
  throw new IOException("Canceled");
}複製程式碼

private boolean recover(IOException e, boolean requestSendStarted, Request userRequest) {
  streamAllocation.streamFailed(e);

  // 需要OkHttpClient配置可以重試
  if (!client.retryOnConnectionFailure()) return false;

  // 使用 isRecoverable 方法過濾掉不可恢復異常
  if (requestSendStarted && userRequest.body() instanceof UnrepeatableRequestBody) return false;

  // 使用 isRecoverable 方法過濾掉不可恢復異常
  if (!isRecoverable(e, requestSendStarted)) return false;

  // 已經沒有其他的路由可以使用
  if (!streamAllocation.hasMoreRoutes()) return false;

  // For failure recovery, use the same route selector with a new connection.
  return true;
}複製程式碼

OkHttpClient okHttpClient = new OkHttpClient.Builder()
   ...
   .retryOnConnectionFailure(true)
   ...
   .build();複製程式碼

   public boolean hasMoreRoutes() {
       return route != null || routeSelector.hasNext();
   }  123複製程式碼

private Request followUpRequest(Response userResponse) throws IOException {
  if (userResponse == null) throw new IllegalStateException();
  Connection connection = streamAllocation.connection();
  Route route = connection != null
      ? connection.route()
      : null;
  int responseCode = userResponse.code();複製程式碼

接下來將會根據響應碼responseCode來檢查當前是否需要進行請求重定向，我們知道，在Http響應碼中，處於3XX的，都需要進行請求重定向處理。因此，接下來該方法會通過switch…case…來進行不同的響應碼處理操作。
從這段程式碼開始，都是3xx的響應碼處理，這裡就開始進行請求重定向的處理操作。 

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:複製程式碼

執行重定向請求構建前，首先根據OkHttpClient，執行了followRedirects方法，檢查客戶端是否允許進行重定向請求。如果這時客戶端未允許重定向，則會返回null。
接下來根據響應獲取到位置location，然後根據location，得到重定向的url，程式碼如下所示。 

if (!client.followRedirects()) return null;

String location = userResponse.header("Location");
if (location == null) return null;
HttpUrl url = userResponse.request().url().resolve(location);複製程式碼

接下來這一大段程式碼就是重新構建Request的過程，根據重定向得到的url，重新構建Request請求，並對請求中的header和body分別進行處理，最後可以看到，通過build模式，將新構建的Request請求進行返回。

// 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();複製程式碼

5.不需要重定向，直接返回response，結束。否則到6

執行followUpRequest方法，來檢查是否需要進行重定向操作。當不需要進行重新定向操作時，就會直接返回Response，如下所示

if (followUp == null) {
  if (!forWebSocket) {
    streamAllocation.release();
  }
  return response;
}複製程式碼

6.重定向安全檢查

1.重定向次數<20

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

2.然後根據重定向請求followUp，與當前的響應進行對比,檢查是否同一個連線。

通常，當發生請求重定向時，url地址將會有所不同，也就是說，請求的資源在這時已經被分配了新的url。因此，接下來的!sameConnection這個判斷將會符合，該這個方法就是用來檢查重定向請求，和當前的請求，是否為同一個連線。一般來說，客戶端進行重定向請求時，需要與新的url建立連線，而原先的連線，則需要進行銷燬。

判斷是否為同一個連線：

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());
}複製程式碼

不是同一個連線，則重新建立新連線，並銷燬原來的連線：

if (!sameConnection(response, followUp.url())) {
  streamAllocation.release();
  streamAllocation = new StreamAllocation(
      client.connectionPool(), createAddress(followUp.url()), callStackTrace);
} else if (streamAllocation.codec() != null) {
  throw new IllegalStateException("Closing the body of " + response
      + " didn't close its backing stream. Bad interceptor?");
}複製程式碼

至此，RetryAndFollowUpInterceptor就分析完畢了。