rxjava学习笔记（一）订阅关系、线程操作、操作符

总结

第一天静下心来系统完整的学习一下热的不能再热的框架，对该框架有些自己的理解：

rxjava的订阅模式相当于回调模式。

rxjava提出观察者模式，而要满足这个模式工作需要三个要素：被观察者（observable）、观察者（observer ）、订阅关系（subscribe）。

观察者模式实现是这样：observable.subscribe( observer );

而回调模式是这样：button.setOnClickListener( listener );

以下将两个模式对比着看。

对于观察者模式的代码解释是：被观察者通过订阅关系让观察者观察，

类比回调模式：button为被观察者，listener为观察者， 订阅关系就是点击事件。

观察者会通过onNext方法接收到被观察者发送出来的事件。

类比回调模式：listener的onclick方法为观察者的onNext方法，用户点击按钮的过程就是被观察者发送事件的过程。

正文

观察者模式

先记住如下关键字，才能让整个观察者模式跑通。

/**
 * 观察者 Observer
 * 被观察者 Observable
 * 订阅 subscribe
 * 发射 ObservableEmitter
 * 中断接收 Disposable
 */

创建一个被观察者对象，重写subscribe方法，subscribe方法中的ObservableEmitter参数可以理解为发射器，发射器通过onNext方法发送事件给观察者，当没有事件继续发送时调用ObservableEmitter的onComplete方法终止发送事件。

//创建一个被观察者
        Observable observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                //ObservableEmitter发送一条消息
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        });

有了被观察者对象还需要创建一个观察者对象，其中onSubscribe中的参数Disposable可理解为一个中断器，调用Disposable的dispose方法后观察者将不再接收消息，但被观察者依旧会将消息全部发送完毕。被观察者每发一次消息观察者就会调用一次onNext方法，直到没有消息后被观察者调用onComplete，观察者也调用onComplete。

//创建一个观察者
        Observer<Integer> observer = new Observer<Integer>() {
            private Disposable mDisposable;
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("xy:: ","onSubscribe");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d("xy:: ",value+"");
                //使用Disposable终止接收消息
                //mDisposable.dispose();
            }


            @Override
            public void onError(Throwable e) {
                Log.d("xy:: ","onError");
            }

            @Override
            public void onComplete() {
                Log.d("xy:: ","onComplete");
            }
        };

建立订阅关系

        //建立联系，被观察者被观察者观察
        observable.subscribe( observer );

线程操作

如下线程为rxjava定义过的常用线程，线程操作过程中频繁用到。

/**
 * Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
 * Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
 * Schedulers.newThread() 代表一个常规的新线程
 * AndroidSchedulers.mainThread() 代表Android的主线程
 */

同样先创建一个被观察者，并打印当前所在线程。

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                Log.d("xy:: ","ObservableEmitter");
                Log.d("xy:: ", java.lang.Thread.currentThread().getName());
            }
        });

创建一个观察者，并打印当前所在线程。

//subscribe有多个重载方法 accept相当于observer的OnNext
        Consumer<Integer> consumer = new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.i("xy:: ", java.lang.Thread.currentThread().getName());
                Log.i("xy:: ", "OnNext"+integer);
            }
        };

被观察者调用subscribeOn方法可以指定自己运行的线程，调用observeOn方法指定观察者运行的线程，其中，多次调用subscribeOn只有第一次调用生效，但多次调用observeOn可以使观察者在不同线程中切换。

observable.subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                //doOnNext会在observer的OnNext方法前执行
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i("xy:: ", "doOnNext1"+integer);
                    }
                })
                .observeOn(Schedulers.io())
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i("xy:: ", "doOnNext2"+integer);
                    }
                })
                .subscribe( consumer );

操作符

rxjava操作符种类很多，如下为其中三种，操作符的作用为，将接收到被观察者发送过来的事件应用一个函数后再交给观察者。

/**
 * map操作符:将接收到的数据类型应用一个参数
 * FlatMap操作符:不保证顺序的把接收到的事件转换为多个事件
 * concatMap操作符:保证顺序的把接收到的事件转换为多个事件
 */

map为最简单的操作符，如下，将接收到的Integer类型数据转换成String类型后再交给观察者。

//map
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "string类型"+integer+"";
            }

        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("xy:: ",s);
            }
        });

与map操作符类似，flatMap操作符可以将接收到的数据应用多个函数，但交给观察者后，不保证事件顺序。

//flatMap
        Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        }).flatMap(new Function<Integer, ObservableSource<String>>() {

            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                List list = new ArrayList();
                for (int i = 0;i<3;i++){
                    list.add(i);
                }
                return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("xy:: ",s);
            }
        });

concatMap操作符与flatMap操作符唯一的区别为：concatMap可以保证时间顺序。

//concatMap
        Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        }).concatMap(new Function<Integer, ObservableSource<String>>() {

            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                List list = new ArrayList();
                for (int i = 0;i<3;i++){
                    list.add(i);
                }
                return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("xy:: ",s);
            }
        });

以上为第一天学习所有内容，已然沦落为业内最低端的人还是要多学习。。