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

Introduction

Who Should Read This Book

Reactive Programming with RxJava targets intermediate and advanced Java programmers. You should be fairly comfortable with Java; however, prior knowledge of reactive programming is not required. Many concepts in this book relate to functional programming, but you do not need to be familiar with it either. There are two distinct groups of programmers that can benefit from this book:

Craftsmen who seek improved performance on the server or more maintainable code on mobile devices. If you fall into this category, you will find ideas and solutions to real problems as well as practical advice. In this case, RxJava is just another tool that this book will help to master.
Curious developers who’ve heard about reactive programming or RxJava in particular and want to get a fair understanding of it. If this is you, and if you are not planning to take advantage of RxJava in production code, you will significantly broaden your horizons.

Additionally, if you are a hands-on software architect, this book will likely help you. RxJava influences the overall architecture of entire systems, so it is worth knowing. But even if you are just beginning your adventure with programming, try to go through the first few chapters, which explain the basics. Underlying concepts like transformations and composition are quite universal and not related to reactive programming.

Note from Ben Christensen

In 2012, I was working on a new architecture for the Netflix ...

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