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