Retrofit2+Rxjava2
需求是：
1、尽可能简洁
2、可控制不同请求的加载框，
3、错误统一处理
4、页面销毁时取消订阅
5、可根据不同请求处理不同的异常
最终效果：
BaseApi.getDefaultService()
.getNewArticle()
.map(new HuiquRxFunction<List<NewEntity>>())
.compose(RxSchedulers.<List<NewEntity>>io_main())
.subscribeWith(new RxObserver<List<NewEntity>>(getActivity(), "getNewArticle", 1, false) {
@Override
public void onSuccess(int whichRequest, List<NewEntity> newEntities) {
if (action == PullRecycler.ACTION_PULL_TO_REFRESH) {
mDataList.clear();
}
if (newEntities == null || newEntities.size() == 0) {
recycler.enableLoadMore(false);
} else {
// recycler.enableLoadMore(true);
mDataList.addAll(newEntities);
Log.e("ttt", "onResponse: " + newEntities.size());
adapter.notifyDataSetChanged();
}
recycler.onRefreshCompleted();
}
@Override
public void onError(int whichRequest, Throwable e) {
}
});
这个例子其中就包含了以上5点要求，其中大多是对RxObserver的处理。RxObserver实现Observer接口，在Rxjava2中作为观察者，在执行onNext之前先做一些处理，就能相应地减少在View层的处理。
public abstract class RxObserver<T> implements Observer<T> {
private RxManager mRxManager;
private int mWhichRequest;
private String mKey;
private boolean isShowDialog;
private Dialog mDialog;
private Context mContext;
public RxObserver(Context context, String key, int whichRequest, boolean isShowDialog) {
this.mContext = context;
this.mKey = key;
this.isShowDialog = isShowDialog;
this.mWhichRequest = whichRequest;
mDialog = new ProgressDialog(context);
mDialog.setTitle("请稍后");
mRxManager = RxManager.getInstance();
}
@Override
public final void onSubscribe(Disposable d) {
mRxManager.add(mKey, d);
if (isShowDialog) {
mDialog.show();
}
onStart(mWhichRequest);
}
@Override
public final void onNext(T value) {
onSuccess(mWhichRequest, value);
}
@Override
public final void onError(Throwable e) {
if (mDialog.isShowing()) {
mDialog.dismiss();
}
if (e instanceof EOFException || e instanceof ConnectException || e instanceof SocketException || e instanceof BindException || e instanceof SocketTimeoutException || e instanceof UnknownHostException) {
Toast.makeText(mContext, "网络异常，请稍后重试！", Toast.LENGTH_SHORT).show();
} else if (e instanceof ApiException) {
onError(mWhichRequest, e);
} else {
Toast.makeText(mContext, "未知错误！", Toast.LENGTH_SHORT).show();
}
}
@Override
public final void onComplete() {
if (mDialog.isShowing()) {
mDialog.dismiss();
}
}
public abstract void onSuccess(int whichRequest, T t);
public abstract void onError(int whichRequest, Throwable e);
public void onStart(int whichRequest) {
}
}
一、RxObserver参数说明：
- key：key是用来区分不同类中联网的CompositeDisposable的，以便在这个类销毁时，可以取消该类中订阅关系，建议采用包名+类名作为key
- whichRequest：区分不同的请求，用于多个联网请求结束后对不同请求的处理。
- isShowDialog：是否显示加载框，RxObserver内部实例化了一个加载框，可根据需求设置是否显示。
RxObserver实现了Observer的四个方法
void onSubscribe(@NonNull Disposable d);
void onNext(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
1、onSubscribe(Disposable d)方法，相当于Rxjava1中的onStar()方法，其中的参数是Disposable ，用于取消该订阅关系，所以在方法中把它添加进了RxManager中,以方便取消订阅。同时也判断了isShowDialog了是否显示加载框，添加了一个方法onStart()方法，同时把mWhichRequest传出去方便在外部回调。
2、onNext(T value)方法比较简单，联网结果成功返回会执行，参数是结果。在这个方法中写了抽象方法onSuccess(mWhichRequest, value);同样把mWhichRequest传出，方便处理。
3、onComplete()方法是联网正常返回，联网过程结束时执行，在该方法中判断这个加载框的显示与否。
-
4、onError(Throwable e)方法稍微复杂一些，整个过程出现异常是会执行这个方法，这里不只是联网的过程，还包括对返回数据处理上的异常，比如json解析失败等。如果发生异常就不会再走onComplete()，所以同样需要判断加载框的显示。下面的是对一些异常的处理，这里只处理了一些网络方面的异常，可以根据需求添加异常判断，这里处理的异常只是出现意外的异常。这里还自定义了一个异常ApiException，抛出这个异常都是业务上的问题，比如空数据，格式不对等等，这个是根据返回的状态值判断的，方便统一处理错误信息。
public class HuiquRxFunction<T> implements Function<HuiquResult<T>, T> { @Override public T apply(@NonNull HuiquResult<T> huiquResult) throws Exception { Log.e("dawn", "apply: " ); int code = huiquResult.getCode(); if (code != 1) { switch (code) { case 0: throw new ApiException(huiquResult.getMsg()); } } Log.e("dawn." + getClass().getSimpleName(),huiquResult.getMsg()); return huiquResult.getBody(); } }
这就是这个ApiException产生的地方，也是这句话map(new HuiquRxFunction<List<NewEntity>>())用到的逻辑，这个是在Retrofit2解析json后得到HuiquResult<T>，转化成T的map操作符，在转化过程中根据huiquResult的状态值，判断是返回T还是抛出ApiException异常，这里可以根据返回状态值添加不同的错误提示信息，异常会在RxObserver的onError(Throwable e)被捕捉，统一传到View层去处理。
二、compose(RxSchedulers.<Calendar>io_main())
这句话是切换了一下线程，等同于这两句
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
执行在io线程，表现在安卓主线程。RxSchedulers完整的代码：
public class RxSchedulers {
public static <T> ObservableTransformer<T, T> io_main() {
return new ObservableTransformer<T, T>() {
@Override
public ObservableSource<T> apply( Observable<T> upstream) {
return upstream.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}
};
}
}
还有一个类RxManager，这个类是用来管理订阅的，在RxObserver中，执行onSubscribe方法时，把参数Disposable添加进了RxManager中，看一下RxManager对应的add方法：
public void add(String key, Disposable disposable) {
Set<String> keySet = map.keySet();
if (keySet.contains(key)) {
CompositeDisposable compositeDisposable = map.get(key);
compositeDisposable.add(disposable);
} else {
CompositeDisposable compositeDisposable = new CompositeDisposable();
compositeDisposable.add(disposable);
map.put(key,compositeDisposable );
}
}
这里面，给每一个key初始化了一个CompositeDisposable并存入map，把这个Disposable 加入到对应的CompositeDisposable 中。
RxManager中还有一个方法clear(String key)：
public void clear(String key) {
Set<String> keySet = map.keySet();
if (keySet.contains(key)) {
CompositeDisposable compositeDisposable = map.get(key);
compositeDisposable.clear();
map.remove(key);
}
}
根据key得到对应的CompositeDisposable ，并执行compositeDisposable.clear()来取消compositeDisposable中所有的订阅关系。这个RxManager的clear方法建议放在BaseActivity的onDestroy()方法中，这也是为什么前面说的建议这个key采用包名+类名的方式的原因，当这个类销毁的时候，该类中所有的联网订阅关系都会被取消，避免内存泄漏。为保证这个map唯一，RxManager采用了单利模式：
private static RxManager rxManager;
private Map<String, CompositeDisposable> map;
private RxManager() {
map = new HashMap<>();
}
public static RxManager getInstance() {
if (rxManager == null) {
rxManager = new RxManager();
}
return rxManager;
}
BaseActivity的onDestroy：
@Override
protected void onDestroy() {
super.onDestroy();
RxManager.getInstance().clear(TAG);
}
以上就是封装的netWork module的基本使用。
