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

Foreword
Introduction
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
1. Reactive Programming with RxJava
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
2. Reactive Extensions
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
3. Operators and Transformations
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
4. Applying Reactive Programming to Existing Applications
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
5. Reactive from Top to Bottom
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
6. Flow Control and Backpressure
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
7. Testing and Troubleshooting
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
8. Case Studies
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

9. Future Directions
Reactive StreamsObservable and FlowablePerformanceMigration
A. More HTTP Server Examples
fork() Procedure in C LanguageThread per ConnectionThread Pool of Connections
B. A Decision Tree of Observable Operators
Index

Content preview from Reactive Programming with RxJava

Chapter 9. Future Directions

Ben Christensen

Because we took a long time in the 0.x phase before locking down the APIs in RxJava 1.0, it is a fairly mature and stable release. Also, as a result of our decision to support Experimental and Beta markers on APIs, ongoing experimentation can continue before promoting an API to Final. However, the 0.x/1.x phase still ended up with a few decisions that warrant a breaking release; hence, a version 2.0 is being worked on.

Fundamentally, it will be very similar to 1.x, so it won’t require much change in your thinking nor will it be a significant change for usage. Even as 2.0 is released, this book will still apply in most regards. So why a version 2?

Reactive Streams

The first reason is to natively support the Reactive Streams API. Despite the RxJava team being involved in the collaboration that led to Reactive Streams, RxJava v1 APIs were already locked in and couldn’t change to adopt the interfaces in Reactive Streams. Thus, RxJava v1 requires an adaptor, even though it semantically behaves mostly like Reactive Streams. Version 2 will directly implement the Reactive Streams types and comply with the spec so as to better support interoperability across the Java community.

Observable and Flowable

Another reason is to split the Observable type into two types: Observable and Flowable. It was a mistake to make everything require backpressure because not all use cases warrant it. It has a slight performance overhead, but the primary reason ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Reactive Programming in Java Using RxJava 3.x: ReactiveX

Publisher Resources

ISBN: 9781491931646Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design