@Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    RealInterceptorChain realChain = (RealInterceptorChain) chain;、
    // 获取Transmitter
    Transmitter transmitter = realChain.transmitter();

    int followUpCount = 0;
    Response priorResponse = null;
    while (true) {
      // 准备连接  
      transmitter.prepareToConnect(request);
      // 处理取消事件
      if (transmitter.isCanceled()) {
        throw new IOException("Canceled");
      }
      
      Response response;
      boolean success = false;
      try {
        // 从下层获取Response  
        response = realChain.proceed(request, transmitter, null);
        // 标记获取成功  
        success = true;
      } catch (RouteException e) {
        // 判断是否满足重定向条件，满足则重试，不满足就抛异常
        if (!recover(e.getLastConnectException(), transmitter, false, request)) {
          throw e.getFirstConnectException();
        }
        continue;
      } catch (IOException e) {
        // 与服务器连接失败，检查是否满足重定向条件，满足则重试，不满足就抛异常
        boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
        if (!recover(e, transmitter, requestSendStarted, request)) throw e;
        continue;
      } finally {
        // 检测到其他未知异常，则释放连接和资源
        if (!success) {
          transmitter.exchangeDoneDueToException();
        }
      }     

      // 绑定上一个Response，指定body为空
      if (priorResponse != null) {
        response = response.newBuilder()
            .priorResponse(priorResponse.newBuilder()
                    .body(null)
                    .build())
            .build();
      }
     
      Exchange exchange = Internal.instance.exchange(response);
      Route route = exchange != null ? exchange.connection().route() : null;
      // 根据响应码处理请求，返回Request不为空时则进行重定向处理
      Request followUp = followUpRequest(response, route);

      if (followUp == null) {
        if (exchange != null && exchange.isDuplex()) {
          transmitter.timeoutEarlyExit();
        }
        return response;
      }

      RequestBody followUpBody = followUp.body();
      if (followUpBody != null && followUpBody.isOneShot()) {
        return response;
      }

      closeQuietly(response.body());
      if (transmitter.hasExchange()) {
        exchange.detachWithViolence();
      }
      // 限制重定向次数最多为20，超过则抛出异常
      if (++followUpCount > 20) {
        throw new ProtocolException("Too many follow-up requests: " + followUpCount);
      }

      request = followUp;
      priorResponse = response;
    }
  }

 private Request followUpRequest(Response userResponse, @Nullable Route route) throws IOException {
    if (userResponse == null) throw new IllegalStateException();
    int responseCode = userResponse.code();

    final String method = userResponse.request().method();
    switch (responseCode) {
      // 407      
      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);
      // 401
      case HTTP_UNAUTHORIZED:
        // 身份认证    
        return client.authenticator().authenticate(route, userResponse);
      // 308 
      case HTTP_PERM_REDIRECT:
      // 307      
      case HTTP_TEMP_REDIRECT:
        // 如果是307、308 这两种状态码 
        // 不对GET、HEAD 以外的请求重定向
        if (!method.equals("GET") && !method.equals("HEAD")) {
          return null;
        }
        // fall-through
      // 300       
      case HTTP_MULT_CHOICE:	
      // 301
      case HTTP_MOVED_PERM:
      // 302
      case HTTP_MOVED_TEMP:
      // 303
      case HTTP_SEE_OTHER:
        // 客户端关闭重定向
        if (!client.followRedirects()) return null;
        // 从响应头中获取Location字段 
        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;

        // 重建一个新的Request
        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.request().url(), url)) {
          requestBuilder.removeHeader("Authorization");
        }

        return requestBuilder.url(url).build();
      // 408
      case HTTP_CLIENT_TIMEOUT:
      // 需要发送一次相同的请求
      // ......      
      // 503
      case HTTP_UNAVAILABLE:
        if (userResponse.priorResponse() != null
            && userResponse.priorResponse().code() == HTTP_UNAVAILABLE) {
          // We attempted to retry and got another timeout. Give up.
          return null;
        }

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

        return null;

      default:
        return null;
    }
  }