5 Solid Reasons to Use RxJava in Your Java Projects

Reactive Extensions (Rx) are a set of methods and interfaces used to solve a lot of simple and complex problems of developers. Using it with Java allows you to manage multiple actions occurred due to various system events simultaneously. It helps you write elegant code maintaining simplicity. Today, I will share five solid reasons why you should use RxJava in your projects.

Contents

Why You Should Use RxJava in Your Projects?

1. Functional Approach

Functional programming includes active usage of functions as parameters as well as results in other functions. For example, Map is a higher order function which is used in various programming languages, and if it is applied to all the elements of a list, it would return a list of results. You can understand this by looking at the example given below.

Overall, if you’re familiar with the functional programming and understand map and zip concepts, learning RxJava will be a lot easier for you.

Example:

Observable.from(jsonFile)
.map(new Func1<File, String>() {
@Override public String call(File file) {
try {
return new Gson().toJson(new FileReader(file), Object.class);
} catch (FileNotFoundException e) {
throw OnErrorThrowable.addValueAsLastCause(e, file);
}
}
});

2. Operators with schedulers

There are many operators which require you to define Scheduler in order to use the function. They also have their overloaded methods that use computation(), delay () as a Scheduler. Have a look at the code below.

TestSubscriber<Integer> subscriber = new TestSubscriber<>();
Observable.just(1).delay(1, TimeUnit.SECONDS).subscribe(subscriber);
subscriber.awaitTerminalEvent();
Logger.d("LastSeenThread: " + subscriber.getLastSeenThread().getName());

Even without declaring any scheduler, we can still see the next result.

LastSeenThread: RxComputationThreadPool-1

You should always declare the required Schedulers as the third argument if you don’t want to use the computation scheduler.

.delay(1, TimeUnit.SECONDS, Schedulers.immediate())

Apart from delay(), you have a lot of other operators that can change Scheduler such as interval (), debounce (), timer (), skip (), timeout (), etc.

3. Easy Caching

Caching is one of the best ways to improve the performance of an application. It helps to reduce network calls by caching the network response and retrieves the data very fast if it is already cached. There are two types of caching: Memory Cache which keeps the data in the memory of the application and Disk Cache that saves the data to the disk.

Also Read: 5 Best Open Source IDEs for Java Programming Language

4. Subjects

If you are working with objects, you should also know that the sequence of changes in data sent to onNext subject by default and will be executed in the same thread. It’s even used to call onNext() method, until observeOn() operator doesn’t appear in this sequence.

BehaviorSubject<Object> subject = BehaviorSubject.create();
subject
.doOnNext(obj -> Logger.logThread("doOnNext"))
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.newThread())
.subscribe(new Subscriber<Object>() {
@Override
public void onNext(Object o) {
Logger.logThread("onNext");
}
});
subject.onNext("str");
Handler handler = new Handler();
handler.postDelayed(() -> subject.onNext("str"), 1000);

Both observeOn and subscribeOn are present here, but the result are as follows:

doOnNext: RxCachedThreadScheduler-1
onNext: RxNewThreadScheduler-1
doOnNext: main
onNext: RxNewThreadScheduler-1

It simply means when we subscribe to the subject, it returns the value immediately and then processed in a thread of Shedulers.io(). After that, when the following message appears to subject, we use the thread to call onNext().

5. Asynchronous streams

Suppose, you need to send a request to the database to start getting both messages and settings immediately. Once the entire process is completed, it should display a welcome message on the screen.

If you want to achieve this in Java, you’ll have to follow a long process of running 3-4 different AsyncTasks, creating a semaphore that will wait for both settings and messages requests to complete, etc.

But with RxJava, we can optimize the process where the code is like a thread located in one place and being built on the basis of a functional paradigm.

Conclusion

These were some of the solid reasons to use RxJava in your project. If you are still thinking that it’s tough or you’re not experienced enough, just remember, even if you do something wrong while using RxJava, it’s not going to be the end of the world. Knowledge of RxJava can help you fix many problems easily.