Android-Retrofit-超时-重试-缓存-拦截器

2018-02-27 11:33:45来源:https://www.jianshu.com/p/ea2055db3dd3作者:栗子酱油饼人点击

分享


0. Thanks To

Retrofit使用详解(一)
Android Retrofit 2.0 的详细 使用攻略(含实例讲解)
Android Retrofit网络请求Service,@Path、@Query、@QueryMap、@Map...
急速开发系列——Retrofit实战技巧
retrofit2.0缓存设置
OkHttp自定义重试次数
okhttp 日志拦截器Logging-interceptor


1.超时
通过 OkHttpClient.Builder 去设置。
OkHttpClient client = new OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(20, TimeUnit.SECONDS)
.writeTimeout(20, TimeUnit.SECONDS)
.build();

传入builder设置:


Retrofit retrofit = new Retrofit.Builder()
.baseUrl("xxx") //设置网络请求的Url地址
.addConverterFactory(GsonConverterFactory.create()) //设置数据解析器
.client(client)
.build();

2.重试
通过Client设置重试,重试一次。
OkHttpClient client = new OkHttpClient.Builder()
.retryOnConnectionFailure(true)//默认重试一次,若需要重试N次,则要实现拦截器。
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(20, TimeUnit.SECONDS)
.writeTimeout(20, TimeUnit.SECONDS)
.build();
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("xxx") //设置网络请求的Url地址
.addConverterFactory(GsonConverterFactory.create()) //设置数据解析器
.client(client)
.build();

以上的重试只能重试一次,若需要重试N次,可以通过设置拦截器
/**
* 自定义的,重试N次的拦截器
* 通过:addInterceptor 设置
*/
public static class Retry implements Interceptor {
public int maxRetry;//最大重试次数
private int retryNum = 0;//假如设置为3次重试的话,则最大可能请求4次(默认1次+3次重试)
public Retry(int maxRetry) {
this.maxRetry = maxRetry;
}
@Override
public Response intercept(@NonNull Chain chain) throws IOException {
Request request = chain.request();
Response response = chain.proceed(request);
Log.i("Retry","num:"+retryNum);
while (!response.isSuccessful() && retryNum < maxRetry) {
retryNum++;
Log.i("Retry","num:"+retryNum);
response = chain.proceed(request);
}
return response;
}
}

当在有网络的情况下,网络是畅通的,但获取失败后,那么会跑以上的拦截了,重新尝试N次。


3.缓存

设置缓存的的两种方式


1) 通过添加 @Headers("Cache-Control: max-age=120") 进行设置。添加了Cache-Control 的请求,retrofit 会默认缓存该请求的返回数据一般来说,这种方法是针对特定的API进行设置。
@Headers("Cache-Control:public,max-age=120")
@GET("mobile/active")
Call<ResponseBody> getActive(@Query("id") int activeId);

这样我们就通过@Headers快速的为该api添加了缓存控制。120s内,缓存都是生效状态,即无论有网无网都读取缓存。


2)通过Interceptors实现缓存。


这两者实现原理一致,但是适用场景不同。通常是使用Interceptors来设置通用缓存策略,而通过@Header针对某个请求单独设置缓存策略。另外,一定要记住,retrofit 2.0底层依赖OkHttp实现,这也就意味着retrofit缓存的实现同样是借助OkHttp来的。另外,无论你是决定使用那种形势的缓存,首先要为OkHttpClient设置Cache,否则缓存不会生效(retrofit并未置默认缓存目录)。


public static Interceptor getCacheInterceptor() {
return new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
Response response = chain.proceed(request);
return response.newBuilder().header("Cache-Control","public,max-age=120").build();
}
};
}

addNetworkInterceptoraddInterceptor
两个方法同样是添加拦截器,addNetworkInterceptor添加的是网络拦截器,在网络畅通的时候会调用,而addInterceptor则都会调用。所以我们应该是在addInterceptor去写逻辑。


代码如下:


