OKHttp請求超時無效問題記錄（自動重試）

參考：https://www.jianshu.com/p/3ef261ab157c

參考：https://www.jianshu.com/p/89033630ab7a

發現問題

在項目開發中發現，發起網絡請求是會一直顯示Loading。但是我們在okhttp初始化的時候已經設置的網絡請求超時時間為30s。為什么會出現這種情況 WTF！最后發現原來是OKHttp的重試機制挖的坑

OKHttp重試機制剖析

OKHttp擁有網絡連接失敗時的重試功能：

OkHttp perseveres when the network is troublesome: it will silently recover from common connection problems. If your service has multiple IP addresses OkHttp will attempt alternate addresses if the first connect fails. This is necessary for IPv4+IPv6 and for services hosted in redundant data centers. OkHttp initiates new connections with modern TLS features (SNI, ALPN), and falls back to TLS 1.0 if the handshake fails.

要了解OKHttp的重試機制，我們最關心的就是 RetryAndFollowUpInterceptor， 在遭遇網絡異常時，OKHttp的網絡異常相關的重試都在 RetryAndFollowUpInterceptor完成。具體我們先從 RetryAndFollowUpInterceptor的# intercept(Chain chian)方法開始入手

 public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        this.streamAllocation = new StreamAllocation(this.client.connectionPool(), this.createAddress(request.url()));
        int followUpCount = 0;
        Response priorResponse = null;
       //while循環
        while(!this.canceled) {
            Response response = null;
            boolean releaseConnection = true;

            try {
                response = ((RealInterceptorChain)chain).proceed(request, this.streamAllocation, (HttpStream)null, (Connection)null);
                releaseConnection = false;
            } catch (RouteException var12) {
                if(!this.recover(var12.getLastConnectException(), true, request)) {
                    throw var12.getLastConnectException();
                }

                releaseConnection = false;
                continue;
            } catch (IOException var13) {
                if(!this.recover(var13, false, request)) {
                    throw var13;
                }

                releaseConnection = false;
                continue;
            } finally {
                if(releaseConnection) {
                    this.streamAllocation.streamFailed((IOException)null);
                    this.streamAllocation.release();
                }

            }

            if(priorResponse != null) {
                response = response.newBuilder().priorResponse(priorResponse.newBuilder().body((ResponseBody)null).build()).build();
            }

            Request followUp = this.followUpRequest(response);
            if(followUp == null) {
                if(!this.forWebSocket) {
                    this.streamAllocation.release();
                }

                return response;
            }

            Util.closeQuietly(response.body());
            ++followUpCount;
            if(followUpCount > 20) {
                this.streamAllocation.release();
                throw new ProtocolException("Too many follow-up requests: " + followUpCount);
            }

            if(followUp.body() instanceof UnrepeatableRequestBody) {
                throw new HttpRetryException("Cannot retry streamed HTTP body", response.code());
            }

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

            request = followUp;
            priorResponse = response;
        }

        this.streamAllocation.release();
        throw new IOException("Canceled");
    }

去掉代碼片段中的非核心邏輯：

  //StreamAllocation init...
  Response priorResponse = null;
    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) {
        //socket連接階段，如果發生連接失敗，會統一封裝成該異常並拋出
        `RouteException`：通過路由的嘗試失敗了，請求將不會被發送，此時會嘗試通過調用`#recover`來恢復；
        // 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) {
        //socket連接成功后，發生請求階段時拋出的各類網絡異常
        // 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 {
        // We're throwing an unchecked exception. Release any resources.
        if (releaseConnection) {
          streamAllocation.streamFailed(null);
          streamAllocation.release();
        }
      }

原來一直在執行while循環，Okhttp在網絡請示出現錯誤時會重新發送請求，最終會不斷執行

 catch (IOException var13) {
                if(!this.recover(var13, false, request)) {
                    throw var13;
                }

                releaseConnection = false;
                continue;
} 

接下來看核心的recover方法：

