RXJAVA反应式编程 影印版pdf电子书版本下载

点此进入-本书在线PDF格式电子书下载【推荐-云解压-方便快捷】直接下载PDF格式图书。移动端-PC端通用
种子下载[BT下载速度快] 温馨提示：（请使用BT下载软件FDM进行下载）软件下载地址页 直链下载[便捷但速度慢]   [在线试读本书]   [在线获取解压码]

RXJAVA反应式编程 影印版PDF格式电子书版下载

下载的文件为RAR压缩包。需要使用解压软件进行解压得到PDF格式图书。

建议使用BT下载工具Free Download Manager进行下载,简称FDM(免费,没有广告,支持多平台）。本站资源全部打包为BT种子。所以需要使用专业的BT下载软件进行下载。如 BitComet qBittorrent uTorrent等BT下载工具。迅雷目前由于本站不是热门资源。不推荐使用！后期资源热门了。安装了迅雷也可以迅雷进行下载！

（文件页数 要大于 标注页数，上中下等多册电子书除外）

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

1．Reactive Programming with RxJava 1

Reactive Programming and RxJava 1

When You Need Reactive Programming 3

How RxJava Works 4

Push versus Pull 4

Async versus Sync 5

Concurrency and Parallelism 8

Lazy versus Eager 12

Duality 13

Cardinality 15

Mechanical Sympathy：Blocking versus Nonblocking I/O 20

Reactive Abstraction 25

2．Reactive Extensions 27

Anatomy of rx.Observable 27

Subscribing to Notifications from Observable 30

Capturing All Notifications by Using Observer＜T＞ 32

Controlling Listeners by Using Subscription and Subscriber＜T＞ 32

Creating Observables 34

Mastering Observable.create（） 35

Infinite Streams 38

Timing：timer（）and interval（） 43

Hot and Cold Observables 43

Use Case：From Callback API to Observable Stream 45

Manually Managing Subscribers 49

rx.subjects.Subject 51

ConnectableObservable 53

Single Subscription with publish（）.refCount（） 54

ConnectableObservable Lifecycle 56

Summary 59

3．Operators and Transformations 61

Core Operators：Mapping and Filtering 61

1-to-1 Transformations Using map（） 64

Wrapping Up Using flatMap（） 67

Postponing Events Using the delay（）Operator 72

Order of Events After flatMap（） 73

Preserving Order Using concatMap（） 75

More Than One Observable 77

Treating Several Observables as One Using merge（） 78

Pairwise Composing Using zip（）and zipWith（） 79

When Streams Are Not Synchronized with One Another：combineLatest（）,withLatestFrom（）,and amb（） 83

Advanced Operators：collect（）,reduce（）,scan（）,distinct（）,and groupBy（） 88

Scanning Through the Sequence with Scan and Reduce 88

Reduction with Mutable Accumulator：collect（） 91

Asserting Observable Has Exactly One Item Using single（） 92

Dropping Duplicates Using distinct（）and distinctUntilChanged（） 92

Slicing and Dicing Using skip（）,takeWhile（）,and Others 94

Ways of Combining Streams：concat（）,merge（）,and switchOnNext（） 97

Criteria-Based Splitting of Stream Using groupBy（） 104

Where to Go from Here？ 107

Writing Customer Operators 107

Reusing Operators Using compose（） 108

Implementing Advanced Operators Using lift（） 110

Summary 115

4．Applying Reactive Programming to Existing Applications 117

From Collections to Observables 118

BlockingObservable：Exiting the Reactive World 118

Embracing Laziness 121

Composing Observables 123

Lazy paging and concatenation 124

Imperative Concurrency 125

flatMap（）as Asynchronous Chaining Operator 131

Replacing Callbacks with Streams 136

Polling Periodically for Changes 138

Multithreading in RxJava 140

What Is a Scheduler？ 141

Declarative Subscription with subscribeOn（） 150

subscribeOn（）Concurrency and Behavior 154

Batching Requests Using groupBy（） 158

Declarative Concurrency with observeOn（） 159

Other Uses for Schedulers 163

Summary 164

5．Reactive from Top to Bottom 165

Beating the C10k Problem 165

Traditional Thread-Based HTTP Servers 167

Nonblocking HTTP Server with Netty and RxNetty 169

Benchmarking Blocking versus Reactive Server 177

Reactive HTTP Servers Tour 183

HTTP Client Code 184

Nonblocking HTTP Client with RxNetty 184

Relational Database Access 187

NOTIFY AND LISTEN on PostgreSQL Case Study 189

CompletableFuture and Streams 193

A Short Introduction to CompletableFuture 193

Interoperability with CompletableFuture 198

Observable versus Single 202

Creating and Consuming Single 203

Combining Responses Using zip,merge,and concat 205

Interoperability with Observable and CompletableFuture 207

When to Use Single？ 208

Summary 209

6．Flow Control and Backpressure 211

Flow Control 211

Taking Periodic Samples and Throttling 212

Buffering Events to a List 214

Moving window 220

Skipping Stale Events by Using debounce（） 221

Backpressure 226

Backpressure in RxJava 227

Built-in Backpressure 231

Producers and Missing Backpressure 233

Honoring the Requested Amount of Data 237

Summary 242

7．Testing and Troubleshooting 243

Error Handling 243

Where Are My Exceptions？ 244

Declarative try-catch Replacement 247

Timing Out When Events Do Not Occur 251

Retrying After Failures 254

Testing and Debugging 258

Virtual Time 258

Schedulers in Unit Testing 260

Unit Testing 262

Monitoring and Debugging 270

doOn...（）Callbacks 270

Measuring and Monitoring 272

Summary 275

8．Case Studies 277

Android Development with RxJava 277

Avoiding Memory Leaks in Activities 278

Retrofit with Native RxJava Support 280

Schedulers in Android 285

UI Events as Streams 288

Managing Failures with Hystrix 291

The First Steps with Hystrix 292

Nonblocking Commands with HystrixObservableCommand 294

Bulkhead Pattern and Fail-Fast 295

Batching and Collapsing Commands 297

Monitoring and Dashboards 303

Querying NoSQL Databases 306

Couchbase Client API 306

MongoDB Client API 307

Camel Integration 309

Consuming Files with Camel 309

Receiving Messages from Kafka 310

Java 8 Streams and CompletableFuture 310

Usefulness of Parallel Streams 312

Choosing the Appropriate Concurrency Abstraction 314

When to Choose Observable？ 315

Memory Consumption and Leaks 315

Operators Consuming Uncontrolled Amounts of Memory 316

Summary 321

9．Future Directions 323

Reactive Streams 323

Observable and Flowable 323

Performance 324

Migration 325

A．More HTTP Server Examples 327

B．A Decision Tree of Observable Operators 333

Index 339