Android 使用Retrofit2.0+OkHttp3.0实现缓存处理+Cookie持久化第三方库 _缓存处理

盛年不重来，一日难再晨，及时当勉励，岁月不待人。这篇文章主要讲述Android 使用Retrofit2.0+OkHttp3.0实现缓存处理+Cookie持久化第三方库相关的知识，希望能为你提供帮助。
1.Retrofit+OkHttp的缓存机制 1.1.第一点

在响应请求之后在 data/data/< 包名> /cache 下建立一个response 文件夹，保存缓存数据。

1.2.第二点

这样我们就可以在请求的时候，如果判断到没有网络，自动读取缓存的数据。

1.3.第三点

同样这也可以实现，在我们没有网络的情况下，重新打开App可以浏览的之前显示过的内容。

1.4.第四点

也就是：判断网络，有网络，则从网络获取，并保存到缓存中，无网络，则从缓存中获取。

1.5.github地址+参考文章
github地址：http://square.github.io/retrofit/
参考文章：让我的项目也是用RxJava+OkHttp+Retrofit
参考文章：Retrofit+RxJava+OkHttp让网络请求变得简单
最重要的参考文章：使用Retrofit2+OkHttp3实现缓存处理

2.缓存实现方式2.1.在build.gradle中引入Retrofit

compile ‘com.squareup.retrofit2:retrofit:2.1.0‘//retrofit compile ‘com.google.code.gson:gson:2.6.2‘//Gson 库 //下面两个是Rxjava 和Rxandroid compile ‘io.reactivex:rxjava:1.1.0‘ compile ‘io.reactivex:rxandroid:1.1.0‘ compile ‘com.squareup.retrofit2:converter-gson:2.1.0‘//转换器，请求结果转换成Model compile ‘com.squareup.retrofit2:adapter-rxjava:2.1.0‘//配合Rxjava 使用

2.2.先开启OkHttp缓存
在Retrofit2.0版本之后，Retrofit底层自动依赖了OkHttp，所以不用重复依赖Okhttp了。

File httpCacheDirectory = new File(MyApp.mContext.getCacheDir(), "responses"); int cacheSize = 10 * 1024 * 1024; // 10 MiB Cache cache = new Cache(httpCacheDirectory, cacheSize); OkHttpClient client = new OkHttpClient.Builder() .addInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR) .cache(cache).build();

这一步设置缓存路径以及缓存大小，其中addInterceptor是添加拦截器，下一步详细讲。

2.3.设置OkHttp拦截器
主要是拦截操作，包括控制缓存的最大生命值，控制缓存的过期时间。
【Android 使用Retrofit2.0+OkHttp3.0实现缓存处理+Cookie持久化第三方库】两个操作都是在Interceptor中进行的。

通过CacheControl控制缓存数据。

CacheControl.Builder cacheBuilder = new CacheControl.Builder(); cacheBuilder.maxAge(0, TimeUnit.SECONDS); //这个是控制缓存的最大生命时间 cacheBuilder.maxStale(365,TimeUnit.DAYS); //这个是控制缓存的过时时间 CacheControl cacheControl = cacheBuilder.build();

设置拦截器。

Request request = chain.request();
if(!StateUtils.isNetworkAvailable(MyApp.mContext)){ request = request.newBuilder() .cacheControl(cacheControl) .build(); }
Response originalResponse = chain.proceed(request);
if (StateUtils.isNetworkAvailable(MyApp.mContext)) { int maxAge = 60; // read from cache return originalResponse.newBuilder() .removeHeader("Pragma") .header("Cache-Control", "public ,max-age=" + maxAge) .build(); } else { int maxStale = 60 * 60 * 24 * 28; // tolerate 4-weeks stale return originalResponse.newBuilder() .removeHeader("Pragma") .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale) .build(); }

如果.maxAge(0,TimeUnit.SECONDS)设置的时间比拦截器长是不起效果，
如果设置比拦截器设置的时间短就会以这个时间为主，我觉得是为了方便控制。
.maxStale(365, TimeUnit.DAYS)设置的是过时时间，
我觉得okthhp缓存分成了两个来考虑，
一个是为了请求时直接拿缓存省流量，
一个是为了下次进入应用时可以直接拿缓存。

2.4.真实案例例子。

public class RetrofitFactory {private static final Object Object = new Object(); /** * 缓存机制 * 在响应请求之后在 data/data/< 包名> /cache 下建立一个response 文件夹，保持缓存数据。 * 这样我们就可以在请求的时候，如果判断到没有网络，自动读取缓存的数据。 * 同样这也可以实现，在我们没有网络的情况下，重新打开App可以浏览的之前显示过的内容。 * 也就是：判断网络，有网络，则从网络获取，并保存到缓存中，无网络，则从缓存中获取。 * https://werb.github.io/2016/07/29/%E4%BD%BF%E7%94%A8Retrofit2+OkHttp3%E5%AE%9E%E7%8E%B0%E7%BC%93%E5%AD%98%E5%A4%84%E7%90%86/ */ //这里是设置拦截器，供下面的函数调用，辅助作用。 private static final Interceptor cacheControlInterceptor = new Interceptor() {@Override public Response intercept(Chain chain) throws IOException { Request request = chain.request(); if (!NetWorkUtil.isNetworkConnected(InitApp.AppContext)) { request = request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build(); }Response originalResponse = chain.proceed(request); if (NetWorkUtil.isNetworkConnected(InitApp.AppContext)) { // 有网络时设置缓存为默认值 String cacheControl = request.cacheControl().toString(); return originalResponse.newBuilder() .header("Cache-Control", cacheControl) .removeHeader("Pragma") // 清除头信息，因为服务器如果不支持，会返回一些干扰信息，不清除下面无法生效 .build(); } else { // 无网络时设置超时为1周 int maxStale = 60 * 60 * 24 * 7; return originalResponse.newBuilder() .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale) .removeHeader("Pragma") .build(); } } }; private volatile static Retrofit retrofit; //这个人函数供外部调用，当请求数据时来调用 @NonNull public static Retrofit getRetrofit() { synchronized (Object) { if (retrofit == null) { // 指定缓存路径,缓存大小 50Mb Cache cache = new Cache(new File(InitApp.AppContext.getCacheDir(), "HttpCache"), 1024 * 1024 * 50); // Cookie 持久化 ClearableCookieJar cookieJar = new PersistentCookieJar(new SetCookieCache(), new SharedPrefsCookiePersistor(InitApp.AppContext)); OkHttpClient.Builder builder = new OkHttpClient.Builder() .cookieJar(cookieJar) .cache(cache) .addInterceptor(cacheControlInterceptor) .connectTimeout(10, TimeUnit.SECONDS) .readTimeout(15, TimeUnit.SECONDS) .writeTimeout(15, TimeUnit.SECONDS) .retryOnConnectionFailure(true); // Log 拦截器 if (BuildConfig.DEBUG) { builder = SDKManager.initInterceptor(builder); }retrofit = new Retrofit.Builder() .baseUrl(INewsApi.HOST) .client(builder.build()) .addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) .build(); } return retrofit; } } }

通过这样，我们就可以直接使用同一个Retrofit请求方法。
无论是最新数据还是换成数据，都可以转化为我们需要的对象，直接使用。
这里的SDK也是一个方便自己调试的拦截器，实现方法如下：

public class SDKManager { public static void initStetho(Context context){ Stetho.initializeWithDefaults(context); }public static OkHttpClient.Builder initInterceptor(OkHttpClient.Builder builder){ HttpLoggingInterceptor interceptor=new HttpLoggingInterceptor(); interceptor.setLevel(HttpLoggingInterceptor.Level.BODY); builder.addInterceptor(interceptor); return builder; } }

这里的HttpLoggingInterceptor是okhttp3中自带的一个谷歌浏览器调试方法类。
比较简单实用。
所以这里就是将缓存控制的拦截器以及日志拦截器加到OkHttpClient.Builder中了。
将Cookie持久化也加到OkHttpClient.Builder中了。
就是要用的的方法加到这个OkHttpClient.Builder中就行了。

3.Cookie持久化的第三方库使用方法3.1.Cookie持久化的第三方库==> PersisitentCookieJar
github地址：https://github.com/franmontiel/PersistentCookieJar
参考文章：Android关于Https中Cookie的使用（PersistentCookieJar）
关于Cookie可以参考这篇文章：深入解析Cookie技术。
关于鸿洋大神封装的okhttputils也提供的cookie的持久化管理工具。

3.2.引入第三方包
在根目录的build.gradle加入如下支持：

allprojects { repositories { ... maven { url "https://jitpack.io" } } }

然后在项目依赖的build.gradle中添加如下代码：

dependencies { compile ‘com.github.franmontiel:PersistentCookieJar:v1.0.1‘ }

3.3.使用方法==> so easy.
首先需要在初始化时加入以下代码：

ClearableCookieJar cookieJar = new PersistentCookieJar(new SetCookieCache(), new SharedPrefsCookiePersistor(context));

然后在初始化OkHttpClient调用cookieJar，如下代码：

OkHttpClient okHttpClient = new OkHttpClient.Builder() .cookieJar(cookieJar) .build();

然后，服务器就可以发送Cookie给我们，我们进行永久保存（或者临时保存）
下一次请求时，服务器即可拿到Cookie进行数据查询操作了。

4.用Retrofit写一个网络请求上面讲OkHttpClient.Builder设置完毕后，用到了Retrofit来请求。

4.1.创建一个Retrofit实例。

Retrofit retrofit = new Retrofit.Builder() .baseUrl(INewsApi.HOST) .client(builder.build()) .addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) .build();

这里配置了接口baseUrl+addConverterFactory
baseUrl是我们请求的基地址。
addConverterFactory是默认提供的Gson转换器，写这个即可。
addCallAdapterFactory是默认提供的适配器工厂回调类，写这个即可。

4.2.创建一个实际接口。

public interface IJokeApi {/** * 获取段子正文内容 * http://www.toutiao.com/api/article/feed/?category=essay_joke& as=A115C8457F69B85& cp=585F294B8845EE1 */ @GET("api/article/feed/?category=essay_joke") Observable< JokeContentBean> getJokeContent( @Query("max_behot_time") String maxBehotTime, @Query("as") String as, @Query("cp") String cp); /** * 获取段子评论 * http://m.neihanshequ.com/api/get_essay_comments/?group_id=编号& count=数量& offset=偏移量 */ @GET("http://m.neihanshequ.com/api/get_essay_comments/?count=20") @Headers({"User-Agent:" + Constant.USER_AGENT_MOBILE}) Observable< JokeCommentBean> getJokeComment( @Query("group_id") String groupId, @Query("offset") int offset); }

说明：定义了一个方法getJokeContent,使用get请求方式，加上@GET 标签，
标签后面是这个接口的尾址,完整的地址应该是 baseUrl+尾址，
参数使用@Query标签，
如果参数多的话可以用@QueryMap标签，接收一个Map

4.3.用Retrofit创建接口实例的方法，如何调用接口中的方法进行网络请求。
数据怎么回调呢？
这里用了一个订阅关系Observable。
加入RxJava后的网络请求，返回不再是一个Call，而是一个Observable。
在Activity或者Fragment传入一个Subscriber建立订阅关系，就可以在onNext中处理结果了。

Subscription subscription = movieService.getTop250(0,20) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Subscriber< MovieSubject> () { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext(MovieSubject movieSubject) { mMovieAdapter.setMovies(movieSubject.subjects); mMovieAdapter.notifyDataSetChanged(); } });

