RxJAVA学习笔记(一)

RxJAVA使用的是响应式编程方式：

响应式编程是一种建立在异步数据流概念上的编程思想。一个数据流可以被过滤，操作，和另外一条数据流合并形成一条新的数据流。

响应式编程主要的是事件，事件可以被等待，可以触发过程，还可以触发另外一些事件，

RxJAVA与纯粹JAVA有什么不同

RxJAVA是从经典的GOF观察者模式继承而来的。

同时RxJAVA添加了以下经典观察者模式没有的能力：

• 生产者能通过onComplete()事件通知消费者，现在已经没有任何数据；
• 生产者能通过onError()事件，通知消费者，出现错误；
• RxJAVA Observable可以不用嵌套调用。

在RXJAVA中最主要的三个方法是：onNext(),onComplete(),onError()。

为什么要使用Observables

在面向对象的编程中，需要努力创建解耦的实体。是程序更容易被测试，重用，维护，当改变某一些功能时，不会影响到其他的东西，

MVC框架模式是第一个用来解决这种问题的。

在GOF书中，观察者模式也是一种，它是一种一对多（one-to-many）的 方式来绑定多个对象，当一个对象发生变化时，其他的多个依赖于它的对象能得到通知，并自动发生相应的变化。

观察者模式

观察者模式是软件设计模式中出现最频繁的模式之一。它建立在subject的基础上。一个subject是一个特殊的对象，它包含了一系列想要在它改变
时得到通知的对象。这些对象称作观察者（ Observers） ,它们暴露一些用来通知的方法，这些方法会在subject的状态产生变化时得到调用。

下图描述了subject/Observer的关系是一个一对多的关系 。

图中展示了一个subject能为3个Observer服务。很明为，没有理由限制Observer的数量。一个subject可以有无限多个Observer，而且在subject产生变化时，所有Observer能得到通知。

什么时候使用观察者模式

• 当你的构架中包含有两个实体，一个依赖于另一个，你想保持他们是分开的，而且像重用他们；
• 当一个改变中的对象想在自己发生变化是通知未知数量与自己相关的对象发生相应的变化；
• 当一个改变中的对象想通知那些它不清楚的对象时。

观察者模式工具箱

在RxJAVA中有以下：

• Observable
• Observer
• Subdcriber
• Subjects

Observables和Subjects是两个生产者， Observer和Subscriber是两个消费者实体。

Observable

当我们要执行一些轻量级的异步任务时， Java提供了一些经典的类，比如Thread,Future,FutureTask,CompletableFuture，来解决这些问题。当复杂度增加时，这个解决方法会变得杂乱，难以维护。特别是，它们不能形成链。RxJava的Observables就是为了解决这些问题设计的。它们灵活好用，能被链接起来，能产生单一的结果，或者更好，产生序列。无论何时你想发射一个新的单一值或者一系列的值，或者是一个无穷尽的流，你都可以使用Observable。
Observalbe的生命周期包括3个可能的事件，我们可以和Iterable类比。下边这个表展示
Observable的生命周期包含三个可能的事件：
1. onNext()
2. onCompleted()
3. onError()
下面将Observable的async/push和Iterable的 sync/pull：进行比较

创建一个Observable

Observable.create()
create()方法提供了一个创建Observable的能力。它
它使用一个OnSubscribe的参数对象，这个OnSubscribe继承于Action1，并且在有观察者订
阅我们的Observable时执行call方法。

Observable.create(new Observable.OnSubcribe<Object>()){
@Obverride
public void call(Subscriber<? super Object> subscriber){
}
});

Observable 使用subscirber变量并根据不同条件来调用它的方法来和Observer通信。

Observable<Integer> observablestring=Observable.create(new
Observable.OnSubscribe<Integer>(){
@Override
public void call(Subscriber<? super Integer> observer){
for(int i=0;i<5;i++){
observer.onNext();
}
observer.onCompleted();
}
});

我们创建一个新的Observable项，它执行一个产生5个元素的for循环，然后一个个的发射这些元素，然后完成发射。
另一方面，我们向Observable订阅，得到一个Subscription对象。从订阅的那一刻起，我们就开始接收integers，一个个打印它们。我们不知道将要接收
多少个integer。其实我们不需要知道。因为我们为可能发生的每个情况都提供了相应的动作响应：

如果得到一个integer，就打印它
如果序列到达最末端，我们打印一个结束信息
如果错误发生了，我们打印一个错误信息

Observable.from()

在前面一个例子中，我们创建了一序列的integer，然后一个个发射它们。如果我们已经有一个list，该怎么做呢？我们继续用这种循环的方式一个个发射
它们吗？ 在接下来的示例代码中，我们从已有的list中创建一个Observable：

List<Integer> items = new ArrayList<Integer>(); items.add(1);
items.add(10);
items.add(100);
items.add(200);
Observable<Integer> observableString = Observable.from(items); Subscription subscriptionPrint =
observableString.subscribe(new Observer<Integer>() {
@Override
public void onCompleted() {
System.out.println("Observable completed");
}
@Override
public void onError(Throwable e) {
System.out.println("Oh no! Something wrong happened!");
}
@Override
public void onNext(Integer item) {
System.out.println("Item is " + item);
}
});

from()创建器能从一个列表或数组中创建Observable，一个个的发射列表或数组里面的对象。或者从Future当中，发射Future对象的.get()结果。传递Future参数，我们甚至能指定一个超时时间。 Observable会等待Future的结果，如果在超时时间后没能等到结果，它会调用onError()方法并通知Observer发生了错误。

Observable.just()

如果我们已经有一个典型的Java方法，想把它转换成Observable该怎么做？我们有使用create()方法，像我们前面看到过的一样。或者，使用just()方法来
避免大量的样板代码：

Observable<String> observableString = Observable.just(helloWorld());
Subscription subscriptionPrint = observableString.subscribe(new Observer<String> () {
@Override
public void onCompleted() {
System.out.println("Observable completed");
}
@Override
public void onError(Throwable e) {
System.out.println("Oh no! Something wrong happened!");
}
@Override
public void onNext(String message) {
System.out.println(message); }
});

helloworld()方法

privatte String helloWorld(){
return "Hello World";
}

just()创建器能接受1到9个参数。它按参数顺序发射这些值。 just()方法同时也接受list或者arrays，但和from()不同，它不会迭代这些List一个个的发射，而是发射整个list。一般的，当我们想发射一个定义好的set时使用它。我们可以使用just()来写出更有组织的和可测试的代码。 最后要提的是，当just()发射完值后， Observable会正常的结束。

Observable.empty(),Observable.never()和Observable.throw()

当由于某些原因，我们有时候需要不发射任何东西，只想正常结束的，这时我们可以使用empty()。我们可以使用never()产生一个不发射任何东西并且永远不结束的Observable。我们可以使用throw()来产生一个不发射值，并以错误结束的Observable。

Subject=Observable+Observer

一个Subject是一个有魔力的对象，它能同时成为Observable和Observer。它像一座桥连接两个世界。一个subject能向一个Observable订阅，这时它的动作像一个Observer。它能发射新item，甚至传递这些值,像一个Observable一样。
当subject向Observable订阅时，它会触发Observable的发射动作。如果原始的Observable是冷的，这会使原来冷的Observable变热。
RxJava 提供4种不同的subject：

PublishSubject
BehaviorSubject
ReplaySubject
AsyncSubject

PublishSubject

PublishSubject 是基本的Subject对象。让我们看一下经典的hello world程序，使用PublishSubject来达成。

PublishSubject<String> stringPublishSubject = PublishSubject.create();
Subscription subscriptionPrint = stringPublishSubject.subscribe(new Observer<String>() {
@Override
public void onCompleted() {
System.out.println("Observable completed");
}
@Override
public void onError(Throwable e) {
System.out.println("Oh no! Something wrong happened!");
}
@Override
public void onNext(String message) {
System.out.println(message); }
});

在这个例子中，我们创建了一个PublishSubject，它使用create()方法发射一个字符串，然后我们向它订阅。这个时候，是没有任何item是被发射的，我们的Observable是在等待，并且等待时不用阻塞线程和消耗资源。它就在那里，准备从subject接收值。如果subject不发射任何值的话，我们的Observer会永远等待。重申一次，不要担心 ，因为我们的Observer在任何情况下都知道该怎么做。什么时候会发射值我们不关心，因为这是响应式编程，系统会自动响应。我们也不关心它什么时候会响应。我们只关心响应的时候会发生什么动作。 最后一行代码展示了手动发射我们的hello world字符串，它触发了Observer的onNext()方法，让我们在控制台打印出了“hellow world”。让我们看一个更复杂的例子。假设我们有一个私有的Observable，它不能从外面访问到。这个Observable在它的生命周期中发射值。我们不关心这些值，我们只关心它的终止。
首先，我们创建一个新的PublishSubject，在它的onNext()方法中响应，它能被外界访问 到：

final PublishSubject<Boolean> subject = PublishSubject.create();
subject.subscribe(new Observer<Boolean>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Boolean completed) {
System.out.println("Observable completed!");
}
});

然后，我们创建一个私有的Observable，它只能访问到这个subject：

Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
for (int i = 0; i < 5; i++) {
subscriber.onNext(i);
}
subscriber.onCompleted();
}
}).doOnCompleted(new Action0() {
@Override
public void call() {
subject.onNext(true);
}
}).subscribe();

这个Observable.create()方法包含了我们熟悉的发射数字的for循环。 doOnCompleted()方法指明了当Observable结束时会向subject发射true值。最后，我们向这个Observable订阅，明显的，这个空的subscribe()方法只是简单的开启Observable的发射动作，而忽略它发射的具体值以及它的完成或错误事件。
在这个例子中，我们创建了一个能连接到Observable并同时能被观察的实体。在我们想创建一个分离的，抽象的，或观察一个普通对象时极其有用。

BehaviorSubject

BehaviorSubject会发射最近的一个值，和被订阅后的值。

BehaviorSubject<Integer> behaviorSubject=BehaviorSubject.create(1);

在这个简短的例子中，我们创建了一个发射整型的subject.BehaviorSubject需要一个初始值，因为当有观察者订阅它的时候，它需要发射最近的一个
值。

ReplaySubject

ReplaySubject 缓存了所有的item，当有订阅者订阅的时候，它发射所有的item。

AsyncSubject

AsyncSubject在Observable结束时对所有订阅它的观察者发射它的最后的一个值。

总结

现在我们知道了RxJAVA是采用的观察者模式， RxJava中的Observable有三个事件
1.onNext（），
2.onCompleted（），
3.onError（），
create()创建一个Observable；
from()能从一个数组或者列表中创建Observable；
just()创建器能接受1到9个参数。它按参数顺序发射这些值。 just()方法同时也接受list或者arrays，但和from()不同，它不会迭代这些List一个个的发射，而是发射整个list。

声明：本文是学习http://pan.baidu.com/s/1bovLc8B的笔记；若有需要请下载原文查看：