[正版]反应式编程实战 使用RxJava 2.x开发Android应用 清华大学出版社 蒂莫·图奥米宁

《反应式编程实战 使用RxJava 2.x开发Android应用》首先引导读者以反应的方式考虑编程和数据。本书详细介绍了Android中RxJava的核心模式，并解释了视图模型。然后探讨了备受追捧的应用功能，例如聊天客户端和巧妙的转换。最后，读者将了解与函数式反应式编程(FRP)思维紧密结合的高层设计关注点、架构方法和框架。

主要内容

● 反应式编程简介

● 简单的线程管理

● 提高UI反应能力

● 异步思维方式

● 构建一个有效的聊天客户端

Timo Tuominen在与Futurice合作时，作为三星公司的主要Android项目的架构师，他广泛使用了FRP和RxJava。作为一名顾问，他已经在几乎所有相关的平台上开发了几十个敏捷项目，其中也有一些失败的项目。如今，他可以在任何项目中使用FRP。

对于Android开发人员来说，编写多线程应用具有挑战性。RxJava简化了复杂的线程操作，并能够在线程之间无缝切换时保持适当的同步。在应用中RxJava还体现出了反应式编程的优势，它意味着更好的实时反应能力，是每个Android开发人员的圣杯。《反应式编程实战 使用RxJava 2.x开发Android应用》内容分为三个部分。第一部分介绍如何在Android应用中使用RxJava处理异步事件和网络请求。第二部分以文件资源管理器应用和井字游戏应用为例说明如何使用视图模型优化体系结构，以及如何对RxJava代码进行单元测试。第三部分首先深入探讨如何使用WebSocket协议来构建实时聊天客户端应用，然后介绍如何使用Rx和视图模型进行动画UI高级开发，最后展示如何在RxJava中完整创建可拖动和可缩放的地图客户端应用。另外，本书的所有章节都有完整的公开在线代码示例。

目  录

第Ⅰ部分  反应式核心编程

第1章  反应式编程简介   3

1.1  你阅读本书的原因   3

1.2  不要阅读本书的情形   4

1.3  OOP、Rx、FP和FRP   5

1.3.1  OOP，面向对象编程   5

1.3.2  FP，函数式编程   5

1.3.3  FRP，函数反应式编程   5

1.3.4  Rx，反应式编程   5

1.4  Rx的特征   5

1.5  编写的代码就是所实现的功能   6

1.5.1  灰色代码   7

1.5.2  反应式编程开发   7

1.6  反应式总览   8

1.6.1  移动开发   8

1.6.2  Web和HTML5   9

1.6.3  后端系统和Rx   9

1.7  在开始学习之前你需要知道什么   10

1.7.1  你需要具备的条件   10

1.7.2  你不需要具备的条件   10

1.8  关于本书   10

1.8.1  在线代码示例   10

1.8.2  茶歇   11

1.9  RxJava 2和Android   11

1.9.1  为什么选择Java   11

1.9.2  为什么选择RxJava   11

1.10  设置Android环境   12

1.10.1  Google Android Studio   12

1.10.2  Git   12

1.10.3  RxJava 2依赖项   12

1.11  Java 8 lambda   12

1.11.1  什么是lambda函数   13

1.11.2  剖析lambda函数   13

1.11.3  lambda函数有什么优点   14

1.12  深入研究Rx：实时搜索   14

1.13  项目设置   15

1.13.1  一种快速实现   15

1.13.2  基于时间筛选文本更改   15

1.14  作为数据的emitter的文本输入   15

1.15  发布-订阅模式   16

1.16  作为observable的文本输入   17

1.17  筛选observable   18

1.17.1  .filter操作符   19

1.17.2  observable和subscriber的时间解耦   20

1.18  时间延迟   20

1.19  延迟时间的优势   21

1.20  debounce操作符   21

1.21  将代码放入Android系统中   23

1.22  反应式编程的原理   25