/**
   * Report and attempt to recover from a failure to communicate with a server. Returns true if
   * {@code e} is recoverable, or false if the failure is permanent. Requests with a body can only
   * be recovered if the body is buffered or if the failure occurred before the request has been
   * sent.
   */
  private boolean recover(IOException e, boolean requestSendStarted, Request userRequest) {
    streamAllocation.streamFailed(e);

    // The application layer has forbidden retries. 應用層禁止重試則不再重試
    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. //致命錯誤
    if (!isRecoverable(e, requestSendStarted)) return false;

    // No more routes to attempt. 沒有更多route發起重試
    if (!streamAllocation.hasMoreRoutes()) return false;

    // For failure recovery, use the same route selector with a new connection.
    return true;
  }

在該方法中，首先是通過調用 streamAllocation.streamFailed(e)來記錄該次異常，進而在 RouteDatabase中記錄錯誤的route以降低優先級，避免下次相同address的請求依然使用這個失敗過的route。如果沒有更多可用的連接線路則不能重試連接。

public final class RouteDatabase {
  private final Set<Route> failedRoutes = new LinkedHashSet<>();

  /** Records a failure connecting to {@code failedRoute}. */
  public synchronized void failed(Route failedRoute) {
    failedRoutes.add(failedRoute);
  }

  /** Records success connecting to {@code route}. */
  public synchronized void connected(Route route) {
    failedRoutes.remove(route);
  }

  /** Returns true if {@code route} has failed recently and should be avoided. */
  public synchronized boolean shouldPostpone(Route route) {
    return failedRoutes.contains(route);
  }
}

接着我們重點再關注isRecoverable方法：

  private boolean isRecoverable(IOException e, boolean requestSendStarted) {
    // If there was a protocol problem, don't recover.  協議錯誤不再重試
    if (e instanceof ProtocolException) {
      return false;
    }

    // If there was an interruption don't recover, but if there was a timeout connecting to a route
    // we should try the next route (if there is one)
    if (e instanceof InterruptedIOException) {
      return e instanceof SocketTimeoutException && !requestSendStarted;
    }

    // Look for known client-side or negotiation errors that are unlikely to be fixed by trying
    // again with a different route.
    if (e instanceof SSLHandshakeException) {
      // If the problem was a CertificateException from the X509TrustManager,
      // do not retry.
      if (e.getCause() instanceof CertificateException) {
        return false;
      }
    }
//使用 HostnameVerifier 來驗證 host 是否合法，如果不合法會拋出 SSLPeerUnverifiedException
 // 握手HandShake#getSeesion 拋出的異常，屬於握手過程中的一環
    if (e instanceof SSLPeerUnverifiedException) {
      // e.g. a certificate pinning error.
      return false;
    }

    // An example of one we might want to retry with a different route is a problem connecting to a
    // proxy and would manifest as a standard IOException. Unless it is one we know we should not
    // retry, we return true and try a new route.
    return true;
  }

問題解決

可以關閉okhttp的重試，讓retryOnConnectionFailure返回false就好了：

sClient = builder.retryOnConnectionFailure(false).build();

更新

該問題 在3.4.2版本已處理
https://github.com/square/okhttp/issues/2756

 

常見網絡異常分析：

UnknowHostException

產生原因：

• 網絡中斷
• DNS 服務器故障
• 域名解析劫持

解決辦法：

• HttpDNS
• 合理的兜底策略

![Uploading image_079055.png . . .]

InterruptedIOException

產生原因：

• 請求讀寫階段，請求線程被中斷

解決辦法：

• 檢查是否符合業務邏輯

SocketTimeoutException

產生原因：

• 帶寬低、延遲高
• 路徑擁堵、服務端負載吃緊
• 路由節點臨時異常

解決辦法：

• 合理設置重試
• 切換ip重試

要特別注意： 請求時因為讀寫超時等原因產生的SocketTimeoutException，OkHttp內部是不會重試的

 

 

因此如果app層特別關心該異常，則應該自定義intercetors，對該異常進行特殊處理。

SSLHandshakeException

產生原因：

• Tls協議協商失敗/握手格式不兼容
• 辦法服務器證書的CA未知
• 服務器證書不是由CA簽名的，而是自簽名
• 服務器配置缺少中間CA（不完整的證書鏈）
• 服務器主機名不匹配（SNI）；
• 遭遇了中間人攻擊。

解決辦法：

• 指定SNI
• 證書鎖定
• 降級Http。。。
• 聯系SA

SSLPeerUnverifiedException

產生原因：

• 證書域名校驗錯誤

解決辦法：

• 指定SNI
• 證書鎖定
• 降級Http。。。
• 聯系SA