醉染图书RxJava反应式编程9787564173708

Foreword
Introduction
1.Reactive Programming with RxJava
Reactive Programming and RxJava
When You Need Reactive Programming
How RxJava Works
Push versus Pull
Async versus Sync
Concurrency and Parallelism
Lazy versus Eager
Duality
Cardinality
Mechanical Sympathy： Blocking versus Nonblocking I/O
Reactive Abstraction
2.Reactive Extensions
Anatomy of rx.Observable
Subscribing to Notifications from Observable
Capturing All Notifications by Using Observer
Controlling Listeners by Using Subscription and Subscriber
Creating Observables
Mastering Observable.create()
Infinite Streams
Timing： timer() and interval()
Hot and Cold Observables
Use Case： From Callback API to Observable Stream
Manually Managing Subscribers
rx.subjects.Subject
ConnectableObservable
Single Subscription with publishrefCount()
ConnectableObservable Lifecycle
Summary
3.Operators and Transformations
Core Operators： Mapping and Filtering
1-t- Transformations Using map()
Wrapping Up Using flatMap0
Postponing Events Using the delay() Operator
Order of Events After flatMap0
Preserving Order Using concatMap0
More Than One Observable
Treating Several Observables as One Using merge()
Pairwise Coing Using zip() and zipWith()
When Streams Are Not Synchronized with One Another： combineLatest()，
with Latest From()， and amb()
Advanced Operators： collect()， reduce()， scan()， distinct()， and groupBy()
Scanning Throu&nsp;the Sequence with Scan and Reduce
Reduction with Mutable Accumulator： collect()
Asserting Observable Has Exactly One Item Using single()
Dropping Duplicates Using distinct() and distinctUntilChanged()
Slicing and Dicing Using skip()， takeWhile()， and Others
Ways of Combining Streams： concat()， merge()， and switchOnNext()
Criteria-Based Splitting of Stream Using groupBy()
Where to Go from Here?
Writing Customer Operators
Reusing Operators Using coe()
Implementing Advanced Operators Using lift()
Summary
4.Applying Reactive Programming to Existing Applications
From Collections to Observables
BlockingObservable： Exiting the Reactive World
Embracing Laziness
Coing Observables
Lazy paging and concatenation
Imperative Concurrency
flatMap0 as Asynchronous Chaining Operator
Replacing Callbacks with Streams
Polling Periodically for Changes
Multithreading in RxJava
What Is a Scheduler?
Declarative Subscription with subscribeOn()
subscribeOn0 Concurrency and Behavior
Batching Requests Using groupBy()
Declarative Concurrency with observeOn()
Other Uses for Schedulers
Summary
5.Reactive from Top to Bottom
Beating the C1Ok Problem
Traditional Thread-Based HTTP Servers
Nonblocking HTTP Server with Netty and RxNetty
Benchmarking Blocking versus Reactive Server
Reactive HTTP Servers Tour
HTTP Client Code
Nonblocking HTTP Client with RxNetty
Relational Database Access
NOTIFY AND LISTEN on PostgreSL Case Study
CompletableFuture and Streams
A Short Introduction to CompletableFuture
Interoperability with CompletableFuture
Observable versus Single
Creating and Consuming Single
Combining Responses Using zip， merge， and concat
Interoperability with Observable and CompletableFuture
When to Use Single?
Summary
6.Flow Control and cprssure
Flow Control
Taking Periodic Samples and Throttling
Buffering Events to a List
Moving window
Skipping Stale Events by Using debounce()
cprssure
cprssure in RxJava
Built-in cprssure
Producers and Missing cprssure
Honoring the Requested Amount of Data
Summary
7.Testing and Troubleshooting
Error Handling
Where Are My Exceptions?
Declarative try-catch Replacement
Timing Out When Events Do Not Occur
Retrying After Failures
Testing and Debugging
Virtual Time
Schedulers in Unit Testing
Unit Testing
Monitoring and Debugging
don..() Callbacks
Measuring and Monitoring
Summary
8.Case Studies
Android Develomn&bsp;with RxJava
Avoiding Memory Leaks in Activities
Retrofit with Native RxJava Support
Schedulers in Android
UI Events as Streams
Managing Failures with Hystrix
The First Steps with Hystrix
Nonblocking Commands with HystrixObservableCommand
Bulkhead Pattern and Fail-Fast
Batching and Collapsing Commands
Monitoring and Dashboards
erying NoSL Databases
Couchbase Client API
MongoDB Client API
Camel Integration
Consuming Files with Camel
Receiving Messages from Kafka
Java 8 Streams and CompletableFuture
Usefulness of Parallel Streams
Choosing the Appropriate Concurrency Abstraction
When to Choose Observable?
Memory Consumption and Leaks
Operators Consuming Uncontrolled Amounts of Memory
Summary
9.Future Directions
Reactive Streams
Observable and Flowable
Performance
Migration
A.More HTTP Server Examples
B.A Decision Tree of Observable Operators
Index

Tomas Nrkewicz是Allegro的一名软件。过去十年他一直在用Java编程，他喜欢后端开发，对JVM语言和开源技术富有热情。Tomasz经常在DZone写博客，在优选靠前的Java大会发表演讲。
Ben Christensen是一名软件，他曾在Apple、Netflix和Facebook工作过。Ben从上个世纪90年代就开始用Java编程，贡献了包括Hystrix和RxJava在内的多个开源项目。在NetflixAPI团队工作的时候，Ben成了反应式及函数式编程的粉丝。