Reactive Programming in Java. Copyright - Syncogni Consulting Pvt Ltd. All rights reserved.

Size: px

Start display at page:

Arleen Parrish
6 years ago
Views:

2 Prerequisites: Functional Programming as in Java 8 Streams of Java 8 Lambda expressions Method references

3 Expectations from the participants?

4 Note: The slides are a bit descriptive, because: anybody can use it even after the session without trainer it serves as PPT + study material participants read it silently/aloud during session to maximize participation

5 Teaser begins.

6 Official Reactive Manifesto Responsive Resilient Elastic Message Driven

7 Get the official ribbon!!!

11 Teaser Ends.

12 Trailer begins.

13 Reactive Programming Reactive = showing response to a stimulus Reactive / Responsive Scalable Resilient / fault tolerant Event driven Observable sequences Backpressure Represented using marble diagrams

14 Reactive Programming Async facade - design pattern Asynchronous Ex 1: Do x, y, z after p is done Ex 2: Do p, q after r is started Ex 3:

15 Reactive Programming Polyglot Implemented (Library is available) in.net Scala Clojure JavaScript Ruby Python C++, Groovy, Objective-C/Cocoa etc.

16 Reactive Programming Java Implementations: RxJava from Netflix Spring 5 JSR 166 (headed by Doug Lee) to be implemented in Java 9 Vert.x 3.0

17 What is RxJava? Note : RxJava = Reactive Extensions for Java A library for composing asynchronous and event based programs using observable sequences for the Java VM - Netflix

18 Why Rx? We are not blocked on some operation We will respond to an event as and when we receive the notification of that event When / if the stock price changes, we will be notified. Then only we will take appropriate action If the cricket score changes, we will hear a loud noise, then only look at the screen :)

19 Why Rx? We don t wait for the entire web page to be downloaded to display it Keep pushing the election results as and when the change happens Divide and conquer approach Keep pushing the information like blackberry Users will react to the pushed data

20 Functional Reactive Asynchronous Values Events Push Functional Reactive Lambdas Closures Pure Composable

21 Imperative vs Reactive Iterable Observable pull push T next() onnext(t) throws Exception onerror(exception) returns; oncompleted()

22 Imperative vs Reactive // Iterable<String> contains 379 strings // Observable<String> contains 379 strings myiterable.skip( 16 ) //header.map( s -> s+ _transformed ) //blocking.foreach( e -> System.out.println(e) ); myobservable.skip(16) //header.map( s -> s+" transformed" ) //non-blocking.subscribe( e -> System.out.println(e) );

23 Scenarios: Single Multiple Sync T getdata() Iterable<T> getdata() Async Future<T> getdata() Observable<T> getdata()

24 Trailer Ends!!!

25 Movie Begins...

26 Hello World RxJava

36 Subscriber Subscriber<String> mysubscriber = new Subscriber<String>() public void onnext(string s) { System.out.println(s); public void oncompleted() { System.out.println("Done"); public void onerror(throwable e) { e.printstacktrace(); } };

37 Observable Observable<String> myobservable = Observable.create( new Observable.OnSubscribe<String>() public void call(subscriber<? super String> sub) { sub.onnext("hello, world!"); sub.oncompleted(); } });

38 Connecting code myobservable.subscribe(mysubscriber);

39 HelloWorldRxJava - Demo

40 Communication Protocol One item will be pushed to client during each onnext call at the server side For every onnext call on server, client can execute onnext and receive an item Once server executes, oncompleted or onerror, it will not execute onnext again

41 Communication Protocol Client will not initiate onnext or oncompleted or onerror, but, it is the server onerror signifies that there is some error at the observable s side The observable will call neither oncompleted nor onnext after calling onerror

42 Communication Protocol onnext* (oncompleted onerror)? * = zero or more;? = zero or one Client may call unsubscribe method at any time, to signal the same to server Server must check this using subscriber. isunsubscribed() method and must stop sending further push notifications

43 Life Cycle of an Observable lazily starts emitting items only after subscription keeps emitting items till an error is encountered or till the end of stream is reached lazily emits another item only after the previous item is consumed

45 Ex 2 : Client tells the server to stop //client side code Subscriber<String> mysubscriber = new Subscriber<String>() public void onnext(string s) { System.out.println(s); if (s.touppercase().contains("bahu")) { System.out.println("I got my movie!!!!"); unsubscribe(); } } };

