RXJAVA反应式编程 影印版PDF|Epub|txt|kindle电子书版本网盘下载

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

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

1．Reactive Programming with RxJava1

Reactive Programming and RxJava1

When You Need Reactive Programming3

How RxJava Works4

Push versus Pull4

Async versus Sync5

Concurrency and Parallelism8

Lazy versus Eager12

Duality13

Cardinality15

Mechanical Sympathy：Blocking versus Nonblocking I/O20

Reactive Abstraction25

2．Reactive Extensions27

Anatomy of rx.Observable27

Subscribing to Notifications from Observable30

Capturing All Notifications by Using Observer＜T＞32

Controlling Listeners by Using Subscription and Subscriber＜T＞32

Creating Observables34

Mastering Observable.create（）35

Infinite Streams38

Timing：timer（）and interval（）43

Hot and Cold Observables43

Use Case：From Callback API to Observable Stream45

Manually Managing Subscribers49

rx.subjects.Subject51

ConnectableObservable53

Single Subscription with publish（）.refCount（）54

ConnectableObservable Lifecycle56

Summary59

3．Operators and Transformations61

Core Operators：Mapping and Filtering61

1-to-1 Transformations Using map（）64

Wrapping Up Using flatMap（）67

Postponing Events Using the delay（）Operator72

Order of Events After flatMap（）73

Preserving Order Using concatMap（）75

More Than One Observable77

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 Reduce88

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 Others94

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 Operators107

Reusing Operators Using compose（）108

Implementing Advanced Operators Using lift（）110

Summary115

4．Applying Reactive Programming to Existing Applications117

From Collections to Observables118

BlockingObservable：Exiting the Reactive World118

Embracing Laziness121

Composing Observables123

Lazy paging and concatenation124

Imperative Concurrency125

flatMap（）as Asynchronous Chaining Operator131

Replacing Callbacks with Streams136

Polling Periodically for Changes138

Multithreading in RxJava140

What Is a Scheduler？141

Declarative Subscription with subscribeOn（）150

subscribeOn（）Concurrency and Behavior154

Batching Requests Using groupBy（）158

Declarative Concurrency with observeOn（）159

Other Uses for Schedulers163

Summary164

5．Reactive from Top to Bottom165

Beating the C10k Problem165

Traditional Thread-Based HTTP Servers167

Nonblocking HTTP Server with Netty and RxNetty169

Benchmarking Blocking versus Reactive Server177

Reactive HTTP Servers Tour183

HTTP Client Code184

Nonblocking HTTP Client with RxNetty184

Relational Database Access187

NOTIFY AND LISTEN on PostgreSQL Case Study189

CompletableFuture and Streams193

A Short Introduction to CompletableFuture193

Interoperability with CompletableFuture198

Observable versus Single202

Creating and Consuming Single203

Combining Responses Using zip,merge,and concat205

Interoperability with Observable and CompletableFuture207

When to Use Single？208

Summary209

6．Flow Control and Backpressure211

Flow Control211

Taking Periodic Samples and Throttling212

Buffering Events to a List214

Moving window220

Skipping Stale Events by Using debounce（）221

Backpressure226

Backpressure in RxJava227

Built-in Backpressure231

Producers and Missing Backpressure233

Honoring the Requested Amount of Data237

Summary242

7．Testing and Troubleshooting243

Error Handling243

Where Are My Exceptions？244

Declarative try-catch Replacement247

Timing Out When Events Do Not Occur251

Retrying After Failures254

Testing and Debugging258

Virtual Time258

Schedulers in Unit Testing260

Unit Testing262

Monitoring and Debugging270

doOn...（）Callbacks270

Measuring and Monitoring272

Summary275

8．Case Studies277

Android Development with RxJava277

Avoiding Memory Leaks in Activities278

Retrofit with Native RxJava Support280

Schedulers in Android285

UI Events as Streams288

Managing Failures with Hystrix291

The First Steps with Hystrix292

Nonblocking Commands with HystrixObservableCommand294

Bulkhead Pattern and Fail-Fast295

Batching and Collapsing Commands297

Monitoring and Dashboards303

Querying NoSQL Databases306

Couchbase Client API306

MongoDB Client API307

Camel Integration309

Consuming Files with Camel309

Receiving Messages from Kafka310

Java 8 Streams and CompletableFuture310

Usefulness of Parallel Streams312

Choosing the Appropriate Concurrency Abstraction314

When to Choose Observable？315

Memory Consumption and Leaks315

Operators Consuming Uncontrolled Amounts of Memory316

Summary321

9．Future Directions323

Reactive Streams323

Observable and Flowable323

Performance324

Migration325

A．More HTTP Server Examples327

B．A Decision Tree of Observable Operators333

Index339