RxJava这些天成为了Android开发者关注的新热点。唯一的问题是它在你刚接触时难以理解。当你习惯了命令式编程，函数响应式编程就变得难以理解。但是一旦你理解了它，它就变得很棒了。
我在这试着给你们带来不一样的RxJava。这一系列四篇文章的目标是带你们入门。我不会也不能讲解所有的东西。我只是想让你们对RxJava以及它的工作原理感兴趣。
基础知识
响应式代码的基本构成部分是Observables和Subscribers(译者注：技术名词很难找到合适的中文翻译，所以维持原文不被翻译)。Observable发出items，Subscriber消费这些items。
items如何被消费有一套规则。Observable发出任意数量的items（包括0个items），要么以成功完成终止，要么以发生错误终止。对于Observable的每个Subscriber,Observable调用Subscriber.onNext()方法任意次，然后调用Subscriber.onComplete()方法或Subscriber.onError()方法。
这看起来和我们用的观察者模式类似，但在一个关键地方不同——Observables在有人明确地订阅它之后才会开始发出items。换句话说，没有人去订阅，就不会发出订阅事件（译者注：引申自If a tree falls in a forest）。
Hello World
让我们通过一个具体例子来看RxJava是如何运作的。首先，先创建一个基本的Observable:
Observable<String> myObservable = Observable.create(
new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> sub) {
sub.onNext("Hello, world!");
sub.onCompleted();
}
}
); |
Observable发出Hello World然后完成。现在创建一个Subscriber来消费掉数据。
Subscriber<String> mySubscriber = new Subscriber<String>() {
@Override
public void onNext(String s) { System.out.println(s); }
@Override
public void onCompleted() { }
@Override
public void onError(Throwable e) { }
}; |
所有这些所做的是将Observable发出的每个String打印出来。
现在有了myObservable和mySubscriber,我们可以用subscribe()方法将它们连接起来。
myObservable.subscribe(mySubscriber); // 输出 "Hello, world!" |
当订阅发生时，myobservable调用subsriber的onNext()和onComplete()方法。作为结果，mySubscriber输出"Hello,World"然后结束。
更简洁的代码
为了输出"Hello,World!",上面写了许多样板代码。这是因为我为了让你们能够明确发生了什么，选择了一种啰嗦的方式。RxJava提供了许多快捷写法让我们能写出更简洁的代码。
首先，简化Observable。RxJava有针对通用任务的多种内置Observable构建方法。在这种情况下，Observable.just()发出一个item然后完成结束，就像我们上面的代码:
Observable<String> myObservable =
Observable.just("Hello, world!"); |
然后，对于啰嗦的Subscriber。我们不关心onCompleted()和onError()方法，取而代之，我们可以用一个更简洁的类来定义在onNext()中做什么:
Action1<String> onNextAction = new Action1<String>() {
@Override
public void call(String s) {
System.out.println(s);
}
}; |
Subscriber每部分的Action都能自定义。Observable.subscribe()能处理一个，两个以及三个Action参数，以取代onNext(),onError()和onComplete()方法。复用我们之前的Subscriber,如下:
myObservable.subscribe(onNextAction, onErrorAction, onCompleteAction); |
然而，我们仅仅需要第一个参数，因为我们可以省略onError()和onComplete()方法:
myObservable.subscribe(onNextAction); // 输出 "Hello, world!" |
现在，让我们通过方法的链式调用来取代这些变量:
Observable.just("Hello, world!")
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
System.out.println(s);
}
}); |
最后，用Java 8的lambdas表达式来去掉丑陋的Action1代码。
Observable.just("Hello, world!")
.subscribe(s -> System.out.println(s)); |
如果你在Android中使用（迄今为止不能使用Java8）(译者注：原文作者写这篇文章的时候(2014年)Java8在Android中开发不能使用，在译者翻译这篇文章的时候（2016年），已经能使用部分特性了)，我推荐使用retrolambda,它将大幅降低代码的啰嗦程度。
变换
让我们把事情变得更有趣。
假设我想要在输出的"Hello,world!"语句中加上我的签名。一种可能（的实现方式）是改变Observable:
Observable.just("Hello, world! -Dan")
.subscribe(s -> System.out.println(s)); |
如果你能够控制你的Observable,这有效。但是不能保证以后都是这种情况。如果你使用的是别人的库呢？
另一种可能的问题是:如果我在多个地方使用我的Observable，但仅仅是某些情况下想要加上签名呢?
那修改我们的Subscriber怎样:
Observable.just("Hello, world!")
.subscribe(s -> System.out.println(s + " -Dan")); |
这个回答同样不能让人满意，有不同的原因：我想要我的Subscriber尽可能轻量，因为我可能会在主线程上运行它们。在更概念的层次上理解，Subscribers被认定是做出反应(reacts)的事物，而不是做出转变(mutates)的事物。
如果我能够通过一些中间步骤将"Hello,world!"转换，是不是很酷？
Operators介绍
接下来是如何解决item转换问题:使用operators。Operators被用于在源Observable和最终的Subscriber之间操作被发出的items。RxJava推出了非常多的operators，但是刚开始我们仅仅需要关注少数几个。
对于这种情况，map()操作能被用于将一个被发出的item转化为另一个：
Observable.just("Hello, world!")
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return s + " -Dan";
}
})
.subscribe(s -> System.out.println(s)); |
同样的，我们能使用lambda来简化这个：
Observable.just("Hello, world!")
.map(s -> s + " -Dan")
.subscribe(s -> System.out.println(s)); |
非常酷，我们的map()操作是一个转换一个item的Observable。我们可以链式调用任意个map()
，将数据改进，成为最终的Subscriber可消费的形式。
深入map()
map()有一个有趣的方面：它不需要发出和源Observable相同类型的items！
假设我的Subscriber对输出原文本不感兴趣，想要输出原文本的hash码:
Observable.just("Hello, world!")
.map(new Func1<String, Integer>() {
@Override
public Integer call(String s) {
return s.hashCode();
}
})
.subscribe(i -> System.out.println(Integer.toString(i))); |
非常有趣——我们以String开始但是我们的Subscriber接收的是一个Integer。
同样地，我们能使用lambda来简化代码：
Observable.just("Hello, world!")
.map(s -> s.hashCode())
.subscribe(i -> System.out.println(Integer.toString(i))); |
就像我之前说的，我们想要Subscriber尽可能少做事。通过另一个map()来将hash码转化为String：
Observable.just("Hello, world!")
.map(s -> s.hashCode())
.map(i -> Integer.toString(i))
.subscribe(s -> System.out.println(s)); |
你有没有发现——Observable和Subscriber回到了它们之前的样子了！我们仅仅在它们之间增加了一些转换步骤。甚至能够添加我的签名：
Observable.just("Hello, world!")
.map(s -> s + " -Dan")
.map(s -> s.hashCode())
.map(i -> Integer.toString(i))
.subscribe(s -> System.out.println(s)); |
So What？
此刻你可能会想”对于一些简单的代码，用了很多花式步伐一样技巧”。对，那是简单的例子。但是有两点你需要掌握：
关键点1:Observable和Subscriber能做任何事情
Observale可以是数据库查询，Subscriber得到结果并将它们显示在屏幕上。Observable可以是屏幕上的点击，Subscriber对它做出反应。Observable可以是从网络读取的字节流，Subscriber把它写入磁盘。
RxJava是个能够处理任何问题的通用框架。
关键点2:Observable和Subscriber独立于在它们之间的转换步骤
我可以调用任意次的map操作，在最初的源Observable和它最终的Subscriber之间。RxJava高度组件化：易于操作数据。只要操作于正确的输入输出数据，我可以制造一条无止尽的方法链。
综合以上两点，我们可以看到RxJava的巨大潜力。虽然此时我们仅仅有一个map()操作,这严重地限制了我们的能力。在第二部分，我们将深入研究更多RxJava的操作。
随时随地看视频
