Retrofit2+Rxjava2
需求是：
1、尽可能简洁
2、可控制不同请求的加载框，
3、错误统一处理
4、页面销毁时取消订阅
5、可根据不同请求处理不同的异常
最终效果：
BaseApi.getDefaultService()
.getNewArticle()
.map(new HuiquRxFunction>())
.compose(RxSchedulers.>io_main())
.subscribeWith(new RxObserver>(getActivity(), "getNewArticle", 1, false) {
@Override
public void onSuccess(int whichRequest, List 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 implements Observer {
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 HuiquRxFunctionimplements Function 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
二、compose(RxSchedulers.io_main())
这句话是切换了一下线程，等同于这两句
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
执行在io线程，表现在安卓主线程。RxSchedulers完整的代码：
public class RxSchedulers {
public static ObservableTransformer io_main() {
return new ObservableTransformer() {
@Override
public ObservableSource apply( Observable upstream) {
return upstream.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}
};
}
}
还有一个类RxManager，这个类是用来管理订阅的，在RxObserver中，执行onSubscribe方法时，把参数Disposable添加进了RxManager中，看一下RxManager对应的add方法：
public void add(String key, Disposable disposable) {
Set 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 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 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的基本使用。