RxJava初体验

参考文章

http://www.cnblogs.com/halzhang/p/4458095.html
http://www.tuicool.com/articles/MjyaUfq
http://www.tuicool.com/articles/VrQRvur
http://blog.csdn.net/lzyzsd/article/details/41833541

RxJava的Guihub地址

https://github.com/ReactiveX/RxJava

添加依赖

首先，需要在Android Studio中添加依赖

dependencies {
    compile 'io.reactivex:rxjava:1.0.15'
}

响应式编程

响应式编程的主要组成部分是observable, operator和susbscriber。一般响应式编程的信息流 : Observable -> Operator 1 -> Operator 2 -> Operator 3 -> Subscriber。
因为subscriber通常在主线程中执行，因此设计上要求其代码尽可能简单，只对事件进行响应，而修改事件的工作全部由operator执行。

Observable (被观察者，事件源)

消息的发送是有固定模式的。Observable可以发送任意数量的消息（包括空消息），当消息被成功处理或者出错时，流程结束。Observable会调用它的每个Subscriber的Subscriber.onNext()函数，并最终以Subscriber.onComplete()或者Subscriber.onError()结束。

Subscriber （观察者）

Subscriber有3个需要实现的方法

onNext:当顺利执行时执行

onCompleted:当执行完毕时

• 你能够知道什么时候订阅者已经接收了全部的数据。

onError:当出现错误时执行

• 只要有异常发生onError()一定会被调用
  极大的简化了错误处理。只需要在一个地方处理错误即可以。
• 操作符不需要处理异常
  将异常处理交给订阅者来做，Observerable的操作符调用链中一旦有一个抛出了异常，就会直接执行onError()方法。

Operators(操作符)

Operators可以在最终的Subscriber和Observable之间进行修改数据
以下列出基本的操作符

create

作用

创建一个基础的Observable对象，可执行onNext，onCompleted操作。

调用

此时，onNext，onCompleted必须主动调用，否则不会生效。而onStart等重写的方法，是会被主动调用的，无需自己调用。

代码

创建一个Observable（被观察者，事件源）

Observable observable = Observable.create(new    Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("hello world!");
                subscriber.onCompleted();
            }
 });

然后需要创建一个Subscribers（观察者）

Subscriber<String> subscriber = new Subscriber<String>() {
        @Override
        public void onStart() {
            super.onStart();
            Log.i(TAG, "start");
        }

        @Override
        public void onCompleted() {
            Log.i(TAG, "completed");
        }

        @Override
        public void onError(Throwable e) {
            Log.i(TAG, "error:" + e.getMessage());
        }

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

关联Observable和Subscriber

我们可以使用subscribe方法很方便的进行关联，进行关联后就会进行执行。

observable.subscribe(subscriber);

输出结果

start
s:hello world!
completed   

just

作用

创建只发出一个事件就结束的Observable对象，可传递多个参数，将按照参数的顺序遍历执行。

调用

此时，Observable将自动调用onNext和OnonCompleted

代码

修改Observable 的代码，将其改为使用just

Observable observable = Observable.just("hello world!");

输出结果

start
s:hello world!
completed

什么？没发现什么变化？那再来增加一个参数

Observable observable = Observable.just("hello world!", "good job!");

输出结果

start
s:hello world!
s:good job!
Completed

just，可以接受多个参数，并逐个输出，并且可以极大化的简化代码。

from

作用

接收一个数组或集合或可变参数数组，然后逐个遍历输出。

调用

此时，Observable将自动调用onNext和OnonCompleted

代码

改变Observable 的代码，将其改为使用from

    List list = new ArrayList();
    list.add("hello world!");
    list.add("good job!");
    Observable observable = Observable.from(list);

输出结果

start
s:hello world!
s:good job!
Completed

在输入的参数是一个集合、数组或可变参数时，就可以使用from，非常方便!

subscribe方法

作用

关联Subscriber 和Observable，进行关联后就会被执行。

observable.subscribe(subscriber);

从上面的代码中我们可以知道，subscribe方法可以关联Subscriber 和Observable，但如果有时并不想把这subscriber的三个实现方法都实现时，我们就可以使用subscribe的另一个重载了。

observable.subscribe(onNextAction, onErrorAction, onCompleteAction);

比如，我们不关心OnComplete和OnError，只想使用onNext，那么就可以使用

observable.subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            Log.i(TAG, "s:" + s);
        }
    });

输出结果

s:hello world!
s:good job!

map

作用

用于改变Observable对象，返回一个新的Observable对象

代码

在Observable和Subscriber之间增加以下代码

    observable = observable.map(new Func1() {
        @Override
        public Object call(Object o) {
            return o + " 增加的数据~";
        }
    });

输出结果

start
s:hello world! 增加的数据~
s:good job! 增加的数据~
completed

并且，map还可以改变返回的Observable的泛型类型，比如，我们现在想要返回参数的hashcode，就可以这样干

observable = observable.map(new Func1() {
        @Override
        public Object call(Object o) {
            return o.hashCode();
        }
});

但是我们最后的Subscriber是String类型的泛型，当然也可以将Subscriber的泛型修改为 Object类型，然后在call方法中toString，但Subscriber方法做得事情越少越好，所以，我们再添加一个map

    observable = observable.map(new Func1() {
        @Override
        public Object call(Object o) {
            return o.toString();
        }
    });

输出结果

start
s:-217287203
s:1318599047
completed

flatMap

作用

和Map的作用相同:用于改变Observable对象，返回一个新的Observable对象，区别在于map的返回值后会自动包装一层Observable，而flatmap返回值不会自动包装Observable

比如

    //都是从Observable<String>转为Observable<String>，其中的区别
    observable = Observable.just("hello world!").map(new Func1() {
        @Override
        public Object call(Object o) { //o 是 String类型
            return o+"增加的数据"; //会自动包装Observable，此处直接返回String对象
        }
    });

    observable = Observable.just("hello world!").flatMap(new Func1() {
        @Override
        public Object call(Object o) { // o 是 String类型
            return Observable.just(o+""增加的数据""); //不会自动包装Observable，此处需自己返回一个Observable<String>对象
        }
    });

意义

如果输入是一个Observable<List>、Observable<数组>等，就显得非常有用了，直接可以输出为Observable<String>

代码

//修改Observable 的代码，将其改为使用flatMap，(通过Observable.just(list)可以得到一个Observable<List>对象)

 observable = Observable.just(list).flatMap(new Func1<List, Observable<?>>() {
        @Override
        public Observable<?> call(List list) {
            return Observable.from(list);
        }
    });

输出结果

start
 s:hello world!
s:good job!
completed

filter

作用

过滤指定的数据

代码

增加list的数据

    list.add(null);
    list.add("4");

我们修改Observable的代码，将其改为使用filter

   observable = observable.filter(new Func1() {
        @Override
        public Object call(Object o) {
            return o != null;
        }
    });

输出结果

 start
s:hello world!
s:good job!
s:4
 completed

take

作用

输出最多指定数量的结果

代码

增加take的代码，指定其只输出一个

observable = observable.take(1);

输出结果

start
s:hello world!
completed

这篇文章这样的写法只是为了理解起来比较方便，但真正要用起来代码还是太臃肿了，有关RxJava中多线程的使用、链式调用、lambda表达式的使用将在下篇文章中使用。

相关代码在这里