RxJava初体验

参考文章

/article/5845016.html

http://www.tuicool.com/articles/MjyaUfq

http://www.tuicool.com/articles/VrQRvur

/article/2268010.html

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表达式的使用将在下篇文章中使用。

相关代码在这里