RxJava反应式编程

Book description

如今,移动App驱动着我们的生活,程序的异步性和响应式至关重要。反应式编程技术能够帮助我们编写易于扩展、性能良好且可靠性强的代码。在这本注重实战的图书中,Java开发人员首先将会学习如何以反应式的方式看待问题,然后再借助这一令人兴奋的编程范式的优秀特性构建程序。

本书包含了一些使用RxJava的具体样例,用来解决Android设备和服务器端的实际性能问题。你将会学到RxJava如何借助并行和并发解决当前的问题。本书还特别收录了2.0版本的基本情况。

  • 编写对多个异步源输入进行响应的程序,避免陷入“回调地狱”
  • 理解如何以反应式的方式解决问题
  • 处理Observable生产数据太快的问题
  • 探索调试和测试反应式程序的策略
  • 在程序中高效利用并行和并发
  • 学习如何迁移至RxJava 2.0版本

Table of contents

  1. 封面
  2. 扉页
  3. 版权
  4. 版权声明
  5. O’Reilly Media, Inc.介绍
  6. 目录
  7. 本书赞誉
  8. 译者序
  9. 前言
    1. 本书目标读者
    2. 本 • 克里斯滕森的说明
    3. 托马什 • 努尔凯维茨的说明
    4. 本书结构
    5. 在线资源
    6. 排版约定
    7. Safari® Books Online
    8. 联系我们
    9. 致谢
      1. 来自本的致谢
      2. 来自托马什的致谢
    10. 电子书
  10. 第1章 使用RxJava实现反应式编程
    1. 1.1 反应式编程与RxJava
    2. 1.2 何时需要反应式编程
    3. 1.3 RxJava是如何运行的
      1. 1.3.1 推送与拉取
      2. 1.3.2 异步与同步
      3. 1.3.3 并发与并行
      4. 1.3.4 延迟执行与立即执行
      5. 1.3.5 双重性
      6. 1.3.6 基数
    4. 1.4 阻塞I/O与非阻塞I/O
    5. 1.5 反应式抽象
  11. 第2章 Reactive Extensions
    1. 2.1 剖析rx.Observable
    2. 2.2 订阅来自Observable的通知
    3. 2.3 使用Subscription和Subscriber控制监听器
    4. 2.4 创建Observable
      1. 2.4.1 掌握Observable.create()
      2. 2.4.2 无穷流
      3. 2.4.3 计时:timer()和interval()
      4. 2.4.4 hot和cold类型的Observable
    5. 2.5 用例:从回调API到Observable流
      1. 手动管理订阅者
    6. 2.6 rx.subjects.Subject
    7. 2.7 ConnectableObservable
      1. 2.7.1 使用publish().refCount()实现单次订阅
      2. 2.7.2 ConnectableObservable的生命周期
    8. 2.8 小结
  12. 第3章 操作符与转换
    1. 3.1 核心的操作符:映射和过滤
      1. 3.1.1 使用map()进行一对一转换
      2. 3.1.2 使用flatMap()进行包装
      3. 3.1.3 使用delay()操作符延迟事件
      4. 3.1.4 flatMap()之后的事件顺序
      5. 3.1.5 使用concatMap()保证顺序
    2. 3.2 多个Observable
      1. 3.2.1 使用merge()将多个Observable合并为一个
      2. 3.2.2 使用zip()和zipWith()进行成对地组合
      3. 3.2.3 流之间不同步的情况:combineLatest()、withLatest- From()和amb()
    3. 3.3 高级操作符:collect()、reduce()、scan()、distinct()和groupBy()
      1. 3.3.1 使用Scan和Reduce扫描整个序列
      2. 3.3.2 使用可变的累加器进行缩减:collect()
      3. 3.3.3 使用single()断言的Observable只有一个条目
      4. 3.3.4 使用distinct()和distinctUntilChanged()丢弃重复条目
    4. 3.4 使用skip()、takeWhile()等进行切片和切块
      1. 3.4.1 组合流的方式:concat()、merge()和switchOnNext() (1/2)
      2. 3.4.1 组合流的方式:concat()、merge()和switchOnNext() (2/2)
      3. 3.4.2 使用groupBy()实现基于标准的切块流
      4. 3.4.3 下一步要学习什么
    5. 3.5 编写自定义的操作符
      1. 3.5.1 借助compose()重用操作符
      2. 3.5.2 使用lift()实现高级操作符
    6. 3.6 小结
  13. 第4章 将反应式编程应用于已有应用程序
    1. 4.1 从集合到Observable
    2. 4.2 BlockingObservable:脱离反应式的世界
    3. 4.3 拥抱延迟执行
    4. 4.4 组合Observable
    5. 4.5 命令式并发
    6. 4.6 flatMap()作为异步链接操作符
    7. 4.7 使用Stream代替回调
    8. 4.8 定期轮询以获取变更
    9. 4.9 RxJava的多线程
      1. 4.9.1 调度器是什么
      2. 4.9.2 使用subscribeOn()进行声明式订阅
      3. 4.9.3 subscribeOn()的并发性和行为
      4. 4.9.4 使用groupBy()进行批量请求
      5. 4.9.5 使用observeOn()声明并发
      6. 4.9.6 调度器的其他用途
    10. 4.10 小结
  14. 第5章 实现完整的反应式应用程序
    1. 5.1 解决C10k问题
      1. 5.1.1 传统的基于线程的HTTP服务器
      2. 5.1.2 借助Netty和RxNetty实现非阻塞的HTTP服务器 (1/2)
      3. 5.1.2 借助Netty和RxNetty实现非阻塞的HTTP服务器 (2/2)
      4. 5.1.3 阻塞式和反应式服务器的基准测试
      5. 5.1.4 反应式HTTP服务器之旅
    2. 5.2 HTTP客户端代码
      1. 使用RxNetty实现非阻塞的HTTP客户端
    3. 5.3 关系数据库访问
      1. 在PostgreSQL中使用NOTIFY和LISTEN的案例
    4. 5.4 CompletableFuture与Stream
      1. 5.4.1 CompletableFuture概述
      2. 5.4.2 与CompletableFuture进行交互
    5. 5.5 Observable与Single
      1. 5.5.1 创建和消费Single
      2. 5.5.2 使用zip、merge和concat组合响应
      3. 5.5.3 与Observable和CompletableFuture的交互
      4. 5.5.4 何时使用Single
    6. 5.6 小结
  15. 第6章 流控制和回压
    1. 6.1 流控制
      1. 6.1.1 定期采样和节流
      2. 6.1.2 将事件缓冲至列表中
      3. 6.1.3 窗口移动
      4. 6.1.4 借助debounce()跳过陈旧的事件
    2. 6.2 回压
      1. 6.2.1 RxJava中的回压
      2. 6.2.2 内置的回压
      3. 6.2.3 Producer与缺失回压场景
      4. 6.2.4 按照请求返回指定数量的数据
    3. 6.3 小结
  16. 第7章 测试和排错
    1. 7.1 错误处理
      1. 7.1.1 我的异常在哪里
      2. 7.1.2 替代声明式的try-catch
      3. 7.1.3 事件没有发生导致的超时
      4. 7.1.4 失败之后的重试
    2. 7.2 测试和调试
      1. 7.2.1 虚拟时间
      2. 7.2.2 单元测试中的调度器
    3. 7.3 单元测试 (1/2)
    4. 7.3 单元测试 (2/2)
    5. 7.4 监控和调试
      1. 7.4.1 doOn...()回调
      2. 7.4.2 测量和监控
    6. 7.5 小结
  17. 第8章 案例学习
    1. 8.1 使用RxJava进行Android开发
      1. 8.1.1 避免Activity中的内存泄漏
      2. 8.1.2 Retrofit对RxJava的原生支持
      3. 8.1.3 Android中的调度器
      4. 8.1.4 将UI事件作为流
    2. 8.2 使用Hystrix管理失败
      1. 8.2.1 使用Hystrix的第一步
      2. 8.2.2 使用HystrixObservableCommand的非阻塞命令
      3. 8.2.3 舱壁模式和快速失败
      4. 8.2.4 批处理和合并命令
      5. 8.2.5 监控和仪表盘
    3. 8.3 查询NoSQL数据库
      1. 8.3.1 Couchbase客户端API
      2. 8.3.2 MongoDB客户端API
    4. 8.4 Camel集成
      1. 8.4.1 通过Camel来消费文件
      2. 8.4.2 接收来自Kafka的消息
    5. 8.5 Java 8的Stream和CompletableFuture
      1. 8.5.1 并行流的用途
      2. 8.5.2 选择恰当的并发抽象
      3. 8.5.3 何时使用Observable
    6. 8.6 内存耗费和泄漏
    7. 8.7 小结
  18. 第9章 未来的方向
    1. 9.1 反应式流
    2. 9.2 Observable和Flowable
    3. 9.3 性能
    4. 9.4 迁移
  19. 附录A HTTP服务器的更多样例
    1. A.1 C语言中的fork()程序
    2. A.2 每个连接对应一个线程
    3. A.3 连接的线程池
  20. 附录B Observable操作符的决策树
  21. 附录C RxJava 1.0至RxJava 2.0的迁移指南
    1. C.1 RxJava 2.0版本的变化
      1. C.1.1 Maven地址和基础包
      2. C.1.2 Javadoc
      3. C.1.3 关于null
      4. C.1.4 Observable和Flowable
      5. C.1.5 Single
      6. C.1.6 Completable
      7. C.1.7 Maybe
      8. C.1.8 基础的反应式接口
      9. C.1.9 Subject和Processor
      10. C.1.10 其他的类
      11. C.1.11 函数式接口
      12. C.1.12 Subscriber
      13. C.1.13 Subscription
      14. C.1.14 回压
      15. C.1.15 遵循反应式流协议
      16. C.1.16 运行时挂钩
      17. C.1.17 错误处理
      18. C.1.18 Scheduler
      19. C.1.19 进入反应式的世界
      20. C.1.20 脱离反应式的世界
      21. C.1.21 测试
      22. C.1.22 操作符的差异
      23. C.1.23 杂项变更
    2. C.2 RxJava 2.0版本中的回压
      1. C.2.1 回压概述
      2. C.2.2 onBackpressureXXX操作符
      3. C.2.3 创建支持回压的数据源 (1/2)
      4. C.2.3 创建支持回压的数据源 (2/2)
  22. 关于作者
  23. 关于封面