//声明缓存地址和大小
Cache cache = new Cache(this.getCacheDir(),10*1024*1024);
//构建 Client
OkHttpClient client = new OkHttpClient.Builder()
.retryOnConnectionFailure(true)
.addNetworkInterceptor(new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
Response response = chain.proceed(request);
return response.newBuilder().header("Cache-Control","public,max-age=20").build();
}
})
.cache(cache)
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(20, TimeUnit.SECONDS)
.writeTimeout(20, TimeUnit.SECONDS)
.build();
//构建 Retrofit
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("xxx") //设置网络请求的Url地址
.addConverterFactory(GsonConverterFactory.create()) //设置数据解析器
.client(client)
.build();
// 创建 网络请求接口 的实例
GetAppList request = retrofit.create(GetAppList.class);
Call<AppListBean> call = request.get(1,8);
call.enqueue(new Callback<AppListBean>() {
@Override
public void onResponse(Call<AppListBean> call, retrofit2.Response<AppListBean> response
if (response!=null && response.isSuccessful()) {
if (response.body()!=null && response.body().data!=null)
for (AppListBean.DataBean d :
response.body().data) {
LogUtils.i(TAG,d.toString());
}
}
}
@Override
public void onFailure(Call<AppListBean> call, Throwable t) {
LogUtils.i(TAG,t.getMessage());
}
});

而,现在我们需要这样的一个策略:在无网络的情况下读取缓存,而且网络下的缓存也有过期时间,有网络的情况下根据缓存的过期时间重新请求,修改拦截器的逻辑:
//参考:http://blog.csdn.net/changsimeng/article/details/54668884
OkHttpClient client = new OkHttpClient.Builder()
.addInterceptor(new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
if (!NetworkUtils.isConnected(MainActivity.this)) {
int maxStale = 4 * 7 * 24 * 60; // 离线时缓存保存4周,单位:秒
CacheControl tempCacheControl = new CacheControl.Builder()
.onlyIfCached()
.maxStale(maxStale, TimeUnit.SECONDS)
.build();
request = request.newBuilder()
.cacheControl(tempCacheControl)
.build();
}
return chain.proceed(request);
}
})
.addNetworkInterceptor(new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
Response originalResponse = chain.proceed(request);
int maxAge = 20; // 在线缓存,单位:秒
return originalResponse.newBuilder()
.removeHeader("Pragma")// 清除头信息,因为服务器如果不支持,会返回一些干扰信息,不清除下面无法生效
.removeHeader("Cache-Control")
.header("Cache-Control", "public, max-age=" + maxAge)
.build();
}
})
.cache(cache)
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(20, TimeUnit.SECONDS)
.writeTimeout(20, TimeUnit.SECONDS)
.build();

那么,有网络的情况下,缓存时间是:20秒。也就是在20秒内的请求都是获取本地的缓存。当网络断开后,会设置一个离线的缓存,为4周。


3)关于max-age和max-stale


maxAge :设置最大失效时间,失效则不使用


maxStale :设置最大失效时间,失效则不使用


max-stale在请求头设置有效,在响应头设置无效。


max-stale和max-age同时设置的时候,缓存失效的时间按最长的算。


4.拦截器
在上面大家已经看到过拦截器的用法了,自定义的拦截器需要复写以下的接口:
public Response intercept(Interceptor.Chain chain) throws IOException

其中的chain就是包含了,request和respone,所以你想要什么都可以从这里获取到。


Request request = chain.request();
Response response = chain.proceed(request);

这里示例写一个,实现打印回包的日志拦截器:
@Override
public Response intercept(@NonNull Chain chain) throws IOException {
Request request = chain.request();
long t1 = System.currentTimeMillis();//请求发起的时间
Response response = chain.proceed(request);
long t2 = System.currentTimeMillis();//收到响应的时间
//这里不能直接使用response.body().string()的方式输出日志
//因为response.body().string()之后,response中的流会被关闭,程序会报错,我们需要创建出一
//个新的response给应用层处理
ResponseBody responseBody = response.peekBody(1024 * 1024);
Log.i("CommonLog",response.request().url()+ " , use-timeMs: " + (t2 - t1) + " , data: "+responseBody.string());
return response;
}

5.最后
在上面的代码中,我们有用到一个判断当前是否连着网络的工具类:
 /**
* 判断网络是否连接
* <p>需添加权限 {@code <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>}</p>
*
* @param context 上下文
* @return {@code true}: 是<br>{@code false}: 否
*/
public static boolean isConnected(Context context) {
NetworkInfo info = getActiveNetworkInfo(context);
return info != null && info.isConnected();
}
/**
* 获取活动网络信息
*
* @param context 上下文
* @return NetworkInfo
*/
private static NetworkInfo getActiveNetworkInfo(Context context) {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
return cm.getActiveNetworkInfo();
}

