Android 带大家进入RxJava的世界

Rx指的是ReactiveX，也是Reactive Extensions的缩写，是一个使用可观察数据流进行异步编程的编程接口，结合了观察者模式、迭代器模式和函数式编程的精华，是一种编程思想的突破，它影响了许多其它的程序库和框架以及编程语言

RxJava里最核心的两个东西Observable和Subscriber，Observable指的是被观察者、事件源，Subscriber指的是被观察者、订阅者、用户。

举个简单的例子，像微信里面的服务号和公众号，我们关注了某个服务号或公众号，只要发出消息，我们都能同时收到。这里的服务号和公众号就是Observable，Subscriber指的就是我们用户。

看起来RxJava蛮像观察者模式，不过有一点不同Observable如果没有Subscriber不会发出任何事件

下面就让我们一起进入RxJava的世界吧

参考资料学习网址

1、Grokking RxJava
2、github地址
3、ReactiveX/RxJava文档中文版
4、ReactiveX官网
5、抛物线博客

配置环境

在builde.gradle里面添加

compile 'io.reactivex:rxandroid:1.2.1'
compile 'io.reactivex:rxjava:1.1.6'

基本实现

1、Hello world

创建Observable对象，通过Observable.create()来创建，sub.onNext()可以发出信息，最后调用sub.onCompleted()来完成，还有一个sub.onError()方法是出现异常提供的一个方法，一旦调用了sub.onError()或者sub.onCompleted()，后面的逻辑代码都不会执行。

Observable myObservable = Observable.create(
        new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber sub) {
                sub.onNext("Hello, world1!");
                sub.onNext("Hello, world2!");
                sub.onCompleted();
            }
        }
);

创建Subscriber对象，实例化Subscriber抽象类，实现onNext、onCompleted、onError三个方法，依次响应Observable对象里面的sub.onNext()、sub.onCompleted()和sub.onError()方法

Subscriber mySubscriber = new Subscriber() {
    @Override
    public void onNext(String s) {
        Log.d("rxjava","onNext="+s); 
    }
    @Override
    public void onCompleted() { 
        Log.d("rxjava","onCompleted");
    }
    @Override
    public void onError(Throwable e) {
        Log.d("rxjava","onError="+e);
    }
};

最后Subscriber订阅Observable，这里Observable可以被多个Subscriber订阅

myObservable.subscribe(mySubscriber);
myObservable.subscribe(mySubscriber2);
myObservable.subscribe(mySubscriber3);

2、简化代码

上面的代码可以转变为这样：

Observable myObservable = Observable.just("Hello, world1!"，"Hello, world2!");
Action1 onNextAction = new Action1() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
};
Action1 onErrorAction = new Action1() {
    @Override
    public void call(Throwable e) {
    }
};
Action0 onCompletedAction = new Action0() {
    @Override
    public void call() {
    }
};
// 自动创建 Subscriber ，并使用 onNextAction 来定义 onNext()
myObservable.subscribe(onNextAction);
// 自动创建 Subscriber ，并使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()
myObservable.subscribe(onNextAction,onErrorAction);
// 自动创建 Subscriber ，并使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()
myObservable.subscribe(onNextAction,onErrorAction,onCompletedAction);

Observable.just("Hello, world1!"，"Hello, world2!")会直接创建Observable对象，
然后依次调用sub.onNext("Hello, world1!"); sub.onNext("Hello, world2!"); sub.onCompleted();

一般onErrorAction和onCompletedAction我们可以不用管理 最后代码可优化成：

Observable.just("Hello, world1!","Hello, world2!")
                .subscribe(new Action1() {
                    @Override
                    public void call(String s) {
                        System.out.println(s);
                    }
                });

java8语法lambda可以写成

Observable.just("Hello, world!")
                .subscribe(s -> System.out.println(s));

3、操作符map

简单的一个例子，传递一个字符串，然后获取它的长度，最后打印出来，在RxJava里我们可以这样实现：

Observable.just("Hello, world!")
        .map(new Func1(){
            @Override
            public Integer call(String s){
                return s.length();
            }
        })
        .subscribe(new Action1(){
            @Override
            public void call(Integer i){
                System.out.println(Integer.toString(i));
            }
        });

这里map方法需要结合Func1接口来使用，Func1里第一个String类型是对应接收just类型，第二个Integer类型是返回值，供下一个对象接收

