It provides working details about how to get started with Reactive Programming using RxJava.

1. ReactiveJava =
Reactive Programming
using RxJava

2. Hello!
I AM Hiten Pratap Singh
I am here because I love to dig in to experience new things.
You can find me at:
◦ hiten@nexthoughts.com
◦ http://github.com/hitenpratap/
◦ http://hprog99.wordpress.com/

3. I have divided this presentation into two parts
Reactive
Programming
RxJava

4. Reactive Programming
What’s Reactive Programming? What’s the big deal about it?

6. “
In computing, reactive programming is a
programming paradigm oriented around data
flows and the propagation of change.

7. Reactive Programming
Reactive programming is programming
with asynchronous data streams.
◦ Event buses or your typical click events are really
an asynchronous event stream
◦ Streams are cheap and ubiquitous, anything can be
a stream: variables, user inputs, properties etc.
◦ For example, imagine your Twitter feed would be
a data stream in the same fashion that click events
are.

8. Reactive Programming
On top of that, you are given an amazing
toolbox of functions to combine, create and
filter any of those streams.
◦ A stream can be used as an input to another one.
◦ You can merge two streams.
◦ You can filter a stream to get another one that has
only those events you are interested in.
◦ You can map data values from one stream to
another new one.

9. A stream is a sequence of ongoing events ordered in time. It can emit three
different things: a value (of some type), an error, or a "completed" signal.
Consider that the "completed" takes place, for instance, when the current window
or view containing that button is closed.
We capture these emitted events only asynchronously, by defining a function that
will execute when a value is emitted, another function when an error is emitted,
and another function when 'completed' is emitted.
The "listening" to the stream is called subscribing. The functions we are defining
are observers. The stream is the subject (or "observable") being observed. This is
precisely the Observer Design Pattern.

10. Reactive Programming
Why should I consider adopting RP?
◦ RP raises the level of abstraction of your code.
◦ Code in RP will likely be more concise.
◦ Apps nowadays have an abundancy of real-time
events of every kind that enable a highly
interactive experience to the user.
◦ We need tools for properly dealing with that, and
Reactive Programming is an answer.

11. Reactive Programming
Key Takeaways
◦ RP is a specification for dealing with
asynchronous streams of data.
◦ Reactive provides tools for transforming and
combining streams and for managing flow-control
◦ Resembles Java Streams API but the resemblance
is purely superficial

12. Thinking in RP with
Example

13. What’s ReactiveX?

14. ◦ A library for composing async and event based
program by using observable sequences.
◦ Created by Microsoft initially for .Net platform by
Erik Meijer
◦ Extends observer pattern-
* Supports sequence of data and/or events
* Add operators that allow you to compose sequences
together declaratively
▫ Abstracts away concerns around
* Threading and Thread Safety
* Concurrent data structures and non blocking I/O
▫ RxJava is a port of Reactive Extensions created by
Netflix.
What’s ReactiveX?

15. RxJava
A libraryto use mightypowers of Reactive Programmingin Java!

16. Maven
Getting Started
Gradle
You can also include its jar file without having to use
any of build system as well.

17. Reactive Components/Building Blocks
ObserverObservable Subject

18. Observable

19. Observable
In ReactiveX an observer subscribes to an Observable. Then that
observer reacts to whatever item or sequence of items the
Observable emits.This patternfacilitatesconcurrent operations
because it does not need to block while waiting for the
Observable to emit objects,but insteadit creates a sentryin the
form of an observer that stands ready to react appropriatelyat
whatever future time the Observable does so.
◦ Emits zero or more values
◦ Life Cycles
* Notifies Observer using onNext(T)
* Completes with either onError() or onCompleted()

21. Operators

22. Operators By Categories
Creating
Observables
Transforming
Observables
Filtering
Observables
Combining
Observables
Error
handling
Operators
Observable
Utility
Operators

23. Operators By Categories(Contd.)
Conditional
and Boolean
Operators
Mathematical
and
Aggregate
Operators
Backpressure
Operators
ReactiveX provides great flexibility over operators by
letting us chaining them together or even creating new
ones.

24. Transforming Observable

