Android之RxJava(一)

RxJava(一)

翻译地址：http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

RxJava这段时间在Android开发者之间变得越来越火。 唯一的问题是,很难理解。 特别大部分人之前都是使用命令式编程语言。但是一旦你理解它，它是很完美的!

在这里帮你更好理解RxJava。 一共有四部分组成的。 我会尽我最大努力去讲解。让你对RxJava感兴趣,并且知道它是如何工作的。

基础：

     RxJava的基本是Observables（目标源）和Subscribers1（观察者）这两个东西。 Observable发出事件;Subscriber接受处理这些事件。一个Observable可能发出很多或者零个事件,直到通过成功或因一个错误完成终止。 发送事件之后会使subscriberObservable调用Subscriber.onNext(),让后调用的是Subscriber.onComplete()或Subscriber.onError()方法。

 RxJava看起来很像标准观察者模式,但它在一个关键不同的地方是Observables经常不开始发出事件,直到有人明确订阅 ， 换句话说:如果没有人听,树不会落在森林里。

Hello, World!

    首先让我们看看这个框架的具体的例子。 让我们创建一个基础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) { }
};

    这里subscriber仅仅就是打印observable发出的字符串，现在我们有了Observable和Subscriber对象之后，我们需要把他们关联起来，才能实现Subscriber的监听，代码如下

myObservable.subscribe(mySubscriber);
// Outputs "Hello, world!"

当mySubscriber订阅了myObservable，myObservable就会调用mySubscriber对象的onNext和onComplete方法，mySubscriber就会打印出Hello World！

更简单的代码

      上面的代码打印出"Hello, world!"，那是我们用的详细的代码,可以让你更好的理解原理。 我们可以使用RxJava的简化编码。

首先,让我们简化Observable。 RxJava有多个内置Observable创建方法。 在这种情况下,Observable.just()发出一个事件就完成,就像我们上面的代码

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);
}
};

     Observable.subscribe()可以处理一个,两个或三个Action参数代替onNext(), onError(),onComplete()吗？ 重写我们的Subscriber之前是这样的:

myObservable.subscribe(onNextAction, onErrorAction, onCompleteAction);

     然而,我们只需要第一个参数,因为我们忽视了onError()和onComplete():

myObservable.subscribe(onNextAction);
// Outputs "Hello, world!"

     最后我们简化的代码是如下

Observable.just("Hello, world!")
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
System.out.println(s);
}
});

    使用java8的lambda可以使代码更简洁

Observable.just("Hello, world!")
.subscribe(s -> System.out.println(s));

如果你在Android上(因此不能使用Java 8),我高度推荐使用retrolambda,它会减少代码的冗长。

转变代码

     假如我想在hello world中加上我的签名，你可能会想到修改Observable：

Observable.just("Hello, world! -Dan")
.subscribe(s -> System.out.println(s));

     当你改变Observable对象，当然可以，但如果不能修改Observable对象呢？比如Observable对象是第三方库提供的？比如Observable对象被多个Subscriber订阅，但是我只想在对某个订阅者做修改呢？

那么我们需要再Subscriber中对事件进行修改，代码如下：

Observable.just("Hello, world!")
.subscribe(s -> System.out.println(s + " -Dan"));

     这个答案也不尽人意,但出于不同的原因:我要我的Subscribers尽可能的轻,因为我可能会运行在主线程。 在一个更多的概念的层面上,Subscribers是应该的反应,而不是改变的。

如果我可以改变“Hello Worid! “一些中间步骤行不行呢？这样应该很帅（翻译到这里的的时候我个人理解是违背了设计原则里面的”扩展开放，修改关闭“原则，如果读者觉得不是，误喷哈）

操作符（Operators）

      操作符为了解决Observable对象变换的问题，渴用于在Observable和最终的Subscriber之间修改Observable发出的事件。RxJava提供了很多很有用的操作符。

比如map操作符，就是用来把把一个事件转换为另一个事件。

Observable.just("Hello, world!")
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return s + " -Dan";
}
})
.subscribe(s -> System.out.println(s));

简化代码：

Observable.just("Hello, world!")
.map(s -> s + " -Dan")
.subscribe(s -> System.out.println(s));

更多的map操作符

      map操作符更有趣的一点是它不必返回Observable对象返回的类型，你可以使用map操作符返回一个发出新的数据类型的observable对象。

上面的例子，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)));

有趣的——我们开始但是我们的字符串Subscriber收到一个整数。 再一次,我们可以使用lambdas缩短这段代码:

Observable.just("Hello, world!")
.map(s -> s.hashCode())
.subscribe(i -> System.out.println(Integer.toString(i)));

就像我之前说的,我们希望我们的Subscriber尽可能少。 让我们把在另一个map()我们的散列转换成一个字符串:

Observable.just("Hello, world!")
.map(s -> s.hashCode())
.map(i -> Integer.toString(i))
.subscribe(s -> System.out.println(s));

那又怎么样呢？

此时,您可能会想“这是很多花式步法一些简单的代码。 “真正的足够的;它是一个简单的例子。 但是你应该有两个想法:

关键理念# 1:Observable和Subscriber可以做任何事。

让你的想象力自由发挥!一切皆有可能。

你的Observable可能是一个数据库查询,Subscriber并在屏幕上显示结果。 你的Observable可以点击屏幕,Subscriber对它做出反应。 你的Observable可能是一个从网络流读取的字节数,Subscriber可以写磁盘。

这是一个通用框架,可以处理任何问题。

关键理念# 2:Observable和Subscriber他们之间是独立的转换步骤。

我可以把尽可能多的map放在bservable和Subscriber中间。 该系统是高度可组合的:很容易操纵数据。 只要操作人员使用正确的输入/输出数据我可以永远做一个链。

结合我们的两个关键的想法,你可以看到一个系统的潜力。 不过,在这一点上,我们只有一个操作符,map(),这严重限制了我们的能力。 在第2部分中,我们将动用大量的运营商使用RxJava时可用。