RxJava 的好处是帮我处理线程之间的切换，
我们可以在指定订阅的在哪个线程，观察在哪个线程。
我们可以通过操作符进行数据变换。整个过程都是链式的，简化逻辑。
其中FlatMap 操作符还可以解除多层嵌套的问题。
总之，RxJava 很强大，能帮我处理很多复杂的场景，如果熟练使用的话，那么能提升我们的开发效率。

如果无聊的话可以看看原理：
参考文章：给Android开发者的RxJava详解。
参考文章：关于RxJava最友好地文章。

4.4.用Retrofit创建接口的实际方法。

@Override public void doLoadData(){ Map< String, String> map = ToutiaoUtil.getAsCp(); RetrofitFactory.getRetrofit().create(IJokeApi.class).getJokeContent(time, map.get(Constant.AS), map.get(Constant.CP)) .subscribeOn(Schedulers.io()) .map(new Function< JokeContentBean, List< JokeContentBean.DataBean.GroupBean> > () { @Override public List< JokeContentBean.DataBean.GroupBean> apply(@NonNull JokeContentBean jokeContentBean) throws Exception { List< JokeContentBean.DataBean> data = https://www.songbingjia.com/android/jokeContentBean.getData(); for (JokeContentBean.DataBean dataBean : data) { groupList.add(dataBean.getGroup()); } time = jokeContentBean.getNext().getMax_behot_tim() +""; return groupList; } }) .compose(view.< List< JokeContentBean.DataBean.GroupBean> > bindToLife()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Consumer< List< JokeContentBean.DataBean.GroupBean> > () { @Override public void accept(@NonNull List< JokeContentBean.DataBean.GroupBean> groupBeen) throws Exception { if (groupBeen.size() > 0) { doSetAdapter(); } else { doShowNoMore(); } } }, ErrorAction.error()); }

这是实际请求方法。
说白了，Retrofit.create是返回一个Observable< T> 对象。
因为在接口API中已经定义。
所以这里用订阅关系处理回调。
以前常用的方法是Call的回调，一个onSuccess表示网络成功请求，一个onFailure表示网络请求失败。
太low了。
现在用Observable< T> 来进行类似的操作。

这里Observable.subscribeOn==> 指定了被观察者执行的线程环境
map==> 使用map操作来完成类型转换，前者转换成后者。
compose()==> 方便多个流重复利用一系列操作符（这个我也不是特别理解）
observeOn(Android...MainThread)==> 将后面执行的线程环境切换为主线程，但这一句还在io线程
subscribe(...)==> 执行在主线程，创建观察者，作为事件传递的终点处理事件

关于Rxjava操作符compose()的理解，可以参考这篇文章。

5.关于RxJava的不理解的地方5.1.在用Retrofit返回的Observable< T> 中调用了一个compose方法。

.compose(view.< List< JokeContentBean.DataBean.GroupBean> > bindToLife())

5.2.然后这个方法定义在IBaseListView中。

/** * 绑定生命周期 */ < T> LifecycleTransformer< T> bindToLife();

5.3.执行bindToLife()地方在BaseFragment中。

/** * 绑定生命周期 */ @Override public < T> LifecycleTransformer< T> bindToLife() { return bindUntilEvent(FragmentEvent.DESTROY); }

bindUntilEvent方法定义在RxFragment中。

5.4.在BaseListFragment中实现了LazyLoadFragment懒加载中的fetchData抽象函数。

@Override public void fetchData() { observable = RxBus.getInstance().register(BaseListFragment.TAG); observable.subscribe(new Consumer< Integer> () { @Override public void accept(@NonNull Integer integer) throws Exception { adapter.notifyDataSetChanged(); } }); }

这里的方法和JokeContentPresenter处理器中请求数据的方法中的一段代码及其相似。

5.5.在BaseListFragment中重写了onDestroy()