book

Reactive Programming with RxJava

by Tomasz Nurkiewicz, Ben Christensen

October 2016

Intermediate to advanced

372 pages

9h 55m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Who Should Read This BookNote from Ben ChristensenNote from Tomasz NurkiewiczNavigating This BookOnline ResourcesConventions Used in This BookSafari® Books OnlineHow to Contact UsAcknowledgmentsFrom BenFrom Tomasz
Reactive Programming and RxJavaWhen You Need Reactive ProgrammingHow RxJava WorksPush versus PullAsync versus SyncConcurrency and ParallelismLazy versus EagerDualityCardinalityMechanical Sympathy: Blocking versus Nonblocking I/OReactive Abstraction
Anatomy of rx.ObservableSubscribing to Notifications from ObservableCapturing All Notifications by Using Observer<T>Controlling Listeners by Using Subscription and Subscriber<T>Creating ObservablesMastering Observable.create()Infinite StreamsTiming: timer() and interval()Hot and Cold ObservablesUse Case: From Callback API to Observable StreamManually Managing Subscribersrx.subjects.SubjectConnectableObservableSingle Subscription with publish().refCount()ConnectableObservable LifecycleSummary
Core Operators: Mapping and Filtering1-to-1 Transformations Using map()Wrapping Up Using flatMap()Postponing Events Using the delay() OperatorOrder of Events After flatMap()Preserving Order Using concatMap()More Than One ObservableTreating Several Observables as One Using merge()Pairwise Composing Using zip() and zipWith()When Streams Are Not Synchronized with One Another: combineLatest(), withLatestFrom(), and amb()Advanced Operators: collect(), reduce(), scan(), distinct(), and groupBy()Scanning Through the Sequence with Scan and ReduceReduction 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 OthersWays of Combining Streams: concat(), merge(), and switchOnNext()Criteria-Based Splitting of Stream Using groupBy()Where to Go from Here?Writing Customer OperatorsReusing Operators Using compose()Implementing Advanced Operators Using lift()Summary
From Collections to ObservablesBlockingObservable: Exiting the Reactive WorldEmbracing LazinessComposing ObservablesLazy paging and concatenationImperative ConcurrencyflatMap() as Asynchronous Chaining OperatorReplacing Callbacks with StreamsPolling Periodically for ChangesMultithreading in RxJavaWhat Is a Scheduler?Declarative Subscription with subscribeOn()subscribeOn() Concurrency and BehaviorBatching Requests Using groupBy()Declarative Concurrency with observeOn()Other Uses for SchedulersSummary
Beating the C10k ProblemTraditional Thread-Based HTTP ServersNonblocking HTTP Server with Netty and RxNettyBenchmarking Blocking versus Reactive ServerReactive HTTP Servers TourHTTP Client CodeNonblocking HTTP Client with RxNettyRelational Database AccessNOTIFY AND LISTEN on PostgreSQL Case StudyCompletableFuture and StreamsA Short Introduction to CompletableFutureInteroperability with CompletableFutureObservable versus SingleCreating and Consuming SingleCombining Responses Using zip, merge, and concatInteroperability with Observable and CompletableFutureWhen to Use Single?Summary
Flow ControlTaking Periodic Samples and ThrottlingBuffering Events to a ListMoving windowSkipping Stale Events by Using debounce()BackpressureBackpressure in RxJavaBuilt-in BackpressureProducers and Missing BackpressureHonoring the Requested Amount of DataSummary
Error HandlingWhere Are My Exceptions?Declarative try-catch ReplacementTiming Out When Events Do Not OccurRetrying After FailuresTesting and DebuggingVirtual TimeSchedulers in Unit TestingUnit TestingMonitoring and DebuggingdoOn…() CallbacksMeasuring and MonitoringSummary
Android Development with RxJavaAvoiding Memory Leaks in ActivitiesRetrofit with Native RxJava SupportSchedulers in AndroidUI Events as StreamsManaging Failures with HystrixThe First Steps with HystrixNonblocking Commands with HystrixObservableCommandBulkhead Pattern and Fail-FastBatching and Collapsing CommandsMonitoring and DashboardsQuerying NoSQL DatabasesCouchbase Client APIMongoDB Client APICamel IntegrationConsuming Files with CamelReceiving Messages from KafkaJava 8 Streams and CompletableFutureUsefulness of Parallel StreamsChoosing the Appropriate Concurrency AbstractionWhen to Choose Observable?Memory Consumption and LeaksOperators Consuming Uncontrolled Amounts of MemorySummary

Reactive StreamsObservable and FlowablePerformanceMigration
fork() Procedure in C LanguageThread per ConnectionThread Pool of Connections

Overview

In today’s app-driven era, when programs are asynchronous and responsiveness is so vital, reactive programming can help you write code that’s more reliable, easier to scale, and better-performing. With this practical book, Java developers will first learn how to view problems in the reactive way, and then build programs that leverage the best features of this exciting new programming paradigm.

Authors Tomasz Nurkiewicz and Ben Christensen include concrete examples that use the RxJava library to solve real-world performance issues on Android devices as well as the server. You’ll learn how RxJava leverages parallelism and concurrency to help you solve today’s problems. This book also provides a preview of the upcoming 2.0 release.

Write programs that react to multiple asynchronous sources of input without descending into "callback hell"
Get to that aha! moment when you understand how to solve problems in the reactive way
Cope with Observables that produce data too quickly to be consumed
Explore strategies to debug and to test programs written in the reactive style
Efficiently exploit parallelism and concurrency in your programs
Learn about the transition to RxJava version 2