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
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拦截器
主要是拦截操作，包括控制缓存的最大生命值，控制缓存的过期时间。
两个操作都是在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 很强大，能帮我处理很多复杂的场景，如果熟练使用的话，那么能提升我们的开发效率。
如果无聊的话可以看看原理：
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 = 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(...)==>执行在主线程，创建观察者，作为事件传递的终点处理事件
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()
@Override
public void onDestroy() {
RxBus.getInstance().unregister(BaseListFragment.TAG, observable);
super.onDestroy();
}