1.23  事件和弹珠图   26

1.24  本章小结   26

第2章  连接observable   29

2.1  RxJava和事件流   29

2.2  subscriber   30

2.3  RxJava 2 observable的类型   31

2.3.1  Observable   31

2.3.2  Single   31

2.3.3  Maybe   31

2.3.4  Completable   31

2.3.5  Flowable   32

2.4  订阅并转换不同的observable   32

2.5  当发出正常的网络请求时会发生什么   32

2.6  当observable发出网络请求时会发生什么   33

2.7  网络请求作为observable   34

2.8  示例：RSS提要聚合器   35

2.9  提要结构   36

2.10  获取数据   37

2.11  combineLatest操作符   37

2.12  到目前为止的Rx代码   38

2.13  异步数据处理链   40

2.14  按顺序排列列表   42

2.15  .map操作符   42

2.15.1  操作符的有效期   43

2.15.2  使用.map对列表进行排序   43

2.16  不变性简介   45

2.16.1  不具有不变性的链   46

2.16.2  具有不可变数据的链   46

2.16.3  使用不变性解决问题   47

2.16.4  Java中的builder   47

2.17  错误处理   48

2.17.1  网络错误及其处理   49

2.17.2  当真正的错误出现时，该怎么办   50

2.18  向客户端添加更多提要   51

2.18.1  提要observable列表   51

2.18.2  细说combineLatest   51

2.18.3  有多个弹珠的combineLatest   52

2.19  本章小结   53

2.19.1  未来展望   53

2.19.2  从事件到反应式状态   53

第3章  建立数据处理链   55

3.1  observable的不同角色   55

3.1.1  observable事件   55

3.1.2  反应变量   56

3.1.3  篮子中橘子的数量   56

3.2  事件与反应状态   57

3.2.1  observable的click事件   57

3.2.2  开关按钮   57

3.2.3  将事件转换为状态   57

3.2.4  作为反应变量的observable   58

3.3  observable的内部状态   58

3.4  箭头图和不同的observable类型   59

3.5  示例：信用卡验证表单   60

3.5.1  信用卡验证器   60

3.5.2  布局   60

3.5.3  信用卡卡号的工作原理   61

3.5.4  按步骤验证数字   62

3.5.5  输入   62

3.5.6  输出   62

3.5.7  解方程式   63

3.6  第一步：有效期   63

3.7  信用卡卡号类型和校验和   65

3.7.1  卡类型   65

3.7.2  检查已知的CardType   67

3.7.3  计算校验和   67

3.7.4  信用卡卡号输入验证的大图   68

3.8  CVC代码验证   68

3.9  融会贯通   70

3.9.1  登录FRP链   71

3.9.2  完整图   71

3.10  反应式编程的抽象层次   72

3.11  RxJava的工作原理   74

3.12  本章小结   75

3.12.1  反应图的优点   75

3.12.2  表单改进   75

第4章  通过网络连接用户界面   77

4.1  订阅解释   77

4.2  终止订阅   79

4.2.1  已经完成的observable信号   79

4.2.2  Disposable对象用于取消订阅   80

4.3  RxJava 2概念和订阅管理   81

4.3.1  新subscribe函数签名   81

4.3.2  subscribe函数重载   81

4.3.3  作为subscriber的基本consumer接口   82

4.3.4  LambdaObserver   82

4.4  高级Rx链示例：Flickr搜索客户端   82

4.5  设置Flickr客户端项目   83

4.5.1  申请API密钥   83

4.5.2  将API放到gradle.properties中   84

4.6  搜索链概述   84

4.7  步骤1：简单的硬编码搜索   85

4.7.1  搜索API返回的数据类型   86

4.7.2  搜索并呈现   86

4.7.3  到目前为止已实现的功能   86

4.8  click事件   87

4.8.1  使用onClickListener触发搜索   87

4.8.2  使用订阅   88

