okhttp3源码分析（二）：五大拦截器

发表于 | 更新于 | 分类于 | 阅读次数：

前言

拦截器是 okhttp 的精髓，okhttp 的网络请求过程其实就是通过一条拦截器链来完成的，这体现了责任链模式。本文将分析 okhttp 拦截链中各拦截器的作用，代码基于 okhttp-3.10.0。

各拦截器的分析

在上一篇文章说过，无论是同步请求还是异步请求，最后都是调用 getResponseWithInterceptorChain 方法来获得 Response，该方法实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 Response getResponseWithInterceptorChain() throws IOException {
   // Build a full stack of interceptors.
   List<Interceptor> interceptors = new ArrayList<>();

//在配置OkHttpClient时设置的interceptors
   interceptors.addAll(client.interceptors());

//RetryAndFollowUpInterceptor：负责失败重试和重定向
   interceptors.add(retryAndFollowUpInterceptor);

//BridgeInterceptor：负责把用户请求转换为发送到服务器的请求，
//并把服务器的响应转化为用户需要的响应
   interceptors.add(new BridgeInterceptor(client.cookieJar()));

//CacheInterceptor：负责读取缓存、更新缓存
   interceptors.add(new CacheInterceptor(client.internalCache()));

//ConnectInterceptor：负责和服务器建立连接
   interceptors.add(new ConnectInterceptor(client));

//在配置OkHttpClient时设置的networkInterceptors
   if (!forWebSocket) {
     interceptors.addAll(client.networkInterceptors());
   }

//CallServerInterceptor：负责向服务器发送数据，从服务器读取响应数据
   interceptors.add(new CallServerInterceptor(forWebSocket));

   Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
       originalRequest, this, eventListener, client.connectTimeoutMillis(),
       client.readTimeoutMillis(), client.writeTimeoutMillis());

   return chain.proceed(originalRequest);
 }

用户自定义的拦截器先不说，okhttp本身调用的拦截器依次是：

  • RetryAndFollowUpInterceptor：负责失败重试和重定向
  • BridgeInterceptor：负责把用户请求转换为发送到服务器的请求，并把服务器的响应转化为用户需要的响应
  • CacheInterceptor：负责读取缓存、更新缓存
  • ConnectInterceptor：负责和服务器建立连接
  • CallServerInterceptor：负责向服务器发送数据，从服务器读取响应数据

下面分析这些拦截器的各自负责的功能，主要是看它们的intercept方法：

RetryAndFollowUpInterceptor

首先是 RetryAndFollowUpInterceptor，它负责失败重试和重定向。

它的intercept方法如下：

RetryAndFollowUpInterceptor#intercept

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
@Override public Response intercept(Chain chain) throws IOException {
  Request request = chain.request();
  RealInterceptorChain realChain = (RealInterceptorChain) chain;
  Call call = realChain.call();
  EventListener eventListener = realChain.eventListener();

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

  int followUpCount = 0;
  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) {
// 路由连接失败
      if (!recover(e.getLastConnectException(), streamAllocation, false, request)) {
        throw e.getLastConnectException();
      }
      releaseConnection = false;
      continue;
    } catch (IOException e) {
// 服务器连接失败
      boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
      if (!recover(e, streamAllocation, requestSendStarted, request)) throw e;
      releaseConnection = false;
      continue;
    } finally {
// 请求失败并不再重试时抛出异常，并释放资源
      if (releaseConnection) {
        streamAllocation.streamFailed(null);
        streamAllocation.release();
      }
    }

    // 重定向时关联上一次的 Response，并将上一次 Response 的 body 置为 null
    if (priorResponse != null) {
      response = response.newBuilder()
          .priorResponse(priorResponse.newBuilder()
                  .body(null)
                  .build())
          .build();
    }

 // 根据响应码判断是否需要重定向
    Request followUp = followUpRequest(response, streamAllocation.route());
 // 不需要重定向的话就返回 Response	
    if (followUp == null) {
      if (!forWebSocket) {
        streamAllocation.release();
      }
      return response;
    }

    // 关闭 response 的 body
    closeQuietly(response.body());

 // 最多只能重定向20次
    if (++followUpCount > MAX_FOLLOW_UPS) {
      streamAllocation.release();
      throw new ProtocolException("Too many follow-up requests: " + followUpCount);
    }

 // 重定向时要销毁旧连接并创建新连接
    if (!sameConnection(response, followUp.url())) {
      streamAllocation.release();
      streamAllocation = new StreamAllocation(client.connectionPool(),
          createAddress(followUp.url()), call, eventListener, callStackTrace);
      this.streamAllocation = streamAllocation;
    } 

    request = followUp;
    priorResponse = response;
  }
}