Product information

  • Title: RxJava反应式编程
  • Author(s): Tomasz Nurkiewicz, Ben Christensen
  • Release date: December 2019
  • Publisher(s): Posts & Telecom Press
  • ISBN: 9787115524003

You might also like

book

Go程序设计语言

by 艾伦A. A.多诺万, 布莱恩W. 柯尼汉

本书由《C程序设计语言》的作者Kernighan和谷歌公司Go团队主管Alan Donovan联袂撰写,是学习Go语言程序设计的权威指南。本书共13章,主要内容包括:Go的基础知识、基本结构、基本数据类型、复合数据类型、函数、方法、接口、goroutine、通道、共享变量的并发性、包、go工具、测试、反射等。

book

Kafka权威指南(第2版)

by Gwen Shapira, Todd Palino, Rajini Sivaram, Krit Petty

本书第1版出版时,有超过30%的《财富》世界500强公司使用Kafka。5年后,这个比例已经达到70%。毋庸置疑,作为大数据时代的核心技术,Kafka已然成为所有动态数据平台的事实基础。本书为使用Kafka的软件工程师、架构师和运维工程师勾勒出一条完整的学习曲线,并强调原理剖析和应用实践。 来自Confluent和LinkedIn的一线Kafka开发人员将为你解释如何部署生产级Kafka集群、编写可靠的事件驱动微服务,以及使用Kafka构建可伸缩的流处理应用程序。通过详细的示例,你将了解Kafka的设计原则、可靠性保证,以及架构细节,包括复制协议、控制器和存储层。第2版更详细地介绍编程式管理Kafka、精确一次性语义、Kafka的安全性等内容。 部署和配置Kafka的良好实践 Kafka生产者和消费者如何读写消息 确保可靠传递数据的模式和用例要求 用Kafka构建数据管道和应用程序 用Kafka在生产环境中执行监控、调优和维护任务 Kafka的关键运维指标 Kafka针对流处理系统的交付能力

