Book Image

Learning RxJava

By : Thomas Nield
Book Image

Learning RxJava

By: Thomas Nield

Overview of this book

RxJava is a library for composing asynchronous and event-based programs using Observable sequences for the JVM, allowing developers to build robust applications in less time. Learning RxJava addresses all the fundamentals of reactive programming to help readers write reactive code, as well as teach them an effective approach to designing and implementing reactive libraries and applications. Starting with a brief introduction to reactive programming concepts, there is an overview of Observables and Observers, the core components of RxJava, and how to combine different streams of data and events together. You will also learn simpler ways to achieve concurrency and remain highly performant, with no need for synchronization. Later on, we will leverage backpressure and other strategies to cope with rapidly-producing sources to prevent bottlenecks in your application. After covering custom operators, testing, and debugging, the book dives into hands-on examples using RxJava on Android as well as Kotlin.

Related Content you might be interested in

Current Title:

Small book image
Learning RxJava
Thomas Nield
Jun, 2017 | 400 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 (21 chapters)
Title Page
Title Page
Credits
Credits
About the Author
About the Author
Acknowledgements
Acknowledgements
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Customer Feedback
Customer Feedback
Preface
Preface
Free Chapter
1
Thinking Reactively
Thinking Reactively
A brief history of ReactiveX and RxJava
Thinking reactively
Why should I learn RxJava?
Setting up
A quick exposure to RxJava
RxJava 1.0 versus RxJava 2.0 - which one do I use?
When to use RxJava
Summary
2
Observables and Subscribers
Observables and Subscribers
The Observable
The Observer interface
Cold versus hot Observables
Other Observable sources
Single, Completable, and Maybe
Disposing
Summary
3
Basic Operators
Basic Operators
Suppressing operators
Transforming operators
Reducing operators
Collection operators
Error recovery operators
Action operators
Summary
4
Combining Observables
Combining Observables
Merging
Concatenation
Ambiguous
Zipping
Combine latest
Grouping
Summary
5
Multicasting, Replaying, and Caching
Multicasting, Replaying, and Caching
Understanding multicasting
Automatic connection
Replaying and caching
Subjects
Summary
6
Concurrency and Parallelization
Concurrency and Parallelization
Why concurrency is necessary
Concurrency in a nutshell
Introducing RxJava concurrency
Understanding Schedulers
Understanding subscribeOn()
Understanding observeOn()
Parallelization
unsubscribeOn()
Summary
7
Switching, Throttling, Windowing, and Buffering
Switching, Throttling, Windowing, and Buffering
Buffering
Windowing
Throttling
Switching
Grouping keystrokes
Summary
8
Flowables and Backpressure
Flowables and Backpressure
Understanding backpressure
Understanding the Flowable and Subscriber
Creating a Flowable
Using onBackpressureXXX() operators
Using Flowable.generate()
Summary
9
Transformers and Custom Operators
Transformers and Custom Operators
Transformers
Using to() for fluent conversion
Operators
Custom Transformers and operators for Singles, Maybes, and Completables
Using RxJava2-Extras and RxJava2Extensions
Summary
10
Testing and Debugging
Testing and Debugging
Configuring JUnit
Blocking subscribers
Blocking operators
Using TestObserver and TestSubscriber
Manipulating time with the TestScheduler
Debugging RxJava code
Summary
11
RxJava on Android
RxJava on Android
Creating the Android project
Using RxJava and RxAndroid
Other RxAndroid bindings libraries
Life cycles and cautions using RxJava with Android
Summary
12
Using RxJava for Kotlin New
Using RxJava for Kotlin New
Why Kotlin?
Configuring Kotlin
Kotlin basics
Extension operators
Using RxKotlin
Dealing with SAM ambiguity
Using let() and apply()
Tuples and data classes
Future of ReactiveX and Kotlin
Summary
13
Appendix
Appendix
Introducing lambda expressions
Functional types
Mixing object-oriented and reactive programming
Materializing and Dematerializing
Understanding Schedulers

RxJava 1.0 versus RxJava 2.0 - which one do I use?

As stated earlier, you are encouraged to use RxJava 2.0 if you can. It will continue to grow and receive new features, while RxJava 1.0 will be maintained for bug fixes. However, there are other considerations that may lead you to use RxJava 1.0.

If you inherit a project that is already using RxJava 1.0, you will likely continue using that until it becomes feasible to refactor to 2.0. You can also check out David Akarnokd's RxJava2Interop project (https://github.com/akarnokd/RxJava2Interop), which converts Rx types from RxJava 1.0 to RxJava 2.0 and vice versa. After you finish this book, you may consider using this library to leverage RxJava 2.0 even if you have the RxJava 1.0 legacy code.

In RxJava, there are several libraries to make several Java APIs reactive and plug into RxJava seamlessly. Just to name a few, these libraries include RxJava-JDBC, RxAndroid, RxJava-Extras, RxNetty, and RxJavaFX. At the time of writing this, only RxAndroid and RxJavaFX have been fully ported to RxJava 2.0 (although many other libraries are following). By the time you are reading this, all major RxJava extension libraries will hopefully be ported to RxJava 2.0.

You will also want to prefer RxJava 2.0 because it was built on much of the hindsight and wisdom gained from RxJava 1.0. It has better performance, simpler APIs, a cleaner approach to backpressure, and a bit more safety when hacking together your own operators.

Previous Section
End of Section 7
Next Section