4.8.3  管理订阅   88

4.8.4  流式方法   88

4.9  实现反应链   90

4.9.1  连通数据图   91

4.9.2  启动链中的异步操作   92

4.10  switchMap的工作原理   92

4.11  获取缩略图信息   94

4.12  步骤1：将列表扩展为一个observable   95

4.12.1  flatMap操作符   95

4.12.2  Observable.merge   95

4.12.3  在嵌套的observable中使用merge   96

4.12.4  flatMap   97

4.12.5  使用flatMap扩展列表   97

4.12.6  代码中的内容   97

4.13  步骤2: 分别对每一项应用操作   98

4.14  步骤3：收集结果   98

4.15  完整的解决方案   99

4.15.1  图中间的关键代码   100

4.15.2  组合代码   100

4.16  添加来自其他API的用户名   101

4.17  本章小结   102

第5章  高级RxJava   105

5.1  深入了解observable和subject   105

5.2  示例：文件浏览器   106

5.3  文件浏览器应用的用户流   107

5.4  获取目录的文件列表   108

5.4.1  返回目录内容列表的函数   109

5.4.2  Android权限   109

5.4.3  使用Observable.create创建自定义observable   109

5.4.4  将文件listing函数封装到FileListingObservable中   110

5.4.5  文件列表observable的生命周期   111

5.5  线程基础   112

5.5.1  什么是线程   112

5.5.2  尚未解决的问题   113

5.5.3  具有输入和输出功能的函数   113

5.6  函数式编程中的线程   114

5.6.1  反应式函数链   114

5.6.2  显示有副作用的结果   115

5.7  使用getFileListingObservable更改线程   115

5.7.1  线程更改   115

5.7.2  使用observeOn更改线程   116

5.7.3  使用subscribeOn更改线程   117

5.7.4  在代码中使用subscribeOn   118

5.8  使文件列表动态化   118

5.8.1  切换到fileObservable作为源   119

5.8.2  形成完整的链   119

5.8.3  Observable.just   119

5.9  列表click事件   120

5.10  subject的不同类型   121

5.10.1  PublishSubject   122

5.10.2  BehaviorSubject   122

5.11  使用subject作为FileObservable   123

5.12  添加PREVIOUS和ROOT按钮   126

5.13  PREVIOUS和ROOT的扩展图   126

5.13.1  对两个新按钮进行编码   127

5.13.2  第一个版本准备好了   128

5.14  更清晰observable的改进版本   128

5.15  PREVIOUS按钮   129

5.16  融会贯通   130

5.17  详细图   131

5.18  到目前为止的完整代码   131

5.19  保存并释放订阅   133

5.20  关于subject的最后说明   135

5.21  本章小结   136

第Ⅱ部分  RxJava中的架构

第6章  反应式视图模型   141

6.1  视图层   141

6.1.1  视图   142

6.1.2  视图和文件浏览器   142

6.2  平台容器   143

6.2.1  平台容器的特征   143

6.2.2  平台容器的生命周期   143

6.3  视图模型   144

6.4  视图模型的蓝图   146

6.4.1  视图模型的特征   147

6.4.2  将现有代码迁移到视图模型中   147

6.4.3  获取视图模型中的外部数据   148

6.4.4  视图模型的完整构造函数   149

6.5  连接视图和视图模型   150

6.5.1  设置视图和视图模型   150

6.5.2  显示视图模型的输出   151

6.5.3  将视图模型绑定到视图   151

6.6  全貌   153

6.7  视图模型生命周期   154

6.7.1  在视图模型中保存订阅   154

6.7.2  视图模型的代码   154

6.8  视图模型和Android生命周期   157

6.8.1  视图模型Subscribe/Unsubscribe   157

6.8.2  视图模型到视图绑定   157

6.8.3  改进的视图模型生命周期   158

6.8.4  全貌   158

6.8.5  Android 上的视图模型阶段   159

