Rxjava1和2在网络封装时的一些区别

1.TransFormer的区别

在使用 Retrofit 和 Rxjava 处理网络流程时，一般会统一处理结果
BaseModel.java

public class BaseModel<T> {
    public String code;
    public String message;
    public T result;

    public boolean success(){
        return code.equals("0");
    }
}

接口返回的数据是这样的结构，code 为 0 时才是正常，实际 javabean 数据在 result 中，那么希望在数据到达 presenter 之前就处理好请求结果是正确的数据还是错误的数据，在Rxjava1.0时一般是这样的：

import rx.Observable;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Func1;
import rx.schedulers.Schedulers;

public class RxHelper {
    /**
     * 统一处理结果
     *
     * @param <T>
     * @return
     */
    public static <T> Observable.Transformer<BaseModel<T>, T> handleResult() {

        return new Observable.Transformer<BaseModel<T>, T>() {
            @Override
            public Observable<T> call(Observable<BaseModel<T>> tObservable) {
                return tObservable.flatMap(new Func1<BaseModel<T>, Observable<T>>() {
                    @Override
                    public Observable<T> call(BaseModel<T> result) {
                        if (result.success()) {
                            return createData(result.result);
                        } else {
                            return Observable.error(new ServerException(result.message));
                        }
                    }
                }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
            }
        };

    }

    private static <T> Observable<T> createData(final T data) {
        return Observable.create(new Observable.OnSubscribe<T>() {
            @Override
            public void call(Subscriber<? super T> subscriber) {
                try {
                    subscriber.onNext(data);
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        });

    }

}

Api.java

    @POST("/contact/update")
    Observable<BaseModel<Contact>> update(
            @Query("accountId") String accountId,
            @Query("userId") String userId);

presenter里使用时如下：

RetrofitFactory.getApi().check("1","1")
                .compose(RxHelper.<Contact>handleResult())
                .subscribe();

这样当数据获取到之后就会在 handleResult 方法里先统一判断结果，并顺便设置一下通用的网络请求线程切换；
如果在 Rxjava2.0 里，handleResult 方法如下：

public class RxHelper {
    /**
     * 统一处理结果
     *
     * @param <T>
     * @return
     */
    public static <T> ObservableTransformer<BaseModel<T>, T> handleResult() {
        return new ObservableTransformer<BaseModel<T>, T>() {
            @Override
            public ObservableSource<T> apply(Observable<BaseModel<T>> upstream) {
                return upstream.flatMap(new Function<BaseModel<T>, ObservableSource<T>>() {
                    @Override
                    public ObservableSource<T> apply(BaseModel<T> tBaseModel) throws Exception {
                        if (tBaseModel.success()) {
                            return createData(tBaseModel.data);
                        }
                        return Observable.error(new ServerException(tBaseModel.msg));
                    }
                }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
            }
        };
    }

    private static <T> ObservableSource<T> createData(final T data) {
        return Observable.create(new ObservableOnSubscribe<T>() {
            @Override
            public void subscribe(ObservableEmitter<T> e) {
                try {
                    e.onNext(data);
                    e.onComplete();
                } catch (Exception e1) {
                    e.onError(e1);
                }
            }
        });
    }

    public static <T> FlowableTransformer<GankHttpResponse<T>, T> handleResult() {   //compose判断结果
        return new FlowableTransformer<GankHttpResponse<T>, T>() {
            @Override
            public Flowable<T> apply(Flowable<GankHttpResponse<T>> httpResponseFlowable) {
                return httpResponseFlowable.flatMap(new Function<GankHttpResponse<T>, Flowable<T>>() {
                    @Override
                    public Flowable<T> apply(GankHttpResponse<T> tGankHttpResponse) {
                        if(!tGankHttpResponse.getError()) {
                            return createData(tGankHttpResponse.getResults());
                        } else {
                            return Flowable.error(new ApiException("服务器返回error"));
                        }
                    }
                }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
            }
        };
    }

    public static <T> Flowable<T> createData(final T t) {
        return Flowable.create(new FlowableOnSubscribe<T>() {
            @Override
            public void subscribe(FlowableEmitter<T> emitter) throws Exception {
                try {
                    emitter.onNext(t);
                    emitter.onComplete();
                } catch (Exception e) {
                    emitter.onError(e);
                }
            }
        }, BackpressureStrategy.BUFFER);
    }
}

上面代码里列出了两种情况，因为 Rxjava2.0 里有Observable 和 Flowable，那么Transformer 也要用与之对应的；

2.Subscribe 的区别

前面只是判断数据是否正常取到的统一处理，当数据获取到之后，希望再统一处理一些例如弹窗提示一类的逻辑，这时就在观察者里做统一处理了，Rxjava1.0处理如下：

import rx.Subscriber;

public abstract class RxSubscribe<T> extends Subscriber<T> {
    @Override
    public void onCompleted() {
    }

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

    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
        // 错误处理
        if (!AppUtils.isNetworkAvailable()) {
            _onError(mContext.getResources().getString(R.string.toast_text1));
        } else if (e instanceof ServerException) {
            _onError(e.getMessage());
        } else {
            _onError(mContext.getResources().getString(R.string.toast_text2) + e.getMessage());
        }
    }

    protected abstract void _onNext(T t);

    protected abstract void _onError(String message);

}

错误信息在这里统一判断处理，还有例如要在处理数据之前先缓存，就可以在onNext()里直接统一处理，使用时如下；

RetrofitFactory.getApi().check("1", "1")
                .compose(RxHelper.<Contact>handleResult())
                .subscribe(new RxSubscribe<Contact>(mContext) {
                    @Override
                    protected void _onNext(Contact result) {
                    }
                    @Override
                    protected void _onError(String message) {
                        ToastUtils.showT(message);
                    }
                });

Rxjava2.0 分 Observable 和 Flowable，如果接口返回的是 Observable，这里要用 DisposableObserver：

import io.reactivex.observers.DisposableObserver;

public abstract class RxSubscribe<T> extends DisposableObserver<T> {
    @Override
    public void onNext(T t) {
        _onNext(t);
    }
    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
        if (!AppUtils.isNetworkConnected()) {
            _onError("网络不可用");
        } else if (e instanceof ServerException) {
            _onError(e.getMessage());
        } else {
            _onError("未知错误");
        }
    }
    @Override
    public void onComplete() {
    }
    protected abstract void _onNext(T t);
    protected abstract void _onError(String message);
}

如果返回的是 Flowable，这里要换成继承 ResourceSubscriber，具体使用如下：

dataManager.appcategory()
    .compose(RxHelper.<List<AppCatetory>>handleResult())
    .subscribeWith(new RxSubscribe<List<AppCatetory>>() {
        @Override
        protected void _onNext(List<AppCatetory> appCatetories) {
            Logger.e(GsonUtils.toJson(appCatetories));
        }

        @Override
        protected void _onError(String message) {
        }
    })

3.subscribeWith 和 subscribe

用 subscribe 时，参数只能传 Rxjava自带的 Consumer 才会返回 Disposable，如想传上面这个自定义的观察者并且还要返回Disposable，需要用 subscribeWith；这个Disposable 常用来作取消请求使用：

import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;

/**
 * Created by Aislli on 2016/3/17.
 */
public class BasePresenter<V extends IBaseView> implements IBasePresenter{
    protected V mView;
    protected CompositeDisposable mCompositeDisposable;

    protected void addSubscribe(Disposable subscription) {
        if (mCompositeDisposable == null) {
            mCompositeDisposable = new CompositeDisposable();
        }
        mCompositeDisposable.add(subscription);
    }

    protected void unSubscribe() {
        if (mCompositeDisposable != null) {
            mCompositeDisposable.clear();
        }
    }

    public BasePresenter(V view) {
        this.mView = view;
    }

    @Override
    public void destroy() {
        this.mView = null;
        unSubscribe();
    }
}

子类里把网络请求的 Disposable 添加到CompositeDisposable，presenter对应的 Activity 关闭时，调用presenter 的destroy 方法取消请求：

addSubscribe(dataManager.appcategory()
             .compose(RxHelper.<List<AppCatetory>>handleResult())
             .subscribeWith(new RxSubscribe<List<AppCatetory>>() {
                 @Override
                 protected void _onNext(List<AppCatetory> appCatetories) {
                     Logger.e(GsonUtils.toJson(appCatetories));
                 }
                 @Override
                 protected void _onError(String message) {
                 }
             }));