前言
封装作为面向对象的三大基本特征之一，我们在使用RxJava的时候也必然涉及到封装。
但是Rx是一种数据流链式结构的编程思想，我们在封装时应该不能打断其链式结构。
封装前
如果你有看过我的 使用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类，小伙伴们可随意定制和拓展～
