Reactive Programming on Android with RxJava

Leaving the Reactive world
To address the first issue from our change, we can make use of any of the
.blockingX()
operators
available to an
Observable
. Essentially, a
.blockingX()
operator will block the calling thread until
an item is emitted downstream. A few notable blocking operators that are available are:
•
.blockingFirst()
: blocks the calling thread and returns the first element emitted by the
Observable
.
•
.blockingNext()
: returns an
Iterable
which allows you to iterate through all the emissions
by the
Observable
. Each iteration will block until the
Observable
emits a next item.
•
.blockingLast()
: blocks the calling thread and returns the last element emitted by the
Observable
.
•
.blockingSingle()
: blocks the calling thread until the
Observable
emits an element followed
by an
.onComplete()
event, otherwise, an
Exception
is thrown.
•
.blockingSubscribe()
: blocks until a terminal event is received (all elements that are received
through
.onNext()
are ignored).
Using a blocking operator to change the method signature back to a
List
, our snippet would
now look like:
1
/**
2
* @return a list of users with blogs
3
*/
4
public
List
<
User
>
getUsersWithBlogs
() {
5
return
Observable
.
fromIterable
(
UserCache
.
getAllUsers
())
6
.
filter
(
user
->
user
.
blog
!=
null
&& !
user
.
blog
.
isEmpty
())
7
.
sorted
((
user1
,
user2
) ->
user1
.
name
.
compareTo
(
user2
.
name
))
8
.
toList
()
9
.
blockingFirst
();
10
}
Before calling a blocking operator (i.e. in this case,
.blockingFirst()
) we first need to chain
the aggregate operator
.toList()
so that the stream is modified from an
Observable
to a
Single>
. Afterwards, we can then call the blocking operator
.blockingFirst()
which
unwraps the
Single
and returns a
List
.
A
Single
is a special type of
Observable
that emits a single item. As opposed to the
Observable
which can emit any of the 3 events:
.onNext()
,
onCompleted()
, and
.onError()
,
Single
only
has an
.onSuccess()
and an
.onError()
. Using
Single
is preferred when we know that only a
single item will be emitted as it offers the caller a clearer intent as to what data will be emitted in

---

Chapter 5: Reactive Modeling on Android
61
the stream (i.e. a single item). We will revisit
Single
s again later in this chapter (See
Chapter 5:
Completable, Single and Maybe
).
Although RxJava supports blocking operations, as much as possible this should be avoided. This is
because that instead of being data being pushed as it is ready (the reactive way), we are instead
pulling data and blocking the calling thread. In addition, using a blocking operation will cause any
exceptions to be thrown on the calling thread; so if the operation were to be invoked on the main
thread, the application would crash. When absolutely necessary though, blocking operators are a
nice way of stepping out of the reactive world.