BridgeInterceptor拦截器分析

在分析完RetryAndFollowUpInterceptor拦截器后，我们看下BridgeInterceptor(连接桥拦截器)这个拦截器，它的主要作用是在request阶段配置请求头信息，cookie信息等，在response阶段，处理并保存返回的cookie信息，判断是否需要进行gzip解压等。

我们直接来看它的 intercept方法中的处理：

public Response intercept(Chain chain) throws IOException {
    Request userRequest = chain.request();
    Request.Builder requestBuilder = userRequest.newBuilder();

    // 配置请求头信息

    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");
    }

    // 获取本地保存的cookie信息，如果没有配置cookieJar，则返回的是空集合
    List<Cookie> cookies = cookieJar.loadForRequest(userRequest.url());
    if (!cookies.isEmpty()) {
        // 设置cookie信息
        requestBuilder.header("Cookie", cookieHeader(cookies));
    }

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

    // 设置请求头信息结束

    // 通过调用RealInterceptorChain的proceed方法来调用下一个拦截器的intercept，并返回执行结果response
    Response networkResponse = chain.proceed(requestBuilder.build());

    // 处理并保存cookie
    HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());

    Response.Builder responseBuilder = networkResponse.newBuilder()
            .request(userRequest);

    // 压缩处理
    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();
}

上面的逻辑也比较容易理解，首先给request设置请求头信息、然后调用下一个拦截器的intercept方法，返回response，然后处理并保存返回的cookie信息，再判断是否需要进行gzip解压处理。接下来我们关注点放到cookie的处理那部分：

获取本地的cookie

// 获取本地保存的cookie信息，如果没有配置cookieJar，则返回的是空集合
List<Cookie> cookies = cookieJar.loadForRequest(userRequest.url());
if (!cookies.isEmpty()) {
    // 设置cookie信息
    requestBuilder.header("Cookie", cookieHeader(cookies));
}

首先我们先看下cookieJar这个变量，cookieJar的默认值是在OkHttpClient的Builder中赋值的:

public Builder() {
        dispatcher = new Dispatcher();
        protocols = DEFAULT_PROTOCOLS;
        connectionSpecs = DEFAULT_CONNECTION_SPECS;
        eventListenerFactory = EventListener.factory(EventListener.NONE);
        proxySelector = ProxySelector.getDefault();
        if (proxySelector == null) {
            proxySelector = new NullProxySelector();
        }
        
        cookieJar = CookieJar.NO_COOKIES;
        ...省略代码

public interface CookieJar {
  /** A cookie jar that never accepts any cookies. */
  CookieJar NO_COOKIES = new CookieJar() {
    @Override public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
    }

    @Override public List<Cookie> loadForRequest(HttpUrl url) {
      return Collections.emptyList();
    }
  };

可以看到cookieJar的默认值是NO_COOKIES，意思就是没有配置cookie（一个空实现），不会存储任何cookie信息。所以，如果需要保存cookie信息，我们可以创建一个类去实现CookieJar接口，然后实现saveFromResponse和loadForRequest这两个方法来处理cookie信息。我们回到 cookieJar.loadForRequest(userRequest.url()) 这段代码往下看，这里加了个空判断，当对应url的cookie存在时，才会把cookie信息加入到请求头信息中。

处理服务器返回的cookie信息

// 处理并保存cookie，如果没有自定义配置cookie则不处理
HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());

public static void receiveHeaders(CookieJar cookieJar, HttpUrl url, Headers headers) {
    // 如果没有配置cookieJar，则直接返回
    if (cookieJar == CookieJar.NO_COOKIES) return;

    // 解析Set-Cookie中的值，返回cookie集合
    List<Cookie> cookies = Cookie.parseAll(url, headers);
    if (cookies.isEmpty()) return;

    // 保存
    cookieJar.saveFromResponse(url, cookies);
}

Cookie类：

public static List<Cookie> parseAll(HttpUrl url, Headers headers) {
    // 从请求头Set-Cookie中获取所有的cookie信息
    List<String> cookieStrings = headers.values("Set-Cookie");
    List<Cookie> cookies = null;

    for (int i = 0, size = cookieStrings.size(); i < size; i++) {
        // 构造cookie对象
        Cookie cookie = Cookie.parse(url, cookieStrings.get(i));
        if (cookie == null) continue;
        if (cookies == null) cookies = new ArrayList<>();
        cookies.add(cookie);
    }

    return cookies != null
            ? Collections.unmodifiableList(cookies)
            : Collections.emptyList();
}

可以看到，如果没有配置cookieJar，则不进行解析，如果有配置，则最终会调用cookieJar.saveFromResponse(url, cookies) 方法保存cookie信息。

总结

BridgeInterceptor拦截器相对比较容易理解，主要就是配置请求所需要的请求头信息和cookie信息。