6.8.6  onResume和onPause的代码   160

6.9  代码的视图关联性   161

6.10  本章小结   162

第7章  反应式架构   163

7.1  反应式架构基础   163

7.2  模型-视图-视图模型   164

7.2.1  拆分类   164

7.2.2  模型的内部关系   165

7.2.3  所说的数据库是真实的数据库吗   165

7.3  反应模型   166

7.3.1  作为实体存储库的Web服务器   166

7.3.2  Web请求流程   166

7.3.3  Web服务器的模型   167

7.3.4  模型在哪里   168

7.3.5  实体存储库的模型   168

7.4  从模型中检索数据   169

7.5  修改文件浏览器   171

7.6  构建文件浏览器的模型   172

7.6.1  现有的文件浏览器视图模型   172

7.6.2  将状态从视图模型移入模型   173

7.6.3  FileBrowser模型实现   174

7.7  使用模型   175

7.7.1  创建模型   175

7.7.2  更新视图模型中的模型   176

7.7.3  从视图模型中删除逻辑   176

7.8  模型及其使用者的规则   177

7.8.1  模型是事实的唯一来源   177

7.8.2  模型首先提供最新值   177

7.8.3  模型的所有使用者都必须准备好接收更新   177

7.9  事实的唯一来源   178

7.9.1  模型是应用的维基百科   178

7.9.2  使用显式缓存的好处   180

7.10  持久化应用状态   180

7.10.1  原子状态   181

7.10.2  保存模型状态   181

7.10.3  保存模型状态的代码   182

7.10.4  启动时加载模型状态   183

7.10.5  加载模型状态的代码   184

7.11  BehaviorSubject和存储   184

7.12  简单的SharedPreferencesStore   185

7.13  本章小结   186

7.13.1 作为事实来源的模型   187

7.13.2  反应式架构的其他部分   187

第8章  使用视图模型进行开发   189

8.1  视图模型和视图   189

8.2  示例：井字游戏   190

8.3  绘制游戏网格   191

8.3.1  draw函数   192

8.3.2  尝试使用具有硬编码值的视图   193

8.4  使其具有交互性   194

8.4.1  反应式处理链   195

8.4.2  网格坐标解析代码   195

8.4.3  解析网格位置的代码   196

8.4.4  扩展的图结构   197

8.5  事件与反应状态   198

8.5.1  划清事件和状态之间的界限   198

8.5.2  不同observable的示例   199

8.6  不可变数据和游戏网格   200

8.6.1  复制网格   201

8.6.2  更改GameGrid   201

8.6.3  Java中的变量引用和原始数据类型   201

8.6.4  GameGrid类型和setter函数   203

8.7  添加交互代码   203

8.7.1  准备工作   203

8.7.2  基于事件更新GameGrid   204

8.7.3  包含.withLatestFrom的循环图   205

8.8  将逻辑封装到视图模型中   210

8.9  使用click事件进行坐标处理   212

8.10  更改回合   213

8.10.1  连接多个视图模型输出   214

8.10.2  改进的网格数据类型   215

8.10.3  更新playerInTurn-Observable   215

8.10.4  在图中插入玩家回合   216

8.10.5  GameState结构   217

8.11  过滤非法动作   219

8.11.1  阻止非空图块   219

8.11.2  使用pair临时捆绑数据   220

8.11.3  向GameViewModel添加过滤   220

8.12  获胜条件   221

8.12.1  确定GameState的代码   222

8.12.2  生成getWinner函数   222

8.12.3  在UI中显示GameState   223

8.12.4  视图绑定代码   224

8.12.5  游戏结束后过滤所有动作   225

8.13  还有一件事：重新启动游戏   225

8.14  本章小结   226

第9章  扩展现有的Rx应用   229

9.1  使用现有的反应代码   229

9.2  四子棋游戏   230

9.3  更新网格尺寸和资源   230

