Android使用rxjava封装重试处理工具类

项目地址

github：RetryWhenDemo

gitee：RetryWhenDemo: 定时重试执行的封装

针对需求：

针对一些需要操作重试的场景，比如说网络请求。

优点：

1、可以灵活配置各次重试间隔时间、处理和回调线程；
2、回调结果数据和请求参数都是使用泛型，可自定义；
3、使用AutoDispose，防止内存泄漏；
4、可以停止执行。

使用讲解：

来看看具体调用

        //判断是否正在进行
        if (disposable != null && !disposable.isDisposed()) {
            return;
        }

        disposable = RetryWhenDoOperationHelper.getInstance()
                //是否调试打印日志
                .setIsDebug(true)
                //延迟执行时间，默认为0，不延迟
                .setDelay(2)
                //此处参数意义为：第一次失败，3秒后重试；第二次失败，2秒后重试，第三次失败1秒后重试
                //重试列表，即每次重试相隔的时间  默认3秒重试一次
                .setDelayTimeList(Arrays.asList(3, 2, 1))
                //单位
                .setUnit(TimeUnit.SECONDS)
                // 执行线程 默认io线程
                .setSubscribeOnScheduler(Schedulers.io())
                //回调线程  默认主线程
                .setObserveOnScheduler(AndroidSchedulers.mainThread())
                //使用AutoDispose 防止内存泄漏
                .setOwner(this)
                //操作所传入的参数
                .setParam("这是请求参数")
                //实现操作暴露的接口  即需要重试的操作
                //操作暴露的接口  注意此处使用弱引用 所以不要以局部变量作为参数，否则很快被回收
                .setOnDoOperationListener(new OnDoOperationListener<String, SimpleFailedBean, String>() {

                    /**
                     * 进行操作
                     *
                     * @param str 操作所传入的参数
                     * @param callBack 每次操作的回调  注意与上面最终的回调区分 ；其中回调的失败、成功的数据类型可以自定义 F, S
                     */
                    @Override
                    public void onDoOperation(String str, CallBack<SimpleFailedBean, String> callBack) {
                        //此处进行操作，可异步，也可同步；最终CallBack回调结果即可
                        //此处模拟一个异步操作
                        count++;
                        Log.i(TAG, "doAsyncOperation: " + Thread.currentThread() + " 处理参数为： " + str + " count:" + count);
                        if (count > 3) {
                            callBack.onSuccess("成功");
                            return;
                        }
                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                SimpleFailedBean simpleFailedBean = new SimpleFailedBean();
                                simpleFailedBean.setCodeStr("111");
                                simpleFailedBean.setMsgStr("传入参数为：" + str + "，但是处理失败了！");
                                callBack.onFailed(simpleFailedBean);
                            }
                        }).start();
                    }
                })
                // 操作的回调 其中失败成功的数据结构是个泛型，可以自己定义
                //重试结束，最终的回调
                .setFinalCallBack(new CallBack<SimpleFailedBean, String>() {
                    @Override
                    public void onFailed(SimpleFailedBean failedBean) {
                        Log.i(TAG, "final onFailed " + Thread.currentThread() + "  simpleFailedBean:" + JsonUtils.javabeanToJson(failedBean));
                    }

                    @Override
                    public void onSuccess(String successBean) {
                        Log.i(TAG, "final onSuccess: " + Thread.currentThread() + "  " + successBean);
                    }
                })
                //构建对象
                .build()
                //执行操作
                .doRetryWhenOperation();

其中操作参数setParam(T t)、操作方法接口OnDoOperationListener<T, F, S> 、最终回调接口CallBack<F, S>都是使用泛型。

    /**
     * 传入参数
     *
     * @param t
     * @return
     */
    public Builder setParam(T t) {
        this.t = t;
        return this;
    }  }

/**
 * 操作暴露的接口
 *
 * @param <T> 传入参数
 * @param <F> 失败回调数据结构
 * @param <S> 成功回调数据结构
 */
public interface OnDoOperationListener<T, F, S> {

    /**
     * 进行操作
     *
     * @param t        操作所传入的参数
     * @param callBack 每次操作的回调  注意与上面最终的回调区分 ；其中回调的失败、成功的数据类型可以自定义 F, S
     */
    void onDoOperation(T t, CallBack<F, S> callBack);
}

/**
 * 操作的回调
 *
 * @param <F> 失败的回调数据
 * @param <S> 成功的回调数据
 */
public interface CallBack<F, S> {
    void onFailed(F failedBean);

    void onSuccess(S successBean);
}

其中的每个T、F、S类型都要对应上。

这里已经做了一个简单失败数据结构的实现，可以直接使用。

/**
 * 实现一个简单的失败数据
 */
public class SimpleFailedBean {
    private String codeStr;
    private String msgStr;

    public String getCodeStr() {
        return codeStr;
    }

    public void setCodeStr(String codeStr) {
        this.codeStr = codeStr;
    }

    public String getMsgStr() {
        return msgStr;
    }

    public void setMsgStr(String msgStr) {
        this.msgStr = msgStr;
    }
}

如果需要停止请调用

//停止操作  停止执行，停止回调
retryWhenDoOperationHelper.stopNow();

打成jar包使用

项目中已经配置好，可以直接生成jar包使用。

1、打开retrywhendo目录下的build.gradle文件，更改jar包版本号；

2、在AndroidStudio->Terminal中输入命令并回车：

gradlew makeJar

3、如果是在公用的library中依赖jar包，为确保其他module中能使用，还需要添加依赖

    // RxJava
    api 'io.reactivex.rxjava3:rxjava:3.1.6'

    // AutoDispose 2.x https://uber.github.io/AutoDispose/
    api 'com.uber.autodispose2:autodispose-android:2.0.0'
    api 'com.uber.autodispose2:autodispose-androidx-lifecycle:2.0.0'
    api 'com.google.code.gson:gson:2.8.5'

使用grade依赖

1、工程的build.gralde 的buildscript和allprojects新建

repositories {  
    mavenCentral()  
    maven { url 'https://jitpack.io' }  
}

2、module 的 build.gradle 中添加

dependencies {
    implementation 'com.gitee.DragonStream:RetryWhenDemo:v1.1.0'
}