Retrofit实现重试机制（自定义Interceptor或封装callback）

最近在一个项目需求中，涉及到网络请求能有重试机制，而我们项目中网络请求使用的是Retrofit框架，以前也没做过这种，老大提示了下说可以用拦截器Interceptor或者封装Callback实现。

自定义Interceptor

废话少说，直接上代码

public class OkHttpRetryInterceptor implements Interceptor{

    private int mMaxRetryCount;
    private long mRetryInterval;

    public OkHttpRetryInterceptor(int maxRetryCount, long retryInterval) {
        mMaxRetryCount = maxRetryCount;
        mRetryInterval = retryInterval;
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = doRequest(chain, request);
        int retryNum = 1;
        while(((response==null)||response.isSuccessful())&&retryNum<=mMaxRetryCount){
            try {
                Thread.sleep(mRetryInterval);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }C
            retryNum++;
            response = doRequest(chain, request);

        }
        return response;
    }

    private Response doRequest(Chain chain, Request request) {
        try {
            return chain.proceed(request);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static class Builder {

        private int mRetryCount = 1;
        private long mRetryInterval = 1000;

        public Builder buildRetryCount(int retryCount){
            this.mRetryCount = retryCount;
            return this;
        }

        public Builder buildRetryInterval(long retryInterval){
            this.mRetryInterval = retryInterval;
            return this;
        }

        public OkHttpRetryInterceptor build(){
            return new OkHttpRetryInterceptor(mRetryCount,mRetryInterval);
        }

    }

}

OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .addInterceptor(new OkHttpRetryInterceptor.Builder()
                    .buildRetryCount(retryCount)
                    .buildRetryInterval(retryInterval)
                    .build())
            .build();

思路解释：

1. 自定义了一个OkHttpRetryInterceptor类，实现Interceptor接口
2. 定义mMaxRetryCount ，mRetryInterval 两个成员变量用于保存最大重试次数和重试间隔，并利用Build模式对外提供自定义这两个变量的接口。
3. 重试机制最核心的部分是实现了Interceptor接口的intercept(Chain chain)方法，该方法提供了一个Chain类型的对象，Chain对象中可以获取到Request对象，而调用Chain对象的proceed方法（该方法接收一个Request对象）就可发起一次网络请求，该方法返回Response对象。
4. 通过上述返回的Response对象可判断请求结果，如果失败则利用Thread.sleep相应的间隔时间之后，再调用Chain对象的proceed方法再发起一次，如此循环到请求成功或最大重试次数之后返回。
5. 最后在OkHttpClient的对象构造时加入自定义的OkHttpRetryInterceptor即实现了重试机制。

封装Callback

public abstract class RetryCallback<T> implements Callback<T> {

    private static final String TAG = RetryCallback.class.getSimpleName();

    private int mRetryCount;
    private long mRetryInterval;

    private int mCurrentRetryCount;

    private boolean isExecuting;

    private Call<T> mCall;

    private Timer timer = new Timer();

    public RetryCallback(Call<T> call, int retryCount, long retryInterval) {
        isExecuting = true;
        mCall = call;
        mRetryCount = retryCount;
        mRetryInterval = retryInterval;
    }

    @Override
    public final void onResponse(@NonNull Call<T> call, @NonNull Response<T> response) {
        MLog.i(TAG,"onResponse");
        isExecuting = false;
        if (!response.isSuccessful() && mCurrentRetryCount < mRetryCount) {
            mCurrentRetryCount++;
            retryRequest(call);
        } else {
            onRequestResponse(call, response);
        }
    }

    @Override
    public final void onFailure(@NonNull Call<T> call, @NonNull Throwable t) {
        MLog.i(TAG,"onFailure");
        isExecuting = false;
        if (mCurrentRetryCount < mRetryCount) {
            mCurrentRetryCount++;
            retryRequest(call);
        } else {
            onRequestFail(call, t);
        }
    }

    private void retryRequest(final Call<T> call) {
        MLog.i(TAG,"retryRequest");
        onStartRetry();
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                synchronized (RetryCallback.this){
                    mCall = call.clone();
                    mCall.enqueue(RetryCallback.this);
                    isExecuting = true;
                }
            }
        };
        timer.schedule(timerTask, mRetryInterval);

    }

    public void cancelCall(){
        synchronized (this){
            if (!isExecuting){
                timer.cancel();
            }else {
                mCall.cancel();
            }
        }
    }

    public abstract void onRequestResponse(Call call, Response response);

    public abstract void onRequestFail(Call call, Throwable t);

    public abstract void onStartRetry();
}

这种方式是基于在Retrofit的异步请求方法enqueue中，需要传入的一个Callback类型的对象参数。

在Callback接口中有两个方法，onResponse和onFailure。在这两个方法中都能拿到一个Call类型的对象，该对象其实就是最开始发起请求时构造的Call对象，用以再次发起网络请求，这就是该方式实现重试机制的基础。

当通过Callback的两个回调接口判断请求失败时，则利用Timer延时相应的重试间隔，这里需要注意，因为一个Call对象只能使用一次，回调中拿到的Call对象是前一次请求使用过的，于是就需要调用Call的clone方法克隆出一个相同的Call对象。再调用Call的enqueue方法发起请求，这样就实现了重试机制。