4、操作符from

如果我们要循环遍历一个数组或者集合，在RxJava里面可以使用from操作符来实现

String[] items = { "0", "1", "2", "3", "4", "5" };
        Observable.from(items)
                .subscribe(new Action1(){
                    @Override
                    public void call(String str){
                        //依次遍历打印items
                        System.out.println(str);
                    }
                });

操作符from会循环遍历方法参数里面的数组或者集合，然后依次调用onNext()方法

5、操作符flatMap

如果我们要实现多重循环，可以使用flatMap操作符来实现

String[][] itemArray = {{"1","2","3"},{"4","5","6"},{"7","8","9"}};
Observable.from(itemArray)
        .flatMap(new Func1>(){
            @Override
            public Observable call(String[] s){
                return Observable.from(s);
            }
        })
        .subscribe(new Subscriber(){
            @Override
            public void onCompleted(){
            }
            @Override
            public void onError(Throwable e){
            }
            @Override
            public void onNext(String str){
                Log.d("rxJava","str="+str);
            }
        });

上面代码执行后，依次打印str=1到9，这里要注意的是Func1第二个参数类型是Observable

6、操作符filter

字面理解应该就知道它的作用了，过滤不需要的数据

Observable.just(1, 2, 3, 4, 5)
    .filter(new Func1() {
        @Override
        public Boolean call(Integer item) {
            return( item < 4 );
        }
    })
    .subscribe(new Subscriber() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }
        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }
        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

上面代码执行结果，只会打印1到3，后面4和5不符合，则过滤

7、操作符merge

合并多个Observables

Observable odds = Observable.just(1, 3, 5);
Observable evens = Observable.just(2, 4, 6);
Observable.merge(odds, evens)
        .subscribe(new Subscriber() {
            @Override
            public void onNext(Integer item) {
                System.out.println("Next: " + item);
            }
            @Override
            public void onError(Throwable error) {
                System.err.println("Error: " + error.getMessage());
            }
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }
        });

上面代码执行后结果：依次打印的是1、3、5、2、4、6

*  Javadoc: merge(Iterable)
*  Javadoc: merge(Iterable,int)
*  Javadoc: merge(Observable[])
*  Javadoc: merge(Observable,Observable) (接受二到九个Observable)

除了传递多个Observable给merge，你还可以传递一个Observable列表List，数组，甚至是一个发射Observable序列的Observable，merge将合并它们的输出作为单个Observable的输出

8、操作符timer和interval

5秒后打印数据，第一个参数是多少时间执行，第二个参数是时间单位

Observable.timer(5,TimeUnit.SECONDS)
        .subscribe(new Action1(){
            @Override
            public void call(Long aLong){
                Log.d("rxJava","5秒后执行"+aLong);
            }
        });

1秒后每5秒循环打印，第一个参数为多少时间后执行，第二个为没多少时间执行，第三个是时间单位

Observable.interval(1,5,TimeUnit.SECONDS)
        .subscribe(new Action1(){
            @Override
            public void call(Long aLong){
                Log.d("rxJava","1秒后每5秒循环执行"+aLong);
            }
        });

这里aLong返回的值应该是打印的次数

9、线程切换

主要通过subscribeOn()和 observeOn()来实现
subscribeOn()是控制Observable.OnSubscribe的线程切换， subscribeOn()的线程切换发生在 OnSubscribe中，即在它通知上一级 OnSubscribe时，这时事件还没有开始发送，因此控制可以从事件发出的开端就造成影响
observeOn()则是控制Subscriber的线程切换，observeOn() 的线程切换则发生在它内建的 Subscriber中，即发生在它即将给下一级 Subscriber发送事件时，因此控制的是它后面的线程
Schedulers.io()：IO线程
AndroidSchedulers.mainThread()：主线程
Schedulers.newThread()：新开线程

Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.newThread())
    .map(mapOperator) // 新线程，由 observeOn() 指定
    .observeOn(Schedulers.io())
    .map(mapOperator2) // IO 线程，由 observeOn() 指定
    .observeOn(AndroidSchedulers.mainThread) 
    .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

10、防止按钮重复点击

1秒钟内只会执行第一次点击

RxView.clicks(view)
        .throttleFirst(1,TimeUnit.SECONDS)
        .subscribe(new Observer