Java的RxJava库操作符的用法及实例讲解

操作符就是为了解决对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)); 

使用lambda可以简化为

 
observable.just("hello, world!") 
  .map(s -> s + " -dan") 
  .subscribe(s -> system.out.println(s)); 

是不是很酷？map()操作符就是用于变换observable对象的，map操作符返回一个observable对象，这样就可以实现链式调用，在一个observable对象上多次使用map操作符，最终将最简洁的数据传递给subscriber对象。

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

很有趣吧？我们初始的observable返回的是字符串，最终的subscriber收到的却是integer，当然使用lambda可以进一步简化代码：
 

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是独立于中间的变换过程的。
在observable和subscriber中间可以增减任何数量的map。整个系统是高度可组合的，操作数据是一个很简单的过程。

实例
1.准备工作
假设我有这样一个方法：
这个方法根据输入的字符串返回一个网站的url列表（啊哈，搜索引擎）
 

observable<list<string>> query(string text);  

现在我希望构建一个健壮系统，它可以查询字符串并且显示结果。根据上一篇blog的内容，我们可能会写出下面的代码：
 

query("hello, world!") 
  .subscribe(urls -> { 
    for (string url : urls) { 
      system.out.println(url); 
    } 
  }); 

这种代码当然是不能容忍的，因为上面的代码使我们丧失了变化数据流的能力。一旦我们想要更改每一个url，只能在subscriber中来做。我们竟然没有使用如此酷的map()操作符！！！

当然，我可以使用map操作符，map的输入是urls列表，处理的时候还是要for each遍历，一样很蛋疼。

万幸，还有observable.from()方法，它接收一个集合作为输入，然后每次输出一个元素给subscriber：
 

observable.from("url1", "url2", "url3") 
  .subscribe(url -> system.out.println(url)); 

我们来把这个方法使用到刚才的场景： 

query("hello, world!") 
  .subscribe(urls -> { 
    observable.from(urls) 
      .subscribe(url -> system.out.println(url)); 
  }); 

虽然去掉了for each循环，但是代码依然看起来很乱。多个嵌套的subscription不仅看起来很丑，难以修改，更严重的是它会破坏某些我们现在还没有讲到的rxjava的特性。

2.改进
救星来了,他就是flatmap()。
observable.flatmap()接收一个observable的输出作为输入，同时输出另外一个observable。直接看代码：

query("hello, world!") 
  .flatmap(new func1<list<string>, observable<string>>() { 
    @override 
    public observable<string> call(list<string> urls) { 
      return observable.from(urls); 
    } 
  }) 
  .subscribe(url -> system.out.println(url)); 

这里我贴出了整个的函数代码，以方便你了解发生了什么，使用lambda可以大大简化代码长度：

 query("hello, world!") 
  .flatmap(urls -> observable.from(urls)) 
  .subscribe(url -> system.out.println(url)); 

flatmap()是不是看起来很奇怪？为什么它要返回另外一个observable呢？理解flatmap的关键点在于，flatmap输出的新的observable正是我们在subscriber想要接收的。现在subscriber不再收到list<string>，而是收到一些列单个的字符串，就像observable.from()的输出一样。

这部分也是我当初学rxjava的时候最难理解的部分，一旦我突然领悟了，rxjava的很多疑问也就一并解决了。

3.还可以更好
flatmap()实在不能更赞了，它可以返回任何它想返回的observable对象。
比如下面的方法： 

// 返回网站的标题，如果404了就返回null 
observable<string> gettitle(string url); 

接着前面的例子，现在我不想打印url了，而是要打印收到的每个网站的标题。问题来了，我的方法每次只能传入一个url，并且返回值不是一个string，而是一个输出string的observabl对象。使用flatmap()可以简单的解决这个问题。 

query("hello, world!") 
  .flatmap(urls -> observable.from(urls)) 
  .flatmap(new func1<string, observable<string>>() { 
    @override 
    public observable<string> call(string url) { 
      return gettitle(url); 
    } 
  }) 
  .subscribe(title -> system.out.println(title)); 

4.使用lambda:

query("hello, world!") 
  .flatmap(urls -> observable.from(urls)) 
  .flatmap(url -> gettitle(url)) 
  .subscribe(title -> system.out.println(title)); 

是不是感觉很不可思议？我竟然能将多个独立的返回observable对象的方法组合在一起！帅呆了！
不止这些，我还将两个api的调用组合到一个链式调用中了。我们可以将任意多个api调用链接起来。大家应该都应该知道同步所有的api调用，然后将所有api调用的回调结果组合成需要展示的数据是一件多么蛋疼的事情。这里我们成功的避免了callback hell（多层嵌套的回调，导致代码难以阅读维护）。现在所有的逻辑都包装成了这种简单的响应式调用。

5.丰富的操作符
目前为止，我们已经接触了两个操作符，rxjava中还有更多的操作符，那么我们如何使用其他的操作符来改进我们的代码呢？
gettitle()返回null如果url不存在。我们不想输出"null"，那么我们可以从返回的title列表中过滤掉null值！

query("hello, world!") 
  .flatmap(urls -> observable.from(urls)) 
  .flatmap(url -> gettitle(url)) 
  .filter(title -> title != null) 
  .subscribe(title -> system.out.println(title)); 

filter()输出和输入相同的元素，并且会过滤掉那些不满足检查条件的。

如果我们只想要最多5个结果：
 

query("hello, world!") 
  .flatmap(urls -> observable.from(urls)) 
  .flatmap(url -> gettitle(url)) 
  .filter(title -> title != null) 
  .take(5) 
  .subscribe(title -> system.out.println(title)); 

take()输出最多指定数量的结果。

如果我们想在打印之前，把每个标题保存到磁盘： 

query("hello, world!") 
  .flatmap(urls -> observable.from(urls)) 
  .flatmap(url -> gettitle(url)) 
  .filter(title -> title != null) 
  .take(5) 
  .doonnext(title -> savetitle(title)) 
  .subscribe(title -> system.out.println(title)); 

doonnext()允许我们在每次输出一个元素之前做一些额外的事情，比如这里的保存标题。

看到这里操作数据流是多么简单了么。你可以添加任意多的操作，并且不会搞乱你的代码。

rxjava包含了大量的操作符。操作符的数量是有点吓人，但是很值得你去挨个看一下，这样你可以知道有哪些操作符可以使用。弄懂这些操作符可能会花一些时间，但是一旦弄懂了，你就完全掌握了rxjava的威力。

你甚至可以编写自定义的操作符！这篇blog不打算将自定义操作符，如果你想的话，清自行google吧。

感觉如何？
好吧，你是一个怀疑主义者，并且还很难被说服，那为什么你要关心这些操作符呢？

因为操作符可以让你对数据流做任何操作。

将一系列的操作符链接起来就可以完成复杂的逻辑。代码被分解成一系列可以组合的片段。这就是响应式函数编程的魅力。用的越多，就会越多的改变你的编程思维。

另外，rxjava也使我们处理数据的方式变得更简单。在最后一个例子里，我们调用了两个api，对api返回的数据进行了处理，然后保存到磁盘。但是我们的subscriber并不知道这些，它只是认为自己在接收一个observable<string>对象。良好的封装性也带来了编码的便利！

在第三部分中，我将介绍rxjava的另外一些很酷的特性，比如错误处理和并发，这些特性并不会直接用来处理数据。