46 Ex 2 : Client tells the server to stop //Server side Observable<String> myobservable = Observable.create(new Observable.OnSubscribe<String>() public void call(subscriber<? super String> sub) { List<String> list = Arrays.asList("Dhoom 3", "Bahubali", "Star wars", "Batman"); for (String e : list) { if (sub.isunsubscribed()) { break; } sub.onnext(e); } sub.oncompleted(); } });

47 Ex 3 : Error Handling - Server code for (String e : list) { try { if(e.equalsignorecase("bahubali 10")){ throw new Exception("Something is wrong!!!"); } sub.onnext(e); if (sub.isunsubscribed()) { break; } sub.oncompleted(); } catch (Exception e1) { sub.onerror(e1); break; } }

48 Ex 3 : Error Handling - Client public void onerror(throwable e) { e.printstacktrace(); }

49 ManualErrorHandler - Demo

50 Ex 5: Take only some values - demo //I can process only next 2 orders Observable<String> mycustomobservable = myobservable.take (2); mycustomobservable.subscribe(mysubscriber);

51 Ex 6: Take orders only for some time //I can take orders for another 3 seconds Observable<String> mycustomobservable = myobservable.take (3, TimeUnit.SECONDS); mycustomobservable.subscribe(mysubscriber);

52 Ex 7: Skip some initial values //Skip initial 3 bytes which is a useless header Observable<String> mycustomobservable = myobservable.skip(3); mycustomobservable.subscribe(mysubscriber);

53 Ex 8: Skip values for some time //Skip the values for initial 3 seconds //while they are testing microphone Observable<String> mycustomobservable = myobservable.skip(3, TimeUnit.SECONDS); mycustomobservable.subscribe(mysubscriber);

54 Ex 9: Skip and Take - Composition myobservable.skip(1).take(2).subscribe(mysubscriber);

55 Ex 10: Filter the stream myobservable.skip(1).take(2).filter(e -> e.touppercase().contains("star")).subscribe(mysubscriber);

56 SkipTakeFilterDemo

57 Ex 11: Two Subscribers - Demo myobservable.skip(1).take(2).filter(e -> e.touppercase().contains("star")).subscribe(mysubscriber1); myobservable.skip(2).take(3).filter(e -> e.touppercase().contains("gold")).subscribe(mysubscriber2);

58 Ex 12: Combinators //Combinators - Combine / Merge 2 observables Observable.merge(myObservable1, myobservable2).subscribe(mysubscriber);

59 Merge2Observables - Demo

60 Error Handling

61 Ex 13: onerrorresumenext //on error, resume with the next observable myobservable1.onerrorresumenext(myobservable2).subscribe(mysubscriber);

62 Ex 13: onerrorresumenext

63 Map vs FlatMap Both do transformation Map: maps one item to another item returns only one item synchronous FlatMap: maps one item to zero or more items returns an Observable stream asynchronous

65 FlatMap myobservable1.flatmap( s -> { String movie1 = s + " 1"; String movie2 = s + " 2"; String movie3 = s + " 3"; return Observable.just(movie1, movie2, movie3); } ).subscribe(mysubscriber);

66 Transformations

67 Group By Transformation groupby similar to group by clause in SQL groups items according to the condition given Ex : can group a sequence of numbers based on odd or even

69 window - operator chunks an Observable into windows of given time frame each chunk is emitted as an independent Observable Ex : Observable.interval(600, TimeUnit. MILLISECONDS).window(2, TimeUnit. SECONDS)

71 window - operator - Demo

72 Connectable Observable normal Observable starts emitting items immediately after subscribing to it publish() is used to get a Connectable one from the normal Connectable Observable emits items after calling connect() method on it. Connectable Observable can be made to wait till any/all Observers are subscribed

73 Connectable Observable Emits items only once for zero or more subscribers Subscribers are likely to lose some initial values if they join late

75 ConnectableObservable - Demo

76 Climax

77 Case studies:

78 Case study 1: DB Access

79 Case study 2 : FlatMap

80 Case study 3 : Twitter App Setup

91 Case study 3 : Twitter App Demo

92 THE END

93 Now revisit the teaser & the trailer :)

94 References Google Wikipedia SO RxJava API Docs html

95 ?

96 Let us stay in touch : Dinesh Bhatt DB@syncogni.com India : USA :

97 Thank you!!!

Reactive Programming in Java. Copyright - Syncogni Consulting Pvt Ltd. All rights reserved.

Reactive Programming in Java. Copyright - Syncogni Consulting Pvt Ltd. All rights reserved. Reactive Programming in Java Copyright - Syncogni Consulting Pvt Ltd. All rights reserved. Prerequisites: Core Java Lambda Expressions Method references Functional Programming Web - application development