book

Kafka权威指南

by Neha Narkhede, Gwen Shapira, Todd Palino

每个应用程序都会产生数据,包括日志消息、度量指标、用户活动记录、响应消息等。如何移动数据,几乎变得与数据本身一样重要。如果你是架构师、开发者或者产品工程师,同时也是Apache Kafka新手,那么这本实践指南将会帮助你成为流式平台上处理实时数据的专家。 本书由出身于LinkedIn的Kafka核心作者和一线技术人员共同执笔,详细介绍了如何部署Kafka集群、开发可靠的基于事件驱动的微服务,以及基于Kafka平台构建可伸缩的流式应用程序。通过详尽示例,你将会了解到Kafka的设计原则、可靠性保证、关键API,以及复制协议、控制器和存储层等架构细节。 了解发布和订阅消息模型以及该模型如何被应用在大数据生态系统中 学习使用Kafka生产者和消费者来生成消息和读取消息 了解Kafka保证可靠性数据传递的模式和场景需求 使用Kafka构建数据管道和应用程序的最佳实践 在生产环境中管理Kafka,包括监控、调优和维护 了解Kafka的关键度量指标 探索Kafka如何成为流式处理利器

book

SQL经典实例

by Anthony Molinaro

了解SQL查询语言的基本原理,但仍感觉无法自由运用SQL?想在数据上线前用SQL跑一遍数据库?想进一步提高SQL技能? 以上需求,《SQL经典实例》都可以满足。本书致力于让广大数据库相关人员了解SQL的强大数据处理能力。书中汇集了150多个SQL示例,给出了常见问题的解决方案,帮助读者扩宽思路并用学到的技术来解决新问题,既适合SQL初学者更深入理解SQL,也适合SQL中高级用户进阶及日常查询参考。 where子句等常见查询语句 查询结果排序 连接查询 如何获取数据库元信息 常见数字运算实例 字符串处理 日期处理 数据仓储和复杂报表生成领域的查询 与层次化有关的一些实例