Book Overview & Buying
Table Of Contents

Learning RxJava - Second Edition

By : Nick Samoylov, Thomas Nield

4.8 (4)

Buy this Book

Learning RxJava

4.8 (4)

By: Nick Samoylov, Thomas 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

Get in touch

Feedback from our readers is always welcome.

General feedback: If you have questions about any aspect of this book, mention the book title in the subject of your message and email us at [email protected].

Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit www.packt.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details.

Piracy: If you come across any illegal copies of our works in any form on the internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected] with a link to the material.

If you are interested in becoming an author: If there is a topic that you have expertise in, and you are interested in either writing or contributing to a book, please visit authors.packtpub.com.

Reviews

Please leave a review. Once you have read and used this book, why not leave a review on the site that you purchased it from? Potential readers can then see and use your unbiased opinion to make purchase decisions, we at Packt can understand what you think about our products, and our authors can see your feedback on their book. Thank you!

For more information about Packt, please visit packt.com.

Tech Concepts

Programming languages

Tech Tools