RxJava学习 - 1. Observable

Observable是一个基于push的，可组合的iterator。
对于一个给定的Observable，它push类型为T的items（叫做emissions），经过一系列运算，最后到达Observer，Observer消费这些items。

How Observables work

Observable是如何把items沿着chain顺序地传给Observer的？在最高级别，Observable传递三种类型的事件：

• OnNext()：一次一个地把item从源Observable传给沿途的Observer
• onComplete()：完成事件，说明不会再调用onNext()
• onError()：发生错误了，Observer定义了怎么处理错误。除非使用retry()阻止该错误，Observable chain终止，不会再有emissions。

这些事件是Observer类型的抽象方法。

Using Observable.create()

可以使用Observable.create()增加一个source Observable。source Observable就是emissions的源头，Observable chain的起始点。

import io.reactivex.Observable;
public class Launcher {
    public static void main(String[] args) {
        Observable<String> source = Observable.create(emitter -> {
            emitter.onNext("Alpha");
            emitter.onNext("Beta");
            emitter.onNext("Gamma");
            emitter.onNext("Delta");
            emitter.onNext("Epsilon");
            emitter.onComplete();
        });
        source.subscribe(s -> System.out.println("RECEIVED: " + s));
    }
}

Emissions只能顺序传递，而且一次只能传一个。Emissions不能并行地或者并发地通过一个Observable。
Observables可以是无限多的，也不是必须调用onComplete()。
当Observable.create()块发生错误，通过onError()发射（emit）他们的时候，我们可以捕获这些错误。错误被push到chain上，由Observer处理。上面的代码不处理异常，但是我们也可以这么写：

import io.reactivex.Observable;
public class Launcher {
    public static void main(String[] args) {
        Observable<String> source = Observable.create(emitter -> {
            try {
                emitter.onNext("Alpha");
                emitter.onNext("Beta");
                emitter.onNext("Gamma");
                emitter.onNext("Delta");
                emitter.onNext("Epsilon");
                emitter.onComplete();
            } catch (Throwable e) {
                emitter.onError(e);
            }
        });
        source.subscribe(s -> System.out.println("RECEIVED: " + s), Throwable::printStackTrace);
    }
}

onNext()、onComplete()和onError()不一定非要直接push给最终的Observer。也可以push给chain中的下一步。
下面的代码，我们派生出执行map()和filter()运算的新的Observables，他们会在源Observable和最终的Observer之间生效：

import io.reactivex.Observable;
public class Launcher {
    public static void main(String[] args) {
        Observable<String> source = Observable.create(emitter -> {
            try {
                emitter.onNext("Alpha");
                emitter.onNext("Beta");
                emitter.onNext("Gamma");
                emitter.onNext("Delta");
                emitter.onNext("Epsilon");
                emitter.onComplete();
            } catch (Throwable e) {
                emitter.onError(e);
            }
        });
        Observable<Integer> lengths = source.map(String::length);
        Observable<Integer> filtered = lengths.filter(i -> i >= 5);
        filtered.subscribe(s -> System.out.println("RECEIVED: " + s));
    }
}

上面的代码，onNext()把每个item交给map()，在map()内部，它作为一个中介Observer，八字符串转换成它的length()。然后，调用onNext()和filter()传递这个整数，lambda条件i -> i >= 5会过滤掉长度小于5的。最后，filter()调用onNext()把每个item交给最终的Observer，他们被打印。
请注意，map()会产生一个新的Observable。filter()也会产生一个新的Observable，但是会忽略条件不成立的emissions。因为类似map()和filter()这样的运算会产生新的Observables（内部使用Observer实现接收emissions），我们能链接所有的Observables，节省掉中间变量：

import io.reactivex.Observable;
public class Launcher {
    public static void main(String[] args) {
        Observable<String> source = Observable.create(emitter -> {
            try {
                emitter.onNext("Alpha");
                emitter.onNext("Beta");
                emitter.onNext("Gamma");
                emitter.onNext("Delta");
                emitter.onNext("Epsilon");
                emitter.onComplete();
            } catch (Throwable e) {
                emitter.onError(e);
            }
        });
        source.map(String::length)
                .filter(i -> i >= 5)
                .subscribe(s -> System.out.println("RECEIVED: " + s));
    }
}

**警告：**RxJava 2.0，Observables不再支持发射null值。如果你增加一个Observable，尝试发射一个null值，会立刻得到一个non-null异常。
如果你需要发射null，请使用JDK8或者Google Guava的Optional。

Using Observable.just()

一般不需要使用Observable.create()，我们一般使用streamlined的工厂增加Observables。
前面使用Observable.create()的例子，可以使用Observable.just()完成。我们能最多传递10个想要发射的items。它将为每个item调用onNext()，
当全部push以后，调用onComplete()：

import io.reactivex.Observable;
public class Launcher {
    public static void main(String[] args) {
        Observable<String> source =
                Observable.just("Alpha", "Beta", "Gamma", "Delta",
                        "Epsilon");
        source.map(String::length).filter(i -> i >= 5)
                .subscribe(s -> System.out.println("RECEIVED: " + s));
    }
}

也可以使用Observable.fromIterable()，从任何Iterable类型发射items，比如一个List。它也为每个item调用onNext()，在iteration完成以后，调用onComplete()。

import io.reactivex.Observable;
import java.util.Arrays;
import java.util.List;
public class Launcher {
    public static void main(String[] args) {
        List<String> items =
                Arrays.asList("Alpha", "Beta", "Gamma", "Delta", "Epsilon");
        Observable<String> source = Observable.fromIterable(items);
        source.map(String::length).filter(i -> i >= 5)
                .subscribe(s -> System.out.println("RECEIVED: " + s));
    }
}