×

RxJava简洁封装之道

96
YoKey
2016.05.05 14:49* 字数 844

前言

封装作为面向对象的三大基本特征之一,我们在使用RxJava的时候也必然涉及到封装。

但是Rx是一种数据流链式结构的编程思想,我们在封装时应该不能打断其链式结构。

ReactiveX

封装前

如果你有看过我的 使用RxJava优雅的处理服务器返回异常 这篇简书的话,里面有类似下面这样的代码:

  _apiService.login(mobile, verifyCode)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnTerminate(() -> hideLoadingDialog())
            .flatMap(result -> {
                if (result.status == RESTResult.FAILURE) {
                    int code = result.code;
                    // 根据不同code进行不同处理
                    ...
                    return Observable.error(new ServerException(result.message));
                }
                return Observable.just(result.data);
            })
            .subscribe(new Action1<User>() {
                    @Override
                    public void call(User user) {
                       // user对象
                    }
              }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        throwable.printStackTrace();

                        if (e instanceof ServerException){
                           Toast.makeText(_context, e.getMessage(), Toast.LENGTH_SHORT).show();
                        } else{
                           if (!NetUtil.checkNet(MyApplication.getInstance())) {
                               Toast.makeText(_context, "网络不可用!", Toast.LENGTH_SHORT).show();
                            }else{
                               Toast.makeText(_context, "请求失败,请稍后重试", Toast.LENGTH_SHORT).show();
                            }
                        }
                    }  
              });

上面的代码看起来有点“脏”,一些地方完全可以封装一下,比如:
1、线程的处理,可以进行封装;

2、服务器返回格式一般都是固定的,对服务器返回的状态作处理,可以进行封装;

3、onError里对异常的处理,可以进行封装.

封装方案

1、封装 Rx线程相关

这个我想很多小伙伴都很熟悉,使用compose()操作符!

compose()里接收一个Transformer对象,Transformer继承自Func1<Observable<T>, Observable<R>>,可以通过它将一种类型的Observable转换成另一种类型的Observable。

下面是我的RxSchedulersHelper:

/**
 * 处理Rx线程
 * Created by YoKey.
 */
public class RxSchedulersHelper {

    public static <T> Observable.Transformer<T, T> io_main() {
        return new Observable.Transformer<T, T>() {
            @Override
            public Observable<T> call(Observable<T> tObservable) {
                return tObservable
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread());
            }
        };
    }
}

使用前:

  _apiService.login(mobile, verifyCode)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .//省略

使用后:

  _apiService.login(mobile, verifyCode)
            .compose(RxSchedulersHelper.io_main())
            .//省略

以后任何使用
.subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread())
的地方都可以使用.compose(RxSchedulersHelper.io_main())代替啦。

2、封装 处理服务器返回数据

我们把代码里的flatMap()操作符内的内容,作为静态方法提到一个Helper类里,即完成封装。

不过我的做法有点不一样,我还是用了compose+Transformer,在flatMap外包了一层,即:

/**
 * Rx处理服务器返回
 * Created by YoKey.
 */
public class RxResultHelper {

    public static <T> Observable.Transformer<RESTResult<T>, T> handleResult() {
        return new Observable.Transformer<RESTResult<T>, T>() {
            @Override
            public Observable<T> call(Observable<RESTResult<T>> tObservable) {
                return tObservable.flatMap(
                        new Func1<RESTResult<T>, Observable<T>>() {
                            @Override
                            public Observable<T> call(RESTResult<T> result) {
                                if (result.status == RESTResult.SUCCESS) {
                                    return Observable.just(result.getData());
                                } else if (result.status == RESTResult.SIGN_OUT) {
                                    // 处理被踢出登录情况
                                    return Observable.error(new ReloginException());
                                } else {
                                    return Observable.error(new ServerException(result.message));
                                }
                                return Observable.empty();
                            }
                        }
                );
            }
        };
    }
}

使用后:

  _apiService.login(mobile, verifyCode)
            .compose(RxSchedulersHelper.io_main())
            .compose(RxResultHelper.handleResult())
            .//省略

因为我们服务器的返回的数据格式一般都是一致的,所有我们每个网络请求都可以使用compose(RxResultHelper.handleResult())来处理服务器返回。

这里我在flatMap外面包了一层compose,原因是我把封装的部分都作为一个Transformer,这样封装的部分都是使用compose操作符,代码看起来更加清晰,当然你也可以直接使用flatMap,即.flatMap(RxResultHelper.handleResult())(handleResult方法需要更改为flatMap的Func1方法)

3、封装 Subscriber,对异常进行封装

我们已经处理服务器返回,可能有各种各样的异常,比如:
1、网络异常
2、服务器连接异常
3、接口请求参数等异常

我们可以封装一个Subscriber对其进行预处理,让调用者只需关心是Log还是Toast错误消息等行为即可。

/**
 * 封装Subscriber
 * Created by YoKey.
 */
public abstract class RxSubscriber<T> extends Subscriber<T> {

    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {
        e.printStackTrace();

        if (e instanceof ServerException) {
            // 服务器异常
            msg = e.getMessage();
        } else if(e instanceof ReloginException){
           // 踢出登录
        }else if (throwable instanceof UnknownHostException) {
            msg = "没有网络...";
        } else if (throwable instanceof SocketTimeoutException) {
            // 超时
           msg = "超时...";
        }else{
            msg = "请求失败,请稍后重试...");
        }
        _onError(msg);
    }

    @Override
    public void onNext(T t) {
        _onNext(t);
    }

    public abstract void _onNext(T t);

    public abstract void _onError(String msg);
}

使用后:

  _apiService.login(mobile, verifyCode)
            .//省略
            .subscribe(new RxSubscriber<User user>() {
                @Override
                public void _onNext(User user) {
                    // 处理user
                }

                @Override
                public void _onError(String msg) {
                    ToastUtil.showShort(mActivity, msg);    
              });

这样使用RxSubscriber之后,我们在onNext里只关心对数据的处理,在onError里只关心发生异常该做哪些后续操作即可。

封装后

最后我们再看下经过我们的封装后,文章开头的那块“脏”代码会变成下面这样:

  _apiService.login(mobile, verifyCode)
            .compose(RxSchedulersHelper.io_main())
            .compose(RxResultHelper.handleResult())
            .doOnTerminate(() -> hideLoadingDialog())
            .subscribe(new RxSubscriber<User user>() {
                @Override
                public void _onNext(User user) {
                    // 处理user
                }

                @Override
                public void _onError(String msg) {
                    ToastUtil.showShort(mActivity, msg);    
              });

是不是神清气爽了呢?!

当然不仅这里的代码会变得简洁,所有使用Rx处理网络的代码都可以使用上面3个RxHelper类,小伙伴们可随意定制和拓展~

参考资料:
小鄧子:【译】避免打断链式结构:使用.compose( )操作符

RxJava随笔
Web note ad 1