可以看到，如果任务没有被取消，那么将会调用下一拦截器进行后续操作。

如果后续请求过程出现问题，okhttp 会通过recover 方法判断是否要重新尝试执行请求，该方法定义如下：

RetryAndFollowUpInterceptor#recover

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 private boolean recover(IOException e, StreamAllocation streamAllocation,
     boolean requestSendStarted, Request userRequest) {
   streamAllocation.streamFailed(e);

//下面四种情况下，将不再重新请求

// 用户设置了拒绝重连
   if (!client.retryOnConnectionFailure()) return false;

// 请求已发送，并且该请求为不能重新发送的类型
   if (requestSendStarted && userRequest.body() instanceof UnrepeatableRequestBody) return false;

// 发生的是再次重试也不能解决的问题，例如协议问题、证书问题。
   if (!isRecoverable(e, requestSendStarted)) return false;

// 没有更多的路由
   if (!streamAllocation.hasMoreRoutes()) return false;

   return true;
 }

可以看到，在四种情况下，不再重新请求：

  1. 用户设置了拒绝重连

用户可以在配置 OkHttpClient 时设置该选项，代码如下：

1
2
3
OkHttpClient okHttpClient = new OkHttpClient.Builder()
        .retryOnConnectionFailure(false)    //拒绝重连，默认情况下该值为true
        .build();

  1. 请求已发送，并且该请求为不能重新发送的类型
  2. 发生的是再次重试也不能解决的问题，例如协议问题、证书问题
  3. 没有更多的路由

小结

下面小结一下 RetryAndFollowUpInterceptor 的执行步骤：

  1. 先看任务是否被取消，被取消了就释放资源，不再执行请求。
  2. 调用下一拦截器执行后续请求，如果请求出现问题就要判断是否要重新执行请求，不重新执行的话就释放资源并抛出异常。
  3. 请求成功的话会根据响应码判断是否需要重定向，不需要重定向的话就返回 Response。需要重定向的话就销毁旧连接并创建新连接，进行新一轮循环。最多可重定向20次。

BridgeInterceptor

BridgeInterceptor 负责把用户请求转换为发送到服务器的请求，并把服务器的响应转化为用户需要的响应。

它的 intercept 方法如下：

BridgeInterceptor#intercept

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 @Override 
 public Response intercept(Chain chain) throws IOException {
   Request userRequest = chain.request();
   Request.Builder requestBuilder = userRequest.newBuilder();

// 将用户的 Request 构造为发送给服务器的 Reuquest

// 添加各种请求报头(包括 Host、Connection、cookie 等)
   RequestBody body = userRequest.body();
   if (body != null) {
     MediaType contentType = body.contentType();
     if (contentType != null) {
       requestBuilder.header("Content-Type", contentType.toString());
     }

     long contentLength = body.contentLength();
     if (contentLength != -1) {
       requestBuilder.header("Content-Length", Long.toString(contentLength));
       requestBuilder.removeHeader("Transfer-Encoding");
     } else {
       requestBuilder.header("Transfer-Encoding", "chunked");
       requestBuilder.removeHeader("Content-Length");
     }
   }
   if (userRequest.header("Host") == null) {
     requestBuilder.header("Host", hostHeader(userRequest.url(), false));
   }
   if (userRequest.header("Connection") == null) {
     requestBuilder.header("Connection", "Keep-Alive");
   }

   // If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing
   // the transfer stream.
   boolean transparentGzip = false;
   if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
     transparentGzip = true;
     requestBuilder.header("Accept-Encoding", "gzip");
   }

   List<Cookie> cookies = cookieJar.loadForRequest(userRequest.url());
   if (!cookies.isEmpty()) {
     requestBuilder.header("Cookie", cookieHeader(cookies));
   }

   if (userRequest.header("User-Agent") == null) {
     requestBuilder.header("User-Agent", Version.userAgent());
   }

// 构造完成后，将新的 Request 交给下一拦截器来处理
   Response networkResponse = chain.proceed(requestBuilder.build());
// 得到 Response 后，先保存 cookies
   HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());
   // 将服务器的 Response 转换为用户需要的 Response
   Response.Builder responseBuilder = networkResponse.newBuilder()
       .request(userRequest);

// 如果使用了 gzip 压缩并且服务器的 Response 有 body 的话，就给用户的 Response 设置相应 body
   if (transparentGzip
       && "gzip".equalsIgnoreCase(networkResponse.header("Content-Encoding"))
       && HttpHeaders.hasBody(networkResponse)) {
     GzipSource responseBody = new GzipSource(networkResponse.body().source());
     Headers strippedHeaders = networkResponse.headers().newBuilder()
         .removeAll("Content-Encoding")
         .removeAll("Content-Length")
         .build();
     responseBuilder.headers(strippedHeaders);
     String contentType = networkResponse.header("Content-Type");
     responseBuilder.body(new RealResponseBody(contentType, -1L, Okio.buffer(responseBody)));
   }

   return responseBuilder.build();
 }

