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

2018-02-04 本文已影响533人 CokeNello

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;
        }
    }
}