附上本文所示例用的拦截器
/**
* <pre>
* author: Chestnut
* blog : http://www.jianshu.com/u/a0206b5f4526
* time : 2018/2/4 22:16
* desc :
* thanks To:
* dependent on:
* update log:
* </pre>
*/
public class XInterceptor {
/**
* 自定义的,重试N次的拦截器
* 通过:addInterceptor 设置
*/
public static class Retry implements Interceptor {
public int maxRetry;//最大重试次数
private int retryNum = 0;//假如设置为3次重试的话,则最大可能请求4次(默认1次+3次重试)
public Retry(int maxRetry) {
this.maxRetry = maxRetry;
}
@Override
public Response intercept(@NonNull Chain chain) throws IOException {
Request request = chain.request();
Response response = chain.proceed(request);
Log.i("Retry","num:"+retryNum);
while (!response.isSuccessful() && retryNum < maxRetry) {
retryNum++;
Log.i("Retry","num:"+retryNum);
response = chain.proceed(request);
}
return response;
}
}
/**
* 设置没有网络的情况下,
* 的缓存时间
* 通过:addInterceptor 设置
*/
public static class CommonNoNetCache implements Interceptor {
private int maxCacheTimeSecond = 0;
private Context applicationContext;
public CommonNoNetCache(int maxCacheTimeSecond, Context applicationContext) {
this.maxCacheTimeSecond = maxCacheTimeSecond;
this.applicationContext = applicationContext;
}
@Override
public Response intercept(@NonNull Chain chain) throws IOException {
Request request = chain.request();
if (!NetworkUtils.isConnected(applicationContext)) {
CacheControl tempCacheControl = new CacheControl.Builder()
.onlyIfCached()
.maxStale(maxCacheTimeSecond, TimeUnit.SECONDS)
.build();
request = request.newBuilder()
.cacheControl(tempCacheControl)
.build();
}
return chain.proceed(request);
}
}
/**
* 设置在有网络的情况下的缓存时间
* 在有网络的时候,会优先获取缓存
* 通过:addNetworkInterceptor 设置
*/
public static class CommonNetCache implements Interceptor {
private int maxCacheTimeSecond = 0;
public CommonNetCache(int maxCacheTimeSecond) {
this.maxCacheTimeSecond = maxCacheTimeSecond;
}
@Override
public Response intercept(@NonNull Chain chain) throws IOException {
Request request = chain.request();
Response originalResponse = chain.proceed(request);
return originalResponse.newBuilder()
.removeHeader("Pragma")// 清除头信息,因为服务器如果不支持,会返回一些干扰信息,不清除下面无法生效
.removeHeader("Cache-Control")
.header("Cache-Control", "public, max-age=" + maxCacheTimeSecond)
.build();
}
}
/**
* 设置一个日志打印拦截器
* 通过:addInterceptor 设置
*/
public static class CommonLog implements Interceptor {
//统一的日志输出控制,可以构造方法传入,统一控制日志
private boolean logOpen = true;
//log的日志TAG
private String logTag = "CommonLog";
public CommonLog() {}
public CommonLog(boolean logOpen) {
this.logOpen = logOpen;
}
public CommonLog(String logTag) {
this.logTag = logTag;
}
public CommonLog(boolean logOpen, String logTag) {
this.logOpen = logOpen;
this.logTag = logTag;
}
@Override
public Response intercept(@NonNull Chain chain) throws IOException {
Request request = chain.request();
long t1 = System.currentTimeMillis();//请求发起的时间
Response response = chain.proceed(request);
long t2 = System.currentTimeMillis();//收到响应的时间
if (logOpen) {
//这里不能直接使用response.body().string()的方式输出日志
//因为response.body().string()之后,response中的流会被关闭,程序会报错,我们需要创建出一
//个新的response给应用层处理
ResponseBody responseBody = response.peekBody(1024 * 1024);
Log.i(logTag, response.request().url() + " , use-timeMs: " + (t2 - t1) + " , data: " + responseBody.string());
}
return response;
}
}
}







最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台