小结

BridgeInterceptor 的执行步骤如下：

  1. 将用户的 Request 构造为发送给服务器的 Reuquest，该过程会添加各种请求报头(包括 Host、Connection、cookie 等)
  2. 构造完成后，将新的 Request 交给下一拦截器来处理
  3. 得到服务器的 Response 后，先保存 cookies，接着将服务器的 Response 转换为用户需要的 Response 并返回（如果使用了 gzip 压缩并且服务器的 Response 有 body 的话，还要给用户的 Response 设置相应 body）

CacheInterceptor

CacheInterceptor 负责读取缓存、更新缓存

它的 intercept 方法如下：

CacheInterceptor#intercept

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 @Override 
 public Response intercept(Chain chain) throws IOException {
// 从 Cache 中得到 Request 对应的缓存
//（Cache 默认为 null，用户在创建 OkHttpClient 时可以配置 Cache）
   Response cacheCandidate = cache != null
       ? cache.get(chain.request())
       : null;

   long now = System.currentTimeMillis();

// 得到缓存策略
   CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
   Request networkRequest = strategy.networkRequest;
   Response cacheResponse = strategy.cacheResponse;

   if (cache != null) {
     cache.trackResponse(strategy);
   }

// 缓存不适用，关闭缓存
   if (cacheCandidate != null && cacheResponse == null) {
     closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.
   }

// 如果缓存策略中设置禁止使用网络，并且缓存又为空，则直接构建一个返回码为 504 的 Response，说明返回失败 
   if (networkRequest == null && cacheResponse == null) {
     return new Response.Builder()
         .request(chain.request())
         .protocol(Protocol.HTTP_1_1)
         .code(504)
         .message("Unsatisfiable Request (only-if-cached)")
         .body(Util.EMPTY_RESPONSE)
         .sentRequestAtMillis(-1L)
         .receivedResponseAtMillis(System.currentTimeMillis())
         .build();
   }

// 禁用网络，但有缓存，那么返回缓存
   if (networkRequest == null) {
     return cacheResponse.newBuilder()
         .cacheResponse(stripBody(cacheResponse))
         .build();
   }

// 如果可以使用网络，就交给下一拦截器执行请求
   Response networkResponse = null;
   try {
     networkResponse = chain.proceed(networkRequest);
   } finally {
  // 如果执行请求时抛出异常，记得要关闭缓存，避免内存异常
     if (networkResponse == null && cacheCandidate != null) {
       closeQuietly(cacheCandidate.body());
     }
   }

// 当缓存和网络返回的 Response 同时存在时
// 如果返回的状态码为 304（说明服务器的文件未更新，可以使用缓存），则返回缓存
   if (cacheResponse != null) {
     if (networkResponse.code() == HTTP_NOT_MODIFIED) {
       Response response = cacheResponse.newBuilder()
           .headers(combine(cacheResponse.headers(), networkResponse.headers()))
           .sentRequestAtMillis(networkResponse.sentRequestAtMillis())
           .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
           .cacheResponse(stripBody(cacheResponse))
           .networkResponse(stripBody(networkResponse))
           .build();
       networkResponse.body().close();

       cache.trackConditionalCacheHit();
       cache.update(cacheResponse, response);
       return response;
     } else {
       closeQuietly(cacheResponse.body());
     }
   }

   Response response = networkResponse.newBuilder()
       .cacheResponse(stripBody(cacheResponse))
       .networkResponse(stripBody(networkResponse))
       .build();

// 更新缓存
   if (cache != null) {
     if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
       CacheRequest cacheRequest = cache.put(response);
       return cacheWritingResponse(cacheRequest, response);
     }

     if (HttpMethod.invalidatesCache(networkRequest.method())) {
       try {
         cache.remove(networkRequest);
       } catch (IOException ignored) {
         // The cache cannot be written.
       }
     }
   }

// 返回网络请求后返回的 Response
   return response;
 }

小结

CacheInterceptor 的执行步骤如下：

  1. 从 Cache 中得到 Request 对应的缓存，默认没有设置 Cache，需要用户自己配置
  2. 得到缓存策略
  3. 如果通过缓存策略没有得到缓存，则关闭缓存
  4. 如果缓存策略设置了禁用网络，看得到的缓存是否为空，如果缓存为空，则构建一个返回码为 504 的 Response，说明返回失败。如果缓存不为空，则返回缓存
  5. 如果可以使用网络，就交给下一拦截器执行请求，执行请求的过程发生异常，及时关闭缓存，并抛出异常，让上一拦截器处理。
  6. 当缓存和网络返回的 Response 同时存在时，如果返回的状态码为 304（说明服务器的文件未更新，可以使用缓存），则返回缓存。否则更新缓存，并返回网络请求后的 Response

ConnectInterceptor

ConnectInterceptor 负责和服务器建立连接

它的 intercept 方法如下：

ConnectInterceptor#intercept

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 @Override 
 public Response intercept(Chain chain) throws IOException {
   RealInterceptorChain realChain = (RealInterceptorChain) chain;
   Request request = realChain.request();
   StreamAllocation streamAllocation = realChain.streamAllocation();

   // We need the network to satisfy this request. Possibly for validating a conditional GET.
   boolean doExtensiveHealthChecks = !request.method().equals("GET");
// 创建一个 HttpCodec 对象
// HttpCodec 有两个实现：Http1Codec 和 Http2Codec，分别对应 HTTP/1.1 和 HTTP/2 版本
   HttpCodec httpCodec = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
// 获取到连接
   RealConnection connection = streamAllocation.connection();

// 调用下一拦截器进行后续请求操作
   return realChain.proceed(request, streamAllocation, httpCodec, connection);
 }

该方法的步骤如下：

  1. 找到一个可用的 RealConnection， 再利用这个 RealConnection 的输入输出（BufferSource 和 BufferSink）创建 HttpCodec。（ HttpCodec 有两个实现：Http1Codec 和 Http2Codec，分别对应 HTTP/1.1 和 HTTP/2 版本）
  2. 调用下一拦截器进行后续请求操作。

CallServerInterceptor

CallServerInterceptor 负责向服务器发送数据，从服务器读取响应数据

它的 intercept 方法如下：

CallServerInterceptor#intercept

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 @Override 
 public Response intercept(Chain chain) throws IOException {
   RealInterceptorChain realChain = (RealInterceptorChain) chain;
   HttpCodec httpCodec = realChain.httpStream();
   StreamAllocation streamAllocation = realChain.streamAllocation();
   RealConnection connection = (RealConnection) realChain.connection();
   Request request = realChain.request();

   long sentRequestMillis = System.currentTimeMillis();

// 向服务器写入请求头
   httpCodec.writeRequestHeaders(request);

   Response.Builder responseBuilder = null;
   if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
   
  // 如果请求头有 Expect: 100-continue，需要根据服务器返回的结果决定是否可以继续写入
     if ("100-continue".equalsIgnoreCase(request.header("Expect"))) {
       httpCodec.flushRequest();
       responseBuilder = httpCodec.readResponseHeaders(true);
     }

  // 可以继续写入就写入请求体
     if (responseBuilder == null) {

       long contentLength = request.body().contentLength();
       CountingSink requestBodyOut =
           new CountingSink(httpCodec.createRequestBody(request, contentLength));
       BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);

       request.body().writeTo(bufferedRequestBody);
       bufferedRequestBody.close();

     } else if (!connection.isMultiplexed()) {
       streamAllocation.noNewStreams();
     }
   }

   httpCodec.finishRequest();

// 得到响应头
   if (responseBuilder == null) {
     realChain.eventListener().responseHeadersStart(realChain.call());
     responseBuilder = httpCodec.readResponseHeaders(false);
   }

// 构建带有响应头的 Response
   Response response = responseBuilder
       .request(request)
       .handshake(streamAllocation.connection().handshake())
       .sentRequestAtMillis(sentRequestMillis)
       .receivedResponseAtMillis(System.currentTimeMillis())
       .build();      
     
   }
   
   // ...
   
// 默认 forWebSocket 为 false，所以会为 Response 构建响应体
   if (forWebSocket && code == 101) {
     // Connection is upgrading, but we need to ensure interceptors see a non-null response body.
     response = response.newBuilder()
         .body(Util.EMPTY_RESPONSE)
         .build();
   } else {
     response = response.newBuilder()
         .body(httpCodec.openResponseBody(response))
         .build();
   }
   
   // ...
   
   return response;

小结

CallServerInterceptor 的执行步骤如下：

  1. 向服务器写入请求头，如果请求头有 Expect: 100-continue，需要根据服务器返回的结果决定是否可以继续写入请求体。
  2. 得到响应头并构建带有响应头的 Response，接着为 Response 构建响应体并返回。

结尾

到此为止，5个拦截器的功能都分析完了，不得不说，这条拦截链的设计真的是太棒了。当然，文章有很多分析还停留在比较浅的地方，还有很多东西没有深入，例如缓存策略（CacheStrategy）的获取、创建 HttpCodec 的过程、和 okio 的结合等，有机会再深入吧。

参考

-------------　　　　本文到此结束　　感谢您的阅读　　　　-------------
0%