reactive programming with rx
play

Reactive Programming with Rx QConSF - November 2014 Ben Christensen - PowerPoint PPT Presentation

Aug 13, 2022 •714 likes •2.49k views

Reactive Programming with Rx QConSF - November 2014 Ben Christensen Developer Edge Engineering at Netflix @benjchristensen http://techblog.netflix.com/ RxJava http://github.com/ReactiveX/RxJava http://reactivex.io Maven Central:

  1. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  2. flatMap ¡Observable<R> ¡b ¡= ¡Observable<T> . flatMap ({ ¡T ¡t ¡ -­‑> ¡ ¡ ¡ ¡ ¡ ¡Observable<R> ¡r ¡= ¡... ¡transform ¡t ¡... ¡ ¡ ¡ ¡ ¡ return ¡r; ¡ ¡ })

  3. flatMap ¡Observable<R> ¡b ¡= ¡Observable<T> . flatMap ({ ¡T ¡t ¡ -­‑> ¡ ¡ ¡ ¡ ¡ ¡Observable<R> ¡r ¡= ¡... ¡transform ¡t ¡... ¡ ¡ ¡ ¡ ¡ return ¡r; ¡ ¡ })

  4. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  5. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  6. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  7. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  8. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  9. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  10. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  11. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  12. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  13. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  14. zip { ( , ) } ¡ ¡ ¡ ¡Observable . zip ( a, ¡b, ¡ ( a, ¡b) ¡ -­‑> ¡{ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡... ¡operate ¡on ¡values ¡from ¡both ¡a ¡& ¡b ¡... ¡ ¡ ¡ ¡ ¡ ¡ ¡ return ¡Arrays.asList(a, ¡b); ¡ ¡ ¡ ¡ ¡ })

  15. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  16. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  18. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  19. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  20. instead of a blocking api ... class ¡ VideoService ¡ { ¡ ¡ ¡ ¡ def ¡VideoList ¡getPersonalizedListOfMovies ( userId ); ¡ ¡ ¡ ¡def ¡VideoBookmark ¡getBookmark ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡VideoRating ¡getRating ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡VideoMetadata ¡getMetadata ( videoId ); ¡ } ... create an observable api: class ¡ VideoService ¡ { ¡ ¡ ¡ ¡ def ¡Observable < VideoList > ¡getPersonalizedListOfMovies ( userId ); ¡ ¡ ¡ ¡def ¡Observable < VideoBookmark > ¡getBookmark ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡Observable < VideoRating > ¡getRating ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡Observable < VideoMetadata > ¡getMetadata ( videoId ); ¡ }

  21. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { 1 // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) 2 .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); 3 Observable<Rating> rating = getRating(video); 4 Observable<VideoMetadata> metadata = getMetadata(video); 5 return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { 6 return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  22. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { 1 // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) 2 .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); 3 Observable<Rating> rating = getRating(video); 4 Observable<VideoMetadata> metadata = getMetadata(video); 5 return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { 6 return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  23. Non-Opinionated Concurrency

  25. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  30. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) { // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); }).flatMap(data -> { // output as SSE as we get back the data (no waiting until all is done) return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data))); }); }

  32. Decouples Consumption from Production // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); })

  33. Decouples Consumption from Production // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); })

  34. Decouples Consumption from Production // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); Observable<Rating> rating = getRating(video); Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); })

  35. Decouples Consumption from Production API Request new Command().observe() API Request new Command(). observe() Collapser Dependency API Request new Command(). observe() Event Loop REST API API Request new Command(). observe() API Request new Command(). observe()

  36. ~5 network calls (#3 and #4 may result in more due to windowing) // first request User object return getUser(request.getQueryParameters().get("userId")).flatMap(user -> { 1 // then fetch personal catalog Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user) 2 .flatMap(catalogList -> { return catalogList.videos().<Map<String, Object>> flatMap(video -> { Observable<Bookmark> bookmark = getBookmark(video); 3 Observable<Rating> rating = getRating(video); 4 Observable<VideoMetadata> metadata = getMetadata(video); return Observable.zip(bookmark, rating, metadata, (b, r, m) -> { return combineVideoData(video, b, r, m); }); }); }); // and fetch social data in parallel Observable<Map<String, Object>> social = getSocialData(user).map(s -> { 5 return s.getDataAsMap(); }); // merge the results return Observable.merge(catalog, social); })

  37. Clear API Communicates Potential Cost class ¡ VideoService ¡ { ¡ ¡ ¡ ¡ def ¡Observable < VideoList > ¡getPersonalizedListOfMovies ( userId ); ¡ ¡ ¡ ¡def ¡Observable < VideoBookmark > ¡getBookmark ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡Observable < VideoRating > ¡getRating ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡Observable < VideoMetadata > ¡getMetadata ( videoId ); ¡ }

  38. Implementation Can Differ BIO Network Call class ¡ VideoService ¡ { ¡ ¡ ¡ ¡ def ¡Observable < VideoList > ¡getPersonalizedListOfMovies ( userId ); ¡ ¡ ¡ ¡def ¡Observable < VideoBookmark > ¡getBookmark ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡Observable < VideoRating > ¡getRating ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡Observable < VideoMetadata > ¡getMetadata ( videoId ); ¡ } Local Cache Collapsed Network Call

  39. Implementation Can Differ and Change BIO NIO Network Call class ¡ VideoService ¡ { ¡ ¡ ¡ ¡ def ¡Observable < VideoList > ¡getPersonalizedListOfMovies ( userId ); ¡ ¡ ¡ ¡def ¡Observable < VideoBookmark > ¡getBookmark ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡Observable < VideoRating > ¡getRating ( userId, ¡videoId ); ¡ ¡ ¡ ¡def ¡Observable < VideoMetadata > ¡getMetadata ( videoId ); ¡ } Local Cache Collapsed Collapsed Network Call Network Call

  40. Retrieval, Transformation, Combination all done in same declarative manner

  41. What about … ?

  42. Error Handling

  43. Observable.create(subscriber -> { throw new RuntimeException("failed!"); }).onErrorResumeNext(throwable -> { return Observable.just("fallback value"); }).subscribe(System.out::println);

  44. Observable.create(subscriber -> { throw new RuntimeException("failed!"); }).onErrorReturn(throwable -> { return "fallback value"; }).subscribe(System.out::println);

  45. Observable.create(subscriber -> { throw new RuntimeException("failed!"); }).retryWhen(attempts -> { return attempts.zipWith(Observable.range(1, 3), (throwable, i) -> i) .flatMap(i -> { System.out.println("delay retry by " + i + " second(s)"); return Observable.timer(i, TimeUnit.SECONDS); }).concatWith(Observable.error(new RuntimeException("Exceeded 3 retries"))); }) .subscribe(System.out::println, t -> t.printStackTrace());

  46. Observable.create(subscriber -> { throw new RuntimeException("failed!"); }).retryWhen(attempts -> { return attempts.zipWith(Observable.range(1, 3), (throwable, i) -> i) .flatMap(i -> { System.out.println("delay retry by " + i + " second(s)"); return Observable.timer(i, TimeUnit.SECONDS); }).concatWith(Observable.error(new RuntimeException("Exceeded 3 retries"))); }) .subscribe(System.out::println, t -> t.printStackTrace());

  47. Observable.create(subscriber -> { throw new RuntimeException("failed!"); }).retryWhen(attempts -> { return attempts.zipWith(Observable.range(1, 3), (throwable, i) -> i) .flatMap(i -> { System.out.println("delay retry by " + i + " second(s)"); return Observable.timer(i, TimeUnit.SECONDS); }).concatWith(Observable.error(new RuntimeException("Exceeded 3 retries"))); }) .subscribe(System.out::println, t -> t.printStackTrace());

  48. Observable.create(subscriber -> { throw new RuntimeException("failed!"); }).retryWhen(attempts -> { return attempts.zipWith(Observable.range(1, 3), (throwable, i) -> i) .flatMap(i -> { System.out.println("delay retry by " + i + " second(s)"); return Observable.timer(i, TimeUnit.SECONDS); }).concatWith(Observable.error(new RuntimeException("Exceeded 3 retries"))); }) .subscribe(System.out::println, t -> t.printStackTrace());

  49. Concurrency

  50. Concurrency an Observable is sequential (no concurrent emissions) scheduling and combining Observables enables concurrency while retaining sequential emission

  51. // merging async Observables allows each // to execute concurrently Observable.merge(getDataAsync(1), getDataAsync(2)) merge

  52. // concurrently fetch data for 5 items Observable.range(0, 5).flatMap(i -> { return getDataAsync(i); })

  53. Observable.range(0, 5000).window(500).flatMap(work -> { return work.observeOn(Schedulers.computation()) .map(item -> { // simulate computational work try { Thread.sleep(1); } catch (Exception e) {} return item + " processed " + Thread.currentThread(); }); })

  54. Observable.range(0, 5000).buffer(500).flatMap(is -> { return Observable.from(is).subscribeOn(Schedulers.computation()) .map(item -> { // simulate computational work try { Thread.sleep(1); } catch (Exception e) {} return item + " processed " + Thread.currentThread(); }); })

  55. Flow Control

  56. Flow Control (backpressure)

  57. Observable.from(iterable).take(1000).map(i -> "value_" + i).subscribe(System.out::println); no backpressure needed

  58. Observable.from(iterable).take(1000).map(i -> "value_" + i).subscribe(System.out::println); no backpressure needed synchronous on same thread (no queueing)

  59. Observable.from(iterable).take(1000).map(i -> "value_" + i) .observeOn(Schedulers.computation()).subscribe(System.out::println); backpressure needed

  60. Observable.from(iterable).take(1000).map(i -> "value_" + i) .observeOn(Schedulers.computation()).subscribe(System.out::println); backpressure needed asynchronous (queueing)

  61. Flow Control Options

  62. Hot Cold emits when requested emits whether you’re ready or not (generally at controlled rate) examples examples mouse and keyboard events database query system events web service request stock prices reading file Observable.create(subscriber -> { Observable.create(subscriber -> { // register with data source // fetch data }) }) flow control flow control & backpressure

  63. Block (callstack blocking and/or park the thread) Hot or Cold Streams

  64. Temporal Operators (batch or drop data using time) Hot Streams

  65. Observable.range(1, 1000000).sample(10, TimeUnit.MILLISECONDS).forEach(System.out::println); 110584 242165 544453 942880

  66. Observable.range(1, 1000000).throttleFirst(10, TimeUnit.MILLISECONDS).forEach(System.out::println); 1 55463 163962 308545 457445 592638 751789 897159

  67. Observable.range(1, 1000000).debounce(10, TimeUnit.MILLISECONDS).forEach(System.out::println); 1000000

  68. Observable.range(1, 1000000).buffer(10, TimeUnit.MILLISECONDS) .toBlocking().forEach(list -> System.out.println("batch: " + list.size())); batch: 71141 batch: 49488 batch: 141147 batch: 141432 batch: 195920 batch: 240462 batch: 160410

  70. /* The following will emit a buffered list as it is debounced */ // first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe Observable<Integer> burstStream = intermittentBursts().take(20).publish().refCount(); // then we get the debounced version Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS); // then the buffered one that uses the debounced stream to demark window start/stop Observable<List<Integer>> buffered = burstStream.buffer(debounced); // then we subscribe to the buffered stream so it does what we want buffered.toBlocking().forEach(System.out::println); [0, 1, 2] [0, 1, 2] [0, 1, 2, 3, 4, 5, 6] [0, 1, 2, 3, 4] [0, 1] []

  71. /* The following will emit a buffered list as it is debounced */ // first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe Observable<Integer> burstStream = intermittentBursts().take(20).publish().refCount(); // then we get the debounced version Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS); // then the buffered one that uses the debounced stream to demark window start/stop Observable<List<Integer>> buffered = burstStream.buffer(debounced); // then we subscribe to the buffered stream so it does what we want buffered.toBlocking().forEach(System.out::println); [0, 1, 2] [0, 1, 2] [0, 1, 2, 3, 4, 5, 6] [0, 1, 2, 3, 4] [0, 1] []

  72. /* The following will emit a buffered list as it is debounced */ // first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe Observable<Integer> burstStream = intermittentBursts().take(20).publish().refCount(); // then we get the debounced version Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS); // then the buffered one that uses the debounced stream to demark window start/stop Observable<List<Integer>> buffered = burstStream.buffer(debounced); // then we subscribe to the buffered stream so it does what we want buffered.toBlocking().forEach(System.out::println); [0, 1, 2] [0, 1, 2] [0, 1, 2, 3, 4, 5, 6] [0, 1, 2, 3, 4] [0, 1] []

Recommend

How Java9+ helps you REACT- Reactive Programming? Jayashree S Kumar, IBM Agenda Why? What?

How Java9+ helps you REACT- Reactive Programming? Jayashree S Kumar, IBM Agenda Why? What?

How Java9+ helps you REACT- Reactive Programming? Jayashree S Kumar, IBM Agenda Why? What? and When? Reactive - System, Principles, Programming, Streams Go reactive in Java : Popular Tools/Libs Java9s Flow API and the

790 views • 40 slides
EFFECTS, ASYNCHRONY, AND CHOICE IN ARROWIZED FUNCTIONAL REACTIVE PROGRAMMING Daniel

EFFECTS, ASYNCHRONY, AND CHOICE IN ARROWIZED FUNCTIONAL REACTIVE PROGRAMMING Daniel

EFFECTS, ASYNCHRONY, AND CHOICE IN ARROWIZED FUNCTIONAL REACTIVE PROGRAMMING Daniel Winograd-Cort Department of Computer Science Yale University Dissertation Defense New Haven, CT Thursday, June 11, 2015 Functional Reactive Programming

1.1k views • 97 slides
Fairness in reactive programming Andrew Cave McGill University January 25, 2013 Joint work with

Fairness in reactive programming Andrew Cave McGill University January 25, 2013 Joint work with

Fairness in reactive programming Andrew Cave McGill University January 25, 2013 Joint work with Francisco Ferreira, Prakash Panangaden and Brigitte Pientka 1 / 14 Introduction Reactive programming languages provide a setting to implement

307 views • 14 slides
Functional Reactive Programming Brandon Siegel Senior Engineer, Mobile Defense Topics

Functional Reactive Programming Brandon Siegel Senior Engineer, Mobile Defense Topics

Functional Reactive Programming Brandon Siegel Senior Engineer, Mobile Defense Topics Monads Futures and Promises Observables, Observers, Subscriptions, and Subjects Functional Reactive Programming in Practice What is a

776 views • 76 slides
Functional Reactive Programming Bob Reynders PLaNES, 4 Februari 2015 1/19 Functional Reactive

Functional Reactive Programming Bob Reynders PLaNES, 4 Februari 2015 1/19 Functional Reactive

Functional Reactive Programming Bob Reynders PLaNES, 4 Februari 2015 1/19 Functional Reactive Programming Event discrete values Mouse.click: Event[Click] List[(Time, A)] Behavior time-varying values Mouse.position:

204 views • 19 slides
Programming Reactive Systems in Scala: Principles and Abstractions Philipp Haller KTH Royal

Programming Reactive Systems in Scala: Principles and Abstractions Philipp Haller KTH Royal

Programming Reactive Systems in Scala: Principles and Abstractions Philipp Haller KTH Royal Institute of Technology Stockholm, Sweden Entwicklertag Frankfurt, Germany, 21 February, 2018 What are reactive systems? Multiple definitions proposed

893 views • 54 slides
Reactive Programming Models for IoT Todd L. Montgomery @toddlmontgomery Psst! Already Here! Not

Reactive Programming Models for IoT Todd L. Montgomery @toddlmontgomery Psst! Already Here! Not

Reactive Programming Models for IoT Todd L. Montgomery @toddlmontgomery Psst! Already Here! Not New! Internet of Things? Just a Silicon Valley buzzword? Psst! Also Not New! Reactive Programming? Just another buzzword? Connecting Things

699 views • 51 slides
Reactive Programming for Java Developers Rossen Stoyanchev About Me Spring Framework committer

Reactive Programming for Java Developers Rossen Stoyanchev About Me Spring Framework committer

Reactive Programming for Java Developers Rossen Stoyanchev About Me Spring Framework committer Spring MVC, WebSocket messaging Spring 5 Reactive Long-Running Shift to Concurrency Today Independent services, Cloud

1.01k views • 65 slides
Push-pull functional reactive programming Conal Elliott 3 September, 2009 Haskell Symposium

Push-pull functional reactive programming Conal Elliott 3 September, 2009 Haskell Symposium

Functional reactive programming Future values Improving values Unambiguous choice Push-pull functional reactive programming Conal Elliott 3 September, 2009 Haskell Symposium Conal Elliott Push-pull functional reactive programming

489 views • 27 slides
Reactive Probabilistic Programming Semantics with Mixed Nondeterministic/Probabilistic Automata

Reactive Probabilistic Programming Semantics with Mixed Nondeterministic/Probabilistic Automata

Reactive Probabilistic Programming Semantics with Mixed Nondeterministic/Probabilistic Automata Albert Benveniste Jean-Baptiste Raclet INRIA Rennes and IRIT Toulouse September 18, 2020 What is Probabilistic Programming? Bringing the

855 views • 59 slides
The CurryHoward Correspondence between Temporal Logic and Functional Reactive Programming

The CurryHoward Correspondence between Temporal Logic and Functional Reactive Programming

Functional Reactive Programming Correspondence to Temporal Logic Benefitting from the Correspondence The CurryHoward Correspondence between Temporal Logic and Functional Reactive Programming Wolfgang Jeltsch Brandenburgische Technische

451 views • 19 slides
Reactive Programming, and WinForms in F# So far weve seen some simple interaction for F#

Reactive Programming, and WinForms in F# So far weve seen some simple interaction for F#

Interaction Reactive Programming, and WinForms in F# So far weve seen some simple interaction for F# programs: Return a value from an evaluated expression Bjrn Lisper Print to the console School of Innovation, Design, and

506 views • 8 slides
Computational Notebooks 30.06.2020 30.06.20 | FB Informatik | Reactive Programming &amp; STG

Computational Notebooks 30.06.2020 30.06.20 | FB Informatik | Reactive Programming &amp; STG

Computational Notebooks 30.06.2020 30.06.20 | FB Informatik | Reactive Programming &amp; STG | G. Doci, J.Stadtmller | 1 Outline Motivation Strong points Pain points &amp; messiness Existing approaches and solutions

234 views • 22 slides
A Survey on Reactive Programming Engineer Bainomugisha, Andoni Lombide Carreton, Tom Van

A Survey on Reactive Programming Engineer Bainomugisha, Andoni Lombide Carreton, Tom Van

A Survey on Reactive Programming Engineer Bainomugisha, Andoni Lombide Carreton, Tom Van Cutsem, Stijn Mostinckx, Wolfgang De Meuter ACM Computing Surveys (CSUR) 2013 PLaNES reading club 21 Jan 2015 Languages 6 Dimensions (

499 views • 39 slides
ARx: Reactive Programming for Synchronous Connectors Jos Proena , Guillermina Cledou

ARx: Reactive Programming for Synchronous Connectors Jos Proena , Guillermina Cledou

ARx: Reactive Programming for Synchronous Connectors Jos Proena , Guillermina Cledou Coordination @ DisCoTec 2020 Video of the presentation: https://www.youtube.com/watch?v=74RUzfYneNI&amp;t=2s Tools: http://arcatools.org/#arx Tools:

384 views • 20 slides
Get Reactive: Microservices, Programming, and Systems Jeremy Davis Principal Solution

Get Reactive: Microservices, Programming, and Systems Jeremy Davis Principal Solution

Get Reactive: Microservices, Programming, and Systems Jeremy Davis Principal Solution Architect, App Dev @argntprgrmr Why Does Any of This Matter? Jakob Nielsen 46 years, 3 numbers 0.1 1 10 3 microservicesjourney.com 4

880 views • 51 slides
Structured Reactive Programming with Polymorphic Temporal Tiles S. Archipoff &amp; D. Janin ,

Structured Reactive Programming with Polymorphic Temporal Tiles S. Archipoff &amp; D. Janin ,

Structured Reactive Programming with Polymorphic Temporal Tiles S. Archipoff &amp; D. Janin , Bordeaux INP, UMR CNRS LaBRI, Inria BSO, University of Bordeaux @ICFP/FARM, Nara, Japan, 2016 This work is dedicated to the memory Paul Hudak. Our

920 views • 37 slides
Categorical Semantics for Functional Reactive Programming with Temporal Recursion and Corecursion

Categorical Semantics for Functional Reactive Programming with Temporal Recursion and Corecursion

Categorical Semantics for Functional Reactive Programming with Temporal Recursion and Corecursion Wolfgang Jeltsch TT Kberneetika Instituut Tallinn, Estonia Teooriapevad Narva-Jesuus 1618 May 2014 Wolfgang Jeltsch (TT

267 views • 15 slides
1 MIT Cooperative Vehicle Testbed Outline Distributed Satellites: Spheres, Spheres,

1 MIT Cooperative Vehicle Testbed Outline Distributed Satellites: Spheres, Spheres,

Outline Executing Reactive, Model-based Cooperative Vehicle Missions Programs through Graph-based Model-based Programming Temporal Planning Reactive Model-based Programming Language (RMPL) Temporal Plan Networks (TPN) Phil

526 views • 13 slides
Expressing Causality in Categorical Models of Functional Reactive Programming Wolfgang Jeltsch

Expressing Causality in Categorical Models of Functional Reactive Programming Wolfgang Jeltsch

Introduction Causality Causality in semantics Consequences Conclusions Expressing Causality in Categorical Models of Functional Reactive Programming Wolfgang Jeltsch TT U K uberneetika Instituut Tallinn, Estonia Joint

547 views • 15 slides
1 Recent Advances in Reactive Planning: Past Approaches to Planning BDD-based Universal Planning

1 Recent Advances in Reactive Planning: Past Approaches to Planning BDD-based Universal Planning

Massachusetts Institute of Technology Motivation for Reactive Planning Factored Symbolic Approach to Reactive Planning Seung H. Chung Brian C. Williams Reason for Planning Reason for onboard reactive planning Anomalies June 7,

80 views • 7 slides
Juniper: A Functional Reactive Programming Language for the Arduino Caleb Helbling Tufts

Juniper: A Functional Reactive Programming Language for the Arduino Caleb Helbling Tufts

Juniper: A Functional Reactive Programming Language for the Arduino Caleb Helbling Tufts University Samuel Z. Guyer Tufts University Workshop on Functional Art, Music, Modelling and Design (FARM) September 2016 Project Ideas From the

619 views • 25 slides
Reactive design patterns for microservices on multicore Reactive summit - 22/10/18

Reactive design patterns for microservices on multicore Reactive summit - 22/10/18

Reactive Software with elegance Reactive design patterns for microservices on multicore Reactive summit - 22/10/18 charly.bechara@tredzone.com Outline Microservices on multicore Reactive Multicore Patterns Modern Software Roadmap 2 1

1.14k views • 69 slides
Outline Synchronous Programming Introduction of Reactive Systems The Data-Flow Language Lustre

Outline Synchronous Programming Introduction of Reactive Systems The Data-Flow Language Lustre

Outline Synchronous Programming Introduction of Reactive Systems The Data-Flow Language Lustre The Imperative Language Esterel Compilation of Synchronous Languages Nicolas Halbwachs Verification and Automatic Testing of Synchronous

371 views • 26 slides

More recommend