Okhttp之CacheInterceptor拦截器分析

Okhttp的浅层架构分析
Okhttp的责任链模式和拦截器分析
Okhttp之RetryAndFollowUpInterceptor拦截器分析
Okhttp之BridgeInterceptor拦截器分析
Okhttp之CacheInterceptor拦截器分析
Okhttp之ConnectInterceptor拦截器分析
Okhttp之网络连接相关三大类RealConnection、ConnectionPool、StreamAllocation

CacheInterceptor，缓存拦截器，负责管理缓存策略相关的逻辑。

上代码：

public final class CacheInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        //1. 读取候选缓存,cache里根据request存储了相应的缓存
        Response cacheCandidate = cache != null
                ? cache.get(chain.request())
                : null;
        long now = System.currentTimeMillis();
        //2. 根据cacheCandidate和request创建缓存策略，强制缓存、对比缓存等
        CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
        Request networkRequest = strategy.networkRequest;
        Response cacheResponse = strategy.cacheResponse;

        if (cache != null) {
            cache.trackResponse(strategy);
        }
        // The cache candidate wasn't applicable. Close it.
        // 这种情况说明cacheCandidate 不适用，把他的流关闭
        if (cacheCandidate != null && cacheResponse == null) {
            closeQuietly(cacheCandidate.body()); 
        }

        // If we're forbidden from using the network and the cache is insufficient, fail.
        //3. 根据策略，不使用网络，又没有缓存的直接报错，并返回错误码504。
        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 we don't need the network, we're done.
        //4. 根据策略，不使用网络，有缓存的直接返回。
        if (networkRequest == null) {
            return cacheResponse.newBuilder()
                    .cacheResponse(stripBody(cacheResponse))
                    .build();
        }

        Response networkResponse = null;
        try {
            // 5. 前面两个都没有返回，继续执行下一个Interceptor，即ConnectInterceptor。
            //来到了这里，说明最终还是请求了网络，没用到缓存，这里拿到了http返回的response
            networkResponse = chain.proceed(networkRequest);
        } finally {
            // If we're crashing on I/O or otherwise, don't leak the cache body.
            //最终要关闭缓存的流
            if (networkResponse == null && cacheCandidate != null) {
                closeQuietly(cacheCandidate.body());
            }
        }

        // If we have a cache response too, then we're doing a conditional get.
        //6. 接收到网络结果，如果响应code式304，则使用缓存，返回缓存结果。
        if (cacheResponse != null) {
            //服务器告诉客户端访问的资源没有修改，可以直接用缓存cacheResponse 
            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();

                // Update the cache after combining headers but before stripping the
                // Content-Encoding header (as performed by initContentStream()).
                cache.trackConditionalCacheHit();
                cache.update(cacheResponse, response);
                return response;
            } else {
                closeQuietly(cacheResponse.body());
            }
        }
        //7. 正常返回结果，读取网络结果。
        Response response = networkResponse.newBuilder()
                .cacheResponse(stripBody(cacheResponse))
                .networkResponse(stripBody(networkResponse))
                .build();
        //8. 对数据进行缓存。
        if (cache != null) {
            if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
                // Offer this request to the cache.
                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.
                }
            }
        }
   //9. 返回网络读取的结果。
        return response;
    }
}

总结：

1.读取候选缓存，创建缓存策略，强制缓存、对比缓存等。
3.根据策略，不使用网络，又没有缓存的直接报错，并返回错误码504。
4.根据策略，不使用网络，有缓存的直接返回。
5.前面两个都没有返回，继续执行下一个Interceptor，即ConnectInterceptor。
6.接收到网络结果，如果响应code式304，则使用缓存，返回缓存结果。
7.读取网络结果。
8.对数据进行缓存。
9.返回网络读取的结果。

具体的缓存操作DiskLruCache之类的另外需要花时间才能了解清楚，mark一下。