Android：手把手带你入门神秘的 Rxjava

前言

• Rxjava因为其基于事件流的链式调用、逻辑简洁 & 使用简单的特色，深受各大 Android开发者的欢迎。

• 本文主要：

  1. 面向 刚接触Rxjava的初学者

  2. 提供了一份 清晰、简洁、易懂的Rxjava入门教程

      

  3. 解决的是初学者不理解Rxjava原理 & 不懂得如何使用的问题

但愿大家会喜欢。

1.  
2.  
3.  

目录

1. 定义

• RxJava 在 GitHub 的介绍：

• 1
• 2

• 总结：RxJava 是一个 基于事件流、实现异步操做的库

2. 做用

实现异步操做

 

3. 特色

因为 RxJava的使用方式是：基于事件流的链式调用，因此使得 RxJava：

• 逻辑简洁
• 实现优雅
• 使用简单

更重要的是，随着程序逻辑的复杂性提升，它依然可以保持简洁 & 优雅

4. 原理

4.1 生活例子引入

• 我用一个生活例子引入 & 讲解 Rxjava原理： 顾客到饭店吃饭

4.2 Rxjava原理介绍

• Rxjava原理 基于 一种扩展的观察者模式

• Rxjava的扩展观察者模式中有4个角色：

角色	做用	类比
被观察者（Observable）	产生事件	顾客
观察者（Observer）	接收事件，并给出响应动做	厨房
订阅（Subscribe）	链接 被观察者 & 观察者	服务员
事件（Event）	被观察者 & 观察者 沟通的载体	菜式

• 具体原理

请结合上述 顾客到饭店吃饭 的生活例子理解： 

即RxJava原理可总结为：被观察者 （Observable） 经过 订阅（Subscribe） 按顺序发送事件 给观察者 （Observer）， 观察者（Observer） 按顺序接收事件 & 做出对应的响应动做。具体以下图：

至此，RxJava原理讲解完毕。

5. 基本使用

• 本文只关注 RxJava的基本使用，更深刻的RxJava使用请继续关注Carson_Ho的安卓开发笔记
• Rxjava的使用方式有两种： 
  1. 分步骤实现：该方法主要为了深刻说明Rxjava的原理 & 使用，主要用于演示说明
  2. 基于事件流的链式调用：主要用于实际使用

5.1 方式1：分步骤实现

5.1.1 使用步骤

5.1.2 步骤详解

步骤1：建立被观察者 （Observable ）& 生产事件

• 即 顾客入饭店 - 坐下餐桌 - 点菜
• 具体实现

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40

步骤2：建立观察者 （Observer ）并 定义响应事件的行为

• 即 开厨房 - 肯定对应菜式
• 发生的事件类型包括：Next事件、Complete事件 & Error事件。具体以下：

• 具体实现

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70

步骤3：经过订阅（Subscribe）链接观察者和被观察者

• 即 顾客找到服务员 - 点菜 - 服务员下单到厨房 - 厨房烹调
• 具体实现

• 1
• 2

• 扩展说明

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

5.2 方式2：优雅的实现方法 - 基于事件流的链式调用

• 上述的实现方式是为了说明Rxjava的原理 & 使用
• 在实际应用中，会将上述步骤&代码连在一块儿，从而更加简洁、更加优雅，即所谓的 RxJava基于事件流的链式调用

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39

这种 基于事件流的链式调用，使得RxJava：

• 逻辑简洁
• 实现优雅
• 使用简单

更重要的是，随着程序逻辑的复杂性提升，它依然可以保持简洁 & 优雅。因此，通常建议使用这种基于事件流的链式调用方式实现RxJava。

特别注意

RxJava 2.x 提供了多个函数式接口 ，用于实现简便式的观察者模式。具体以下： 

以 Consumer为例：实现简便式的观察者模式

• 1
• 2
• 3
• 4
• 5
• 6
• 7

6. 实例说明

我将用一个实际工程实例来演示 Rxjava的使用

6.1 方式1：分步骤实现

步骤1：加入依赖

• 1
• 2

步骤2：直接在MainActivity.java中实现下述步骤 
1. 建立被观察者 （Observable ）& 生产事件 
2. 建立观察者 （Observer ）并 定义响应事件的行为 
3. 经过订阅（Subscribe）链接观察者和被观察者

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61

• 测试结果

6.2 方式2：基于事件流的链式调用方式

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46

• 测试效果 
  实现效果同上 
  

• Demo 下载地址 
  Carson_Ho的Github地址 = RxJava2系列：基础使用

7. 额外说明

7.1 观察者 Observer的subscribe()具有多个重载的方法

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

7.2 可采用 Disposable.dispose() 切断观察者 与 被观察者 之间的链接

• 即观察者 没法继续 接收 被观察者的事件，但被观察者仍是能够继续发送事件
• 具体使用

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33

• 效果图

8. 总结

• 本文主要对 Rxjava 的入门知识进行讲解，包括基本介绍、原理 & 具体使用等
• 接下来，我将持续推出 Android中 Rxjava 2.0 的一系列文章，包括原理、操做符、应用场景、背压等等 ，有兴趣能够继续关注Carson_Ho的安卓开发笔记！！