Book Image

Learning RxJava - Second Edition

By : Nick Samoylov, Thomas Nield
Book Image

Learning RxJava - Second Edition

By: Nick Samoylov, Thomas Nield

Overview of this book

RxJava is not just a popular library for building asynchronous and event-based applications; it also enables you to create a cleaner and more readable code base. In this book, you’ll cover the core fundamentals of reactive programming and learn how to design and implement reactive libraries and applications. Learning RxJava will help you understand how reactive programming works and guide you in writing your first example in reactive code. You’ll get to grips with the workings of Observable and Subscriber, and see how they are used in different contexts using real-world use cases. The book will also take you through multicasting and caching to help prevent redundant work with multiple Observers. You’ll then learn how to create your own RxJava operators by reusing reactive logic. As you advance, you’ll explore effective tools and libraries to test and debug RxJava code. Finally, you’ll delve into RxAndroid extensions and use Kotlin features to streamline your Android apps. By the end of this book, you'll become proficient in writing reactive code in Java and Kotlin to build concurrent applications, including Android applications.

Related Content you might be interested in

Current Title:

Small book image
Learning RxJava - Second Edition
Nick Samoylov | Thomas Nield
Feb, 2020 | 412 pages
Small book image
Reactive Programming in Kotlin
Rivu Chakraborty
Dec, 2017 | 322 pages
Small book image
Reactive Android Programming
Tadas Subonis
May, 2017 | 256 pages
Small book image
Reactive Programming With Java 9
Tejaswini Mandar Jog
Sep, 2017 | 402 pages
Table of Contents (22 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
1
Section 1: Foundations of Reactive Programming in Java
Section 1: Foundations of Reactive Programming in Java
Free Chapter
2
Thinking Reactively
Thinking Reactively
A brief history of ReactiveX and RxJava
Thinking reactively
Why should I learn RxJava?
Setting up
A brief exposure to RxJava
RxJava 1.x, 2.x, or 3.0 – which one do I use?
When to use RxJava
Summary
3
Observable and Observer
Observable and Observer
The Observable
The Observer interface
Cold versus hot observables
Other Observable sources
Single, Completable, and Maybe
Disposing
Summary
4
Basic Operators
Basic Operators
Conditional operators
Suppressing operators
Transforming operators
Reducing operators
Collection operators
Error recovery operators
Action operators
Utility operators
Summary
5
Section 2: Reactive Operators
Section 2: Reactive Operators
6
Combining Observables
Combining Observables
Merging factories and operators
Concatenating factories and operators
Ambiguous operators
Zipping operators
Combining the latest operators
Grouping operators
Summary
7
Multicasting, Replaying, and Caching
Multicasting, Replaying, and Caching
Understanding multicasting
Automatic connection
Replaying and caching
Subjects
Summary
8
Concurrency and Parallelization
Concurrency and Parallelization
Why concurrency is necessary
Concurrency in a nutshell
Introducing RxJava concurrency
Understanding schedulers
Understanding subscribeOn()
Understanding observeOn()
Parallelization
Understanding unsubscribeOn()
Summary
9
Switching, Throttling, Windowing, and Buffering
Switching, Throttling, Windowing, and Buffering
Buffering
Windowing
Throttling
Switching
Grouping keystrokes
Summary
10
Flowable and Backpressure
Flowable and Backpressure
Understanding backpressure
Understanding Flowable and Subscriber
Creating Flowable
Using onBackpressureXXX() operators
Using Flowable.generate()
Summary
11
Transformers and Custom Operators
Transformers and Custom Operators
Composing new operators from existing ones using compose() and transformers
Using the to() operator for fluent conversion
Creating new operators from scratch using lift()
Creating a new operator for Single, Maybe, or Completable
Using RxJava2-Extras and RxJava2Extensions
Summary
12
Section 3: Integration of RxJava applications
Section 3: Integration of RxJava applications
13
Testing and Debugging
Testing and Debugging
Configuring JUnit
Blocking subscribers
Blocking operators
Using TestObserver and TestSubscriber
Manipulating time with TestScheduler
Debugging RxJava code
Summary
14
RxJava on Android
RxJava on Android
Creating an Android project
Using RxJava and RxAndroid
Summary
15
Using RxJava for Kotlin
Using RxJava for Kotlin
Why Kotlin?
Configuring Kotlin
Kotlin basics
Extension operators
Using RxKotlin
Dealing with SAM ambiguity
Using let() and apply()
Tuple and data classes
The future of ReactiveX and Kotlin
Summary
16
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think
Appendix A: Introducing Lambda Expressions
Appendix A: Introducing Lambda Expressions
Introducing lambda expressions
Appendix B: Functional Types
Appendix B: Functional Types
Functional types
Appendix C: Mixing Object-Oriented and Reactive Programming
Appendix C: Mixing Object-Oriented and Reactive Programming
Mixing object-oriented and reactive programming
Appendix D: Materializing and Dematerializing
Appendix D: Materializing and Dematerializing
Materializing and dematerializing
Appendix E: Understanding Schedulers
Appendix E: Understanding Schedulers
Understanding Schedulers

Dealing with SAM ambiguity

In Java, an interface with a single abstract method is called a functional interface. This means a functional interface in Java is SAM in Kotlin.

At the time of writing, when Kotlin invokes Java libraries with functional parameters, a problem may rear its head in RxJava 2.x when several overloads of the method with functional parameters are introduced. Kotlin does not have this issue when invoking Kotlin libraries, but it does with Java libraries. When there are multiple argument overloads for different functional SAM types on a given Java method, Kotlin gets lost in its inference and needs help. Until JetBrains resolves this issue, you will need to work around this either by being explicit or by using RxKotlin's helpers.

One of the most notorious examples is the zip() operator. Try to run the code as shown in the following example and you will...

Previous Section
End of Section 7
Next Section