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();
}
};
}
addNetworkInterceptor和addInterceptor
两个方法同样是添加拦截器，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;
}
}
}