9.3.1  资源和绘图   231

9.3.2  黑色和红色   231

9.3.3  放置标记   231

9.3.4  井字游戏反应图   232

9.3.5  把井字游戏图改为四子棋游戏图   232

9.3.6  在四子棋游戏中放入标记   233

9.3.7  dropping函数的代码   234

9.4  检查有效动作   235

9.4.1  允许的动作   235

9.4.2  更新的事件处理链   237

9.4.3  回顾事件处理中的步骤   238

9.5  保存并加载游戏   240

9.6  创建模型   240

9.6.1  原始图   241

9.6.2  将GameState移到模型中   241

9.6.3  GameModel代码   242

9.7  共享模型   243

9.7.1  “保持简单”的版本   243

9.7.2  扩展过于简单的版本   244

9.7.3  更新反应方式   244

9.7.4  存储和observable   246

9.8  加载游戏活动   247

9.9  PersistedGameStore   248

9.10  保存游戏   250

9.11  加载游戏   251

9.12  本章小结   252

第10章  测试反应代码   253

10.1  反应式架构和测试   253

10.2  测试粒度   254

10.3  依赖项金字塔结构   254

10.3.1  测试的类型   255

10.3.2  应用中的外部因素   256

10.4  单元测试基础   256

10.4.1  布置、动作、断言   256

10.4.2  什么是测试   256

10.4.3  单元测试的代码示例   256

10.5  测试反应链   257

10.5.1  为RxJava和Mockito设置测试   258

10.5.2  测试自定义的observable   258

10.5.3  介绍test subscriber   258

10.6  TestObservable类   259

10.6.1  检查终止   259

10.6.2  检查输出的值   259

10.6.3  测试observable的列表排序   259

10.6.4  测试异步代码   260

10.7  同步或者异步   260

10.7.1  尝试测试一个行为异常的函数   260

10.7.2  测试单线程RxJava函数   261

10.8  编写视图模型的测试   264

10.8.1  四子棋游戏视图模型   264

10.8.2  GameViewModel输入的作用   264

10.9  选择测试什么   265

10.10  测试GameViewModel初始状态   266

10.10.1  设置测试用例   266

10.10.2  第一个视图模型测试用例   267

10.11  测试部分observable链   268

10.11.1  提取链   269

10.11.2  作为静态函数的部分反应链   269

10.12  测试四子棋游戏放置逻辑   270

10.12.1  放置逻辑的测试用例   270

10.12.2  模拟依赖项   271

10.13  本章小结   272

第Ⅲ部分  高级RxJava架构

第11章  高级架构聊天客户端1   275

11.1  使用WebSocket的聊天客户端   275

11.2  如何传输消息   276

11.3  WebSocket   276

11.4  作为广播者的WebSocket   277

11.5  连接到服务器   278

11.6  ChatMessage结构   280

11.7  发送ChatMessage   281

11.7.1  消息数据流   281

11.7.2  发送ChatMessage时的错误   282

11.7.3  运行应用   282

11.8  将监听器包装到observable中   283

11.8.1  包含Observable.create的监听器   283

11.8.2  取消订阅时释放监听器   283

11.9  基本UI   285

11.10  显示消息   287

11.10.1  绘制视图模型和视图   287

11.10.2  创建ArrayAdapter   287

11.11  视图模型   288

11.11.1  设置   289

11.11.2  初步实现   289

11.12  累加ChatMessage   290

11.13  整合消息处理   291

11.14  使用视图模型中的值   293

11.15  视图模型生命周期   293

11.16  创建视图模型生命周期   294

11.16.1  使视图模型了解其订阅   294

11.16.2  Subscribe和Unsubscribe方法   295

11.17  本章小结   295

11.17.1  取消订阅时的清理   296

11.17.2  视图模型和架构   296

第12章  高级架构聊天客户端2   297

12.1  视图模型、存储和模型   297

12.1.1  聊天客户端概述   297