25. Transforming Observable << Map

26. Transforming Observable << Flatmap

27. Filtering Observable

28. Filtering Observable << Take

29. Filtering Observable << Filter

30. Filtering Observable << Distinct

31. Filtering Observable << First

32. Combining Observable

33. Combining Observable << Merge

34. Combining Observable << Zip

35. Schedulers
If you want to introduce multithreadingintoyour cascade of
Observable operators, you can do so by instructingthose operators
(or particular Observables) to operate on particular Schedulers.

36. Observable Utility Operators

37. Observable Utility Operators << SubscribeOn

38. Observable Utility Operators << ObserveOn

39. Single

40. Single
◦ RxJava (and its derivatives like RxGroovy & RxScala) has developed
an Observable variant called “Single.”
◦ A Single is something like an Observable, but instead of emitting a
series of values — anywhere from none at all to an infinite number
— it always either emits one value or an error notification.
◦ For this reason, instead of subscribing to a Single with the three
methods you use to respond to notifications from an Observable
(onNext, onError, and onCompleted), you only use two methods to
subscribe:

41. Subjects

42. Subject
A Subject is a sort of bridge or proxy that is available in some
implementations of ReactiveX that acts both as an observer and as an
Observable. Because it is an observer, it can subscribe to one or more
Observables, and because it is an Observable, it can pass through the
items it observes by reemitting them, and it can also emit new items.
Because a Subject subscribes to an Observable, it will trigger that
Observable to begin emitting items (if that Observable is “cold” — that
is, if it waits for a subscription before it begins to emit items). This can
have the effect of making the resulting Subject a “hot” Observable
variant of the original “cold” Observable.

43. Varieties of Subject
◦ AsyncSubject
◦ BehaviorSubject
◦ PublishSubject
◦ ReplaySubject

44. Subject << AsyncSubject

45. Subject << BehaviorSubject

46. Subject << PublishSubject

47. Subject << ReplaySubject

48. Backpressure

49. Backpressure
In RxJava it is not difficult to get into a situation in which an Observable
is emitting items more rapidly than an operator or subscriber can
consume them. This presents the problem of what to do with such a
growing backlog of unconsumed items.
For example, imagine using the zip operator to zip together two infinite
Observables, one of which emits items twice as frequently as the other.
A naive implementation of the zip operator would have to maintain an
ever-expanding buffer of items emitted by the faster Observable to
eventually combine with items emitted by the slower one. This could
cause RxJava to seize an unwieldy amount of system resources.

50. Hot and Cold
Observable

51. Hot Observable
A hot Observable begins generating items to emit immediately when it
is created. Subscribers typically begin observing the sequence of items
emitted by a hot Observable from somewhere in the middle of the
sequence, beginning with the first item emitted by the Observable
subsequent to the establishment of the subscription.
Such an Observable emits items at its own pace, and it is up to its
observers to keep up.
Examples of items emitted by a hot Observable might include mouse &
keyboard events, system events, or stock prices.

52. Cold Observable
A cold Observable emits a particular sequence of items, but can begin
emitting this sequence when its Observer finds it to be convenient, and
at whatever rate the Observer desires, without disrupting the integrity of
the sequence.
For example if you convert a static Iterable into an Observable, that
Observable will emit the same sequence of items no matter when it is
later subscribed to or how frequently those items are observed.
Examples of items emitted by a cold Observable might include the
results of a database query, file retrieval, or web request.

53. Conclusion

54. Pros
◦ Makes Async code easy to develop
◦ Lots of resources to get started with
◦ Strong use of functional type programming
◦ Netflix used RxNetty and Reactive Programmingto
considerable performance advantage over Tomcat
◦ Web Service clients like Jerseyand Retrofit support RxJava.

55. Cons
◦ Learning curve and mind set change to use functional reactive
programming
◦ Appears like more code and more complex code initially–
Requires time for it to grow on you.
◦ If on Java 7 anonymous class would make this a non-starter.

56. Thanks!
ANY QUESTIONS?
You can find me at:
hiten@nexthoughts.com
http://github.com/hitenpratap/
http://hprog99.wordpress.com/