Book Overview & Buying
Table Of Contents

Learning RxJava - Second Edition

By : Nick Samoylov, Nield

4.8 (4)

Buy this Book

Learning RxJava

4.8 (4)

By: Nick Samoylov, Nield

Buy this Book

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.

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Section 1: Foundations of Reactive Programming in Java

Free Chapter

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

Observable and Observer

The Observable

The Observer interface

Cold versus hot observables

Other Observable sources

Single, Completable, and Maybe

Disposing

Summary

Basic Operators

Conditional operators

Suppressing operators

Transforming operators

Reducing operators

Collection operators

Error recovery operators

Action operators

Utility operators

Summary

Section 2: Reactive Operators

Combining Observables

Merging factories and operators

Concatenating factories and operators

Ambiguous operators

Zipping operators

Combining the latest operators

Grouping operators

Summary

Multicasting, Replaying, and Caching

Understanding multicasting

Automatic connection

Replaying and caching

Subjects

Summary

Concurrency and Parallelization

Why concurrency is necessary

Concurrency in a nutshell

Introducing RxJava concurrency

Understanding schedulers

Understanding subscribeOn()

Understanding observeOn()

Parallelization

Understanding unsubscribeOn()

Summary

Switching, Throttling, Windowing, and Buffering

Buffering

Windowing

Throttling

Switching

Grouping keystrokes

Summary

Flowable and Backpressure

Understanding backpressure

Understanding Flowable and Subscriber

Creating Flowable

Using onBackpressureXXX() operators

Using Flowable.generate()

Summary

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

Section 3: Integration of RxJava applications

Testing and Debugging

Configuring JUnit

Blocking subscribers

Blocking operators

Using TestObserver and TestSubscriber

Manipulating time with TestScheduler

Debugging RxJava code

Summary

RxJava on Android

Creating an Android project

Using RxJava and RxAndroid

Summary

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

Other Books You May Enjoy

Leave a review - let other readers know what you think

Appendix A: Introducing Lambda Expressions

Introducing lambda expressions

Appendix B: Functional Types

Functional types

Appendix C: Mixing Object-Oriented and Reactive Programming

Mixing object-oriented and reactive programming

Appendix D: Materializing and Dematerializing

Materializing and dematerializing

Appendix E: Understanding Schedulers

Understanding Schedulers

Combining Observables

We have covered many operators that suppress, transform, reduce, and collect emissions. These operators can do a lot of work, but what about combining multiple observables and consolidating them into one? If we want to accomplish more with ReactiveX, we need to take multiple streams of data and events and make them work together, and there are operators and factories to achieve this. These combining operators and factories also work safely with observables occurring on different threads (discussed in Chapter 6, Concurrency and Parallelization).

In this chapter, we start the transition from making RxJava useful to making it powerful. We will cover the following types of operators that allow observables to be combined: