RxJava is a JVM implementation of Reactive Extensions and a reactive programming implementation based on event driven and asynchronous programs. It works on the principles of observables and observer patterns. RxJava is lightweight and implemented as a single JAR on the observable abstraction and related higher-order functions.
(For those who are new to Reactive Programming and have less familiarity with it. Reactive programming is an event driven programming where data streams comes in asynchronous manner and get processed as they arrive. ReactiveX is a project which aims to provide reactive programming concept to various programming languages.
Reactive Programming refers to the scenario where program reacts as and when data appears. It is a event based programming concept and events can propagate to observers. As per Reactive, they have combined the best of Observer pattern, Iterator pattern and functional pattern. ReactiveX is a combination of the best ideas from the Observer pattern, the Iterator pattern, and functional programming.)
The main components of RxJava are the observables, operators and observers
Is the source of data. An object similar to stream which can emit zero or more data, can send error message, speed can be controlled while emitting a set of data and can send finite as well as infinite data.
The operators are used for transforming the data stream.
Is the consumer of data. It subscribes to Observable’s data and reacts per item of the observables. Observers are notified whenever Observable emits data. An Observer handles data one by one.
To include RxJava into the project runtime, maven config, gradle config or jar file into classpath can be chosen.
Observables Base Classes
RxJava features several base classes.
- Flowable: 0..N flows, supporting Reactive-Streams and backpressure
- Observable: 0..N flows, no backpressure
- Single: a flow of exactly 1 item or an error
- Completable: a flow without items but only a completion or error signal
- core.Maybe: a flow with no items, exactly one item or an error.
RxJava operators are categorised as below.
The first line is the Observable i.e stream of data. Next is the operator ‘map’ which transforms the observable data. At the end the observer subscribing to the observable and printing the transformed data from the stream.
The following are some uses of RxJava.
- It is a simpler way to handle asynchronous work
- Availability of multitude of operators to make work less complicated
- Clean Code
- Simple to create streams of data
- Ease in implementing back-pressure