RxJava2.0入门

RxJava中文文档：https://mcxiaoke.gitbooks.io/rxdocs/content/

RxJava2.0的基本使用

基于观察者模式，我们开始RxJava2.0的学习。首先引入RxJava2.0相关的类库。
compile 'io.reactivex.rxjava2:rxjava:2.0.1'

compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

第一步：创建被观察者Observable

 Observable mObservable=Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                 e.onNext("one");
                 e.onComplete();
            }
        });

Observable中文意思就是被观察者，通过create方法生成对象，里面放的参数ObservableOnSubscribe<T>，可以理解为一个计划表，泛型T是要操作对象的类型，重写subscribe方法，里面写具体的计划，在subscribe中的ObservableEmitter<String>对象的Emitter是发射器的意思。ObservableEmitter有三种发射的方法，分别是void onNext(T value)、void onError(Throwable error)、void onComplete()，onNext方法可以无限调用，Observer（观察者）所有的都能接收到，onError和onComplete是互斥的，Observer（观察者）只能接收到一个，OnComplete可以重复调用，但是Observer（观察者）只会接收一次，而onError不可以重复调用，第二次调用就会报异常。

第二步：创建观察者Observer

 Observer<String> reader = new Observer<String>(){
            @Override
            public void onSubscribe(Disposable d) {
            }
            @Override
            public void onNext(String value) {
                Log.i(TAG, "onNext: "+value);
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete: ");
            }
        };

通过new创建接口，并实现其内部的方法，看方法其实就应该差不多知道干嘛的，onNext、onError、onComplete都是跟被观察者发射的方法一一对应的，这里就相当于接收了。onSubscribe（Disposable d）里面的Disposable对象要说一下，Disposable英文意思是可随意使用的，可以调用 mDisposable.dispose()取消订阅。

第三步：读者和连载小说建立订阅关系

 mObservable.subscribe(reader);

 这里我们先看一下输出效果

RxJava2.0的异步编程

RxJava是支持异步的，但是RxJava是如何做到的呢？这里就需要Scheduler。Scheduler，英文名调度器，它是RxJava用来控制线程。当我们没有设置的时候，RxJava遵循哪个线程产生就在哪个线程消费的原则，也就是说线程不会产生变化，始终在同一个。然后我们一般使用RxJava都是后台执行，前台调用，本着这个原则，我们需要调用observeOn(AndroidSchedulers.mainThread())，observeOn是事件回调的线程，AndroidSchedulers.mainThread()一看就知道是主线程，subscribeOn(Schedulers.io())，subscribeOn是事件执行的线程，Schedulers.io()是子线程，这里也可以用Schedulers.newThread()，只不过io线程可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。前面的代码根据异步和链式编程的原则，我们可以写成

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("two");
                e.onComplete();
            }
        })
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeOn(Schedulers.io())
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String value) {
                Log.i(TAG, "onNext: "+value);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete: ");
            }
        });

类型

• RxJava功能强大，所以其对应的操作符的类型也非常多
• 根据功能作用的不同，RxJava的操作符分类如下：

示意图

interval

创建一个按固定时间间隔发射整数序列的Observable

Observer<Long> invreader = new Observer<Long>(){
    @Override
    public void onSubscribe(Disposable d) {
    }
    @Override
    public void onNext(Long value) {
        Log.i("invreader", "onNext: "+value);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
        Log.i(TAG, "onComplete: ");
    }
};

Observable.interval(0,3,TimeUnit.SECONDS)
         .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeWith(invreader);

...

just

创建一个发射指定值的Observable

map

对Observable发射的每一项数据应用一个函数，执行变换操作

Observer<String> mapreader = new Observer<String>(){
    @Override
    public void onSubscribe(Disposable d) {
    }
    @Override
    public void onNext(String value) {
        Log.i("mapreader", "onNext: "+value);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
        Log.i(TAG, "onComplete: ");
    }
};
 Function<String,String> mFunction =new Function<String,String>(){
    @Override
    public String apply(String s) throws Exception {
        return s.toUpperCase(); //字符转为大写
    }
};
Observable.just("zhongdan","yasuo","caiji")
        .map(mFunction)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeWith(mapreader);

zip

通过一个函数将多个Observables的发射物结合到一起，基于这个函数的结果为每个结合体发射单个数据项。

Observer<String> zipObserver = new Observer<String>(){
    @Override
    public void onSubscribe(Disposable d) {
    }
    @Override
    public void onNext(String value) {
        Log.i("zipObserver", "onNext: "+value);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
        Log.i(TAG, "onComplete: ");
    }
};


BiFunction mFunctionab =new BiFunction<String,String,String>(){

    @Override
    public String apply(String s, String s2) throws Exception {
        return s+s2;
    }
};
Observable.zip(getObservableA(),getObservableB(),mFunctionab)

        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeWith(zipObserver);

Observable <String> getObservableA(){
    return Observable.fromCallable(new Callable<String>(){
        @Override
        public String call() throws Exception {
            SystemClock.sleep(3000);
            return "kuaile";
        }
    });
}
Observable <String> getObservableB(){
    return Observable.fromCallable(new Callable<String>(){
        @Override
        public String call() throws Exception {
            SystemClock.sleep(3000);
            return "fengnan";
        }
    });

运行结果：I/zipObserver: onNext: kuailefengnan

merge

合并多个Observables的发射物,与zip功能类似

Observable.merge(getObservableA(),getObservableB())

.subscribeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread())

.subscribeWith(zipObserver);

 

I/zipObserver: onNext: kuaile
 I/zipObserver: onNext: fengnan

Scan

连续地对数据序列的每一项应用一个函数，然后连续发射结果

range

创建一个发射特定整数序列的Observable

Observer<Integer> scanObserver = new Observer<Integer>(){
    @Override
    public void onSubscribe(Disposable d) {
    }
    @Override
    public void onNext(Integer value) {
        Log.i("scanObserver", "onNext: "+value);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
        Log.i(TAG, "onComplete: ");
    }
};

BiFunction mFunctionaScan =new BiFunction<Integer,Integer,Integer>(){

    @Override
    public Integer apply(Integer s, Integer s2) throws Exception {
        Log.i("scanObserver", "apply: "+s+","+s2);
        return Math.min(s,s2);
    }
};

Observable.range(0,5)
        .scan(mFunctionaScan)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeWith(scanObserver);

 I/scanObserver: apply: 0,1

I/scanObserver: apply: 0,2

I/scanObserver: apply: 0,3
 I/scanObserver: apply: 0,4
 I/scanObserver: onNext: 0
 I/scanObserver: onNext: 0
 I/scanObserver: onNext: 0
 I/scanObserver: onNext: 0
 I/scanObserver: onNext: 0

filter

只发射通过了谓词测试的数据项

Observer<Integer> filtObserver = new Observer<Integer>(){
    @Override
    public void onSubscribe(Disposable d) {
    }
    @Override
    public void onNext(Integer value) {
        Log.i("filtObserver", "onNext: "+value);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
        Log.i(TAG, "onComplete: ");
    }
};

Observable.range(0,5)
        .filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                int res=integer%2;
                boolean b= (res==0);
                return b;
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeWith(filtObserver);

I/filtObserver: onNext: 0
 I/filtObserver: onNext: 2
 I/filtObserver: onNext: 4