12.1.2  聊天客户端架构   298

12.2  消息挂起状态   299

12.3  处理状态更新   300

12.4  作为aggregator的存储   300

12.4.1  aggregator是存储吗   301

12.4.2  将aggregator切换到存储   301

12.5  存储的代码   302

12.5.1  解析器的故事   303

12.5.2  最初的存储实现   303

12.5.3  更新的视图模型   303

12.5.4  更新的Activity代码   304

12.6  实现挂起的消息   307

12.6.1  呈现挂起状态   307

12.6.2  聊天消息format函数   308

12.7  用确认的消息替换挂起的消息   308

12.7.1  消息ID   309

12.7.2  消息更新流程   309

12.8  更新存储代码   310

12.8.1  使用映射避免重复   310

12.8.2  对映射进行编码   311

12.8.3  副作用：消息顺序   311

12.9  挂起状态的处理代码   311

12.10  模型   314

12.10.1  作为容器的数据层   314

12.10.2  简化的高级架构   315

12.10.3  频谱中的模型   315

12.11  模型的代码   316

12.12  模型生命周期   317

12.13  单例模块   318

12.14  用于生产的Android工具   320

12.14.1  Dagger   320

12.14.2  Subject   320

12.14.3  意外终止observable   320

12.14.4  声明错误处理程序   321

12.14.5  日志记录和线程   321

12.14.6  存储   321

12.15  本章小结   321

12.15.1  视图模型   321

12.15.2  模型   322

12.15.3  表示器   322

第13章  Rx转换   323

13.1  状态之间的转换   323

13.1.1  “即发即弃”策略   324

13.1.2  小故障   324

13.2  应该是怎样的   325

13.2.1  更复杂的场景   326

13.2.2  UI状态不是真或假   326

13.3  使用一个数字的动画进度   327

13.4  反应参数化   328

13.5  示例：风扇小部件   329

13.6  设置子视图的转换   330

13.6.1  每个子视图的总旋转角度   330

13.6.2  设置旋转中心   331

13.7  使用RxJava和Android进行动画处理   333

13.8  更改FanView的代码   334

13.9  视图模型   336

13.9.1  连接视图模型和视图   336

13.9.2  视图模型输入和输出   336

13.10  视图模型逻辑   337

13.11  在视图模型中激活参数化的值   339

13.12  animateTo操作符   340

13.13  Android上的animateTo操作符   342

13.14  添加暗淡的背景   343

13.15  本章小结   345

13.15.1  动画和视图模型   345

13.15.2  接下来的内容   346

第14章  创建地图客户端   347

14.1  地图示例   347

14.1.1  为什么使用地图   347

14.1.2  地图绘制基础   348

14.2  地图图块入门   348

14.2.1  通向世界的窗口   348

14.2.2  合并网格和窗口   349

14.2.3  绘制空图块需要哪些数据   350

14.3  创建初始视图模型   351

14.4  根据缩放级别计算图块   352

14.4.1  计算缩放级别的所有图块   353

14.4.2  移动地图图块   354

14.4.3  地图偏移量   354

14.5  使用偏移量移动图块   355

14.6  拖动地图   356

14.6.1  拖动和反应   357

14.6.2  使用xyMovementEvents更新偏移量   358

14.7  到目前为止的代码   359

14.8  Viewport和隐藏图块   359

14.8.1  计算可见图块的矩形   360

14.8.2  插入可见的图块   361

14.9  加载地图图块   361

14.9.1  下载地图图像   362

14.9.2  地图图块加载程序   363

14.10  添加缩放级别控件   364

14.10.1  图   364

14.10.2  代码   365

14.10.3  缩放级别地图偏移量限制   365

14.11  添加对地图坐标的支持   365

14.11.1  数学知识   366

14.11.2  构建lat/lng地图中心的代码   367

14.12  本章小结   368

附录A  Android开发教程   371