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] []

Download Presentation
Download Policy: The content available on the website is offered to you 'AS IS' for your personal information and use only. It cannot be commercialized, licensed, or distributed on other websites without prior consent from the author. To download a presentation, simply click this link. If you encounter any difficulties during the download process, it's possible that the publisher has removed the file from their server.

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
Break Bricks CSEE 4840 Embedded System Design Spring 2013 Academic Supervisor: Professor Stephen

Break Bricks CSEE 4840 Embedded System Design Spring 2013 Academic Supervisor: Professor Stephen

Break Bricks CSEE 4840 Embedded System Design Spring 2013 Academic Supervisor: Professor Stephen A. Edwards Zimeng Chen, Yuanhan Yang, Bin Xie, Chong Li, Lianhao Qu Architecture Architecture VGA 1. Image processing 2. Image storage

256 views • 9 slides
Abstract This practitioners' report describes Credit Suisse's new client-centric price management

Abstract This practitioners' report describes Credit Suisse's new client-centric price management

Public Design and Implementation of an agile Price Management Platform for Banking Date: 2011-05-19 Produced by: Thipor Kong Account &amp; Product Management / Domain Architecture, Extended Pricing Platform Ulrich Hildebrand Core Banking

631 views • 14 slides
DOWNTOWN PARKING AND TRANSPORTATION MANAGEMENT PLAN FINAL DRAFT JUNE 29, 2015 BBA PARKING

DOWNTOWN PARKING AND TRANSPORTATION MANAGEMENT PLAN FINAL DRAFT JUNE 29, 2015 BBA PARKING

DOWNTOWN PARKING AND TRANSPORTATION MANAGEMENT PLAN FINAL DRAFT JUNE 29, 2015 BBA PARKING INITIATIVE 1 Transportation, Energy &amp; Utilities Committee PRESENTATION AUGUST 4, 2015 BBA PARKING INITIATIVE 2 AGENDA WHAT WEVE

307 views • 18 slides
Wisdom as embodied and embedded process by Sarah Smith MAPP Buckinghamshire New University

Wisdom as embodied and embedded process by Sarah Smith MAPP Buckinghamshire New University

Wisdom as embodied and embedded process by Sarah Smith MAPP Buckinghamshire New University When I open myself up to the vastness of my own ignorance, I cant help but feel a sudden suffocating feeling ( Resnick, 2019) There is no

267 views • 23 slides
RxJS 5 RxJS 5 RxJS 5 RxJS 5 In-depth In-depth by Gerard Sans (@gerardsans) A little about me

RxJS 5 RxJS 5 RxJS 5 RxJS 5 In-depth In-depth by Gerard Sans (@gerardsans) A little about me

RxJS 5 RxJS 5 RxJS 5 RxJS 5 In-depth In-depth by Gerard Sans (@gerardsans) A little about me A little about me a bit more... a bit more... A A A A synchronous Data Streams synchronous Data Streams synchronous Data Streams synchronous

676 views • 44 slides
Project Objective Project Objective Project Objective Project

Project Objective Project Objective Project Objective Project

Project Objective Project Objective Project Objective Project Objective Design Design Design Design SolidWorks Model SolidWorks Model SolidWorks Model SolidWorks Model Physical Model Physical Model

334 views • 15 slides
The meaning of robustness for flood risk management Marjolein Mens, Frans Klijn &amp; Karin de

The meaning of robustness for flood risk management Marjolein Mens, Frans Klijn &amp; Karin de

The meaning of robustness for flood risk management Marjolein Mens, Frans Klijn &amp; Karin de Bruijn Deltares, the Netherlands Common approach flood risk = flood probability x consequences land use map potential damage map damage functions

818 views • 19 slides
Beta Presentation Mobile Information App For Staff The Capstone Experience Team MSUFCU Hassan

Beta Presentation Mobile Information App For Staff The Capstone Experience Team MSUFCU Hassan

Beta Presentation Mobile Information App For Staff The Capstone Experience Team MSUFCU Hassan Alhulaymi Angel Hemmes Clay Reinmann Yen Han Shih Department of Computer Science and Engineering Michigan State University Spring 2013 From

111 views • 10 slides

More recommend