1.由于RxJava1 和 RxJava2 同时引用会导致rxjava的jar包冲突，所以RxJava1和RxJava2推荐二选一，既然选了RxJava2,那么就将RxJava1的引用都改成RxJava2,同时搭配Retrofit使用，Retrofit引用的adapter-rxjava也改成adapter-rxjava2。

image.png

提示：如果有其他第三方库引用的版本不一致导致上述错误，可以在app 的 gradle文件的packagingOptions 中配置 exclude("META-INF/rxjava.properties")，解决第三方库重复打包造成META-INF 冲突。

image.png

//    compile 'io.reactivex:rxandroid:1.1.0'
//    compile 'io.reactivex:rxjava:1.1.0'
//    compile 'com.squareup.retrofit2:retrofit:2.1.0'
//    compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
//    compile 'com.squareup.retrofit2:converter-gson:2.1.0'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
    compile 'io.reactivex.rxjava2:rxjava:2.0.1'
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
    compile 'com.squareup.retrofit2:converter-gson:2.1.0'

2、Action 和 Func 的改变
RxJava1中 Action0-Action9 ,其中Action0 改成了Action,Action1改成的Consumer，Action2改名成了BiConsumer，Action3-Action9都不在使用了。

以Action1为例

Rxjava1
Action1<String> action = new Action1<String>(){
     @Override
      public void call(String s) {
          //需要做的事
      }
}

RxJava2更改为
Consumer<String> consumer = new Consumer<String>() {
      @Override
      public void accept(String s) throws Exception {
           //需要做的事
      }
 }

同样Func1改名成Function ，Func2改名成BiFunction，Func3 - Func9 改名成 Function3 - Function9，FuncN 改名成 Function

以Func1 为例

RxJava1
Func1 func = new Func1<ResponseBody, InputStream>() {
                    @Override
                    public InputStream call(ResponseBody responseBody) {
                        return responseBody.byteStream();
                    }
                }
RxJava2更改为
Function = new Function<ResponseBody, InputStream>() {
                    @Override
                    public InputStream apply(ResponseBody responseBody) throws Exception {
                        return responseBody.byteStream();
                    }
                }

3、
Observable.OnSubscribe 变成 ObservableOnSubscribe

RxJava1
new Observable.OnSubscribe<Object>() {
            @Override
            public void call(Subscriber <? super Object> subscriber) {
                 //处理事情
            }
        }

RxJava2
new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> subscriber) throws Exception {
                 //处理事情
            }

        }

Observable.Transformer 变成 ObservableTransformer

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

RxJava2
new ObservableTransformer<T, T>() {

            @Override
            public ObservableSource<T> apply(Observable<T> observable) {
                return observable.subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread());
            }
        };

4.Subscription 改名为 Disposable
由于 RxJava2 中，已经存在了 org.reactivestreams.subscription 这个类，为了避免名字冲突将原先的 rx.Subscription 改名为 io.reactivex.disposables.Disposable。
Disposable 中 原Subscription的onCompleted() 改成 了onComplete()，onStart()被删了，新增了onSubscribe方法 传递Disposable.Disposable必须单次使用，用完就要销毁。

在RxJava1中.subscribe()返回的是 Subscription 对象，但是在RxJava2 中.subscribe()是void没有返回，这个时候实现他的onSubscribe(Disposable d)方法，拿到Disposable 在销毁的时候通过调用Disposable.dispose();即可。

由于Subscription更名为Disposable，在RxJava1中我们通常会用CompositeSubscription 添加Subscription 在页面销毁时统一调用CompositeSubscription.unsubscribe();取消所有正在执行的订阅,Rxjava2中该类也改成了CompositeDisposable，页面销毁时调用CompositeDisposable.dispose() 即可

举个例子：

RxJava1
private CompositeSubscription mCompositeSubscription = new CompositeSubscription() ;
public void test(){
      Subscription subscription =  new Observable<T>.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<T>() {
                       @Override
                    public void onCompleted() {

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

                    @Override
                    public void onNext(RespResult<OrderList> orderListRespResult) {
                      
                    }
                });

      mCompositeSubscription.add(subscription);
}

/**
 *页面销毁时调用，取消所有订阅
 */
public void distroy(){
    if(mCompositeSubscription != null){
        mCompositeSubscription.unsubscribe();
    }

}

RxJava2

private CompositeDisposable mCompositeDisposable = new CompositeDisposable() ;

public void test(){
    new Observable<T>.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<RespResult<OrderList>>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mCompositeSubscription.add(subscription);
                    }

                    @Override
                    public void onNext(RespResult<OrderList> value) {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
}

/**
 *页面销毁时调用，取消所有订阅
 */
public void distroy(){
    if(mCompositeDisposable != null){
        mCompositeDisposable.dispose();
    }

}

由于我使用的只是RxJava的一小部分功能，所以暂时只贴出这个多东西了，
RxJava相关学习链接：
https://github.com/ReactiveX/RxJava
https://github.com/ReactiveX/RxAndroid
https://github.com/JakeWharton/RxBinding
https://github.com/JakeWharton/RxRelay
https://github.com/ReactiveX/RxJava/wiki/Additional-Reading