Android okhttp缓存真正正确的实现方式

前言

关于okhttp的缓存，网上有大量的文章，或相同，或不一样，方式不一，但都八九不离十，原理都是经过CacheControl的设置策略不一样来实现的。 可是，真正实践过的人会发现，好像有这样那样的问题。 好比：

• 究竟是用addNetInterceptor呢仍是用addInterceptor，不一样的用法有不一样的效果
• 什么有网的时候是maxAge，无网的时候又是maxStale等等

简直不明白。 因而乎，我我的作了不少不少的尝试，几乎把网上的方法都试了一遍，看了大量换汤不换药的文章。下面是借鉴文章出处，可是个人方法都与他们的不一样。

blog.csdn.net/u014614038/… blog.csdn.net/Picasso_L/a… blog.csdn.net/briblue/art… www.jianshu.com/p/412157e23… stackoverflow.com/questions/2… newfivefour.com/android-ret…

对于okhttp的缓存解决方案，个人需求是：

一、有网的时候也能够读取缓存，而且能够控制缓存的过时时间，这样能够减轻服务器压力 二、有网的时候不读取缓存，好比一些及时性较高的接口请求 三、无网的时候读取缓存，而且能够控制缓存过时的时间

正文

说了那么多，先直接上解决方案

/**
     * 有网时候的缓存
     */
    final Interceptor NetCacheInterceptor = new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Response response = chain.proceed(request);
            int onlineCacheTime = 30;//在线的时候的缓存过时时间，若是想要不缓存，直接时间设置为0
            return response.newBuilder()
                    .header("Cache-Control", "public, max-age="+onlineCacheTime)
                    .removeHeader("Pragma")
                    .build();
        }
    };
    /**
     * 没有网时候的缓存
     */
    final Interceptor OfflineCacheInterceptor = new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            if (!SystemTool.checkNet(AppContext.context)) {
                int offlineCacheTime = 60;//离线的时候的缓存的过时时间
                request = request.newBuilder()
//                        .cacheControl(new CacheControl
//                                .Builder()
//                                .maxStale(60,TimeUnit.SECONDS)
//                                .onlyIfCached()
//                                .build()
//                        ) 两种方式结果是同样的，写法不一样
                        .header("Cache-Control", "public, only-if-cached, max-stale=" + offlineCacheTime)
                        .build();
            }
            return chain.proceed(request);
        }
    };

  //setup cache
    File httpCacheDirectory = new File(AppContext.context.getCacheDir(), "okhttpCache");
    int cacheSize = 10 * 1024 * 1024; // 10 MiB
    Cache cache = new Cache(httpCacheDirectory, cacheSize);
    OkHttpClient client = new OkHttpClient.Builder()
            .addNetworkInterceptor(NetCacheInterceptor)
            .addInterceptor(OfflineCacheInterceptor)
            .cache(cache)
            .connectTimeout(10, TimeUnit.SECONDS)
            .readTimeout(10, TimeUnit.SECONDS)
            .build();

复制代码

没错最终的解决方案就是，两个interceptor，而且针对不一样的网络状况进行不一样的处理。（为何是两个interceptor后面会讲到）

若是赶时间的朋友，能够直接拿去用，看到这里就好了。若是以为用起来就问题，欢迎下面留言。

实践和测试的过程

首先我最初的写法就是来源于网上大多数人的写法，相似

public class HttpCacheInterceptor implements Interceptor {

@Override
public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    if (!NetWorkHelper.isNetConnected(MainApplication.getContext())) {
        request = request.newBuilder()
                .cacheControl(CacheControl.FORCE_CACHE)
                .build();
    }

    Response response = chain.proceed(request);

    if (NetWorkHelper.isNetConnected(MainApplication.getContext())) {
        int maxAge = 60 * 60; // read from cache for 1 minute
        response.newBuilder()
                .removeHeader("Pragma")
                .header("Cache-Control", "public, max-age=" + maxAge)
                .build();
    } else {
        int maxStale = 60 * 60 * 24 * 28; // tolerate 4-weeks stale
        response.newBuilder()
                .removeHeader("Pragma")
                .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
                .build();
    }
    return response;
  }
}

  //设置缓存100M
        Cache cache = new Cache(new File(MainApplication.getContext().getCacheDir(),"httpCache"),1024 * 1024 * 100);
        return new OkHttpClient.Builder()
            .cache(cache)
            .addNetworkInterceptor(new HttpCacheInterceptor())
            .build();
复制代码

这段代码知足不了个人需求，而且会发现，有些状况离线的时候缓存过时的时间不可靠，有些状况在线的时候缓存不可用。对于个人需求不可兼得。（故网上有人还分了2种不一样状况的写法来针对不一样的需求，但我想，为何不综合起来呢？）

对于这段代码疑惑点： 一、max-age是啥，maxStale是啥，他们的区别是啥？ 二、为何没有网络的状况下，request要cacheControl.FORCE_CACHE 三、为何又要对response设置header的cache-control，到底request的设置跟response的设置有什么区别？ 四、addNetInterceptor和addInterceptor有什么区别？

解答： 一、max-age是啥，maxStale是啥，他们的区别是啥？

maxAge和maxStale的区别在于： maxAge:没有超出maxAge,无论怎么样都是返回缓存数据，超过了maxAge,发起新的请求获取数据更新，请求失败返回缓存数据。 maxStale:没有超过maxStale，无论怎么样都返回缓存数据，超过了maxStale,发起请求获取更新数据，请求失败返回失败

二、为何没有网络的状况下，request要cacheControl.FORCE_CACHE

public static final CacheControl FORCE_CACHE = new Builder() .onlyIfCached() .maxStale(Integer.MAX_VALUE, TimeUnit.SECONDS) .build(); 能够看到FORCE_CACHE是设置了maxStale的最大时间为interger的最大时间，因此，意思就是不管如何，都不会超过这个时间，因此就是一直（强制）拿缓存，也是想要实现缓存的正确逻辑

通常控制缓存有两种方式： 一、在request里面去设置cacheControl()策略 二、在header里面去添加cache-control

后面也会看到，在request里面设置header的cache-control和调用cacheControl方法来设置实际上是同样的，咱们就是经过在request里面来控制无网缓存的maxStale过时时间的

三、为何又要对response设置header的cache-control，到底request的设置跟response的设置有什么区别？

其实我到如今都尚未搞清楚，为啥那些人要这样写，只是后面我在测试的过程当中推断出来，有网的时候和无网的时候对于interceptor的调用是不一样的，产生的结果也是不一样的。好比request设置的时候就对无网缓存及其时间控制有效，response就不行

四、addNetInterceptor和addInterceptor有什么区别？

addNetInterceptor是添加网络拦截器，addInterceptor是添加应用拦截器，若是看到okhttp的流程分析的知道：应用拦截器是在网络拦截器前执行的。

若是我使用的是addNetInterceptor： 一、有网的状况下，能够在期限内拿到缓存，而没有去请求接口（经过测试数据库的数据改动来判断的） 二、没有网的状况下，直接就ConnectException了，根本不会走到interceptor里面去了。（网上不少人都提出了这样的问题）

若是我使用的是addInterceptor: 一、有网的状况下，明明设置的是60秒，可是每次都没有去拿缓存而都是请求的接口。（经过测试数据库的数据改动来判断的） 二、没有网的状况下，能够拿到缓存数据（猜测：多是由于应用拦截器在网络拦截器前执行，没有网的状况下，自己就执行不到网络拦截器里面去），可是缓存过时时间是“永久”，由于FORCE_CACHE里面已经设置为了integer的最大值，21亿秒左右，堪称永久 可是，依旧没有办法控制无网时候的缓存过时时间

面对这些个问题，我也是很无奈。只得不停地尝试，不停地摸索。因而就在尝试的过程当中发现了它的一些规则，因而最终写出了一个自认为“万全”的方法。

• 既然想要有网的状况下拿缓存，那么就须要addNetInterceptor，若是须要无网的状况下拿缓存，就须要addInterceptor，因此不如直接作两个interceptor吧！
• 另外，若是想要控制有网的时候不去读取缓存，能够直接经过在response里设置maxAge=0来实现。
• 这里经过大量实验发现，只有在request去设置其maxStale才能控制无网时候的缓存时间，在response里面去控制是不行的！

延伸

若是无网的时候，stale缓存时间过了，会怎么样呢？ 会报504错误（属于正常的逻辑）。

最后

欢迎留言，欢迎提问题、交流。