You can map an Observable<List<Car>> to Observable<Car> like so: yourListObservable.flatMapIterable(x -> x) Note that flatMapping might not preserve the order of the source observable. If the order matters to you, use concatMapIterable. Read here for more details.
How is reactive programming different than event-driven programming? Event driven programming revolves around so-called events, which are abstract things that programs “fire” when something happens. Other places in your code “listen” for the events and respond with what they need to do when that event happens. For instance, an event could be “user pressed this … Read more
We accomplished this by providing a custom ExchangeFunction that simply returns the response we want to the WebClientBuilder: webClient = WebClient.builder() .exchangeFunction(clientRequest -> Mono.just(ClientResponse.create(HttpStatus.OK) .header(“content-type”, “application/json”) .body(“{ \”key\” : \”value\”}”) .build()) ).build(); myHttpService = new MyHttpService(webClient); Map<String, String> result = myHttpService.callService().block(); // Do assertions here If we want to use Mokcito to verify if the … Read more
I am coming back a few months later to my original question and wanted to share the gained knowledge in the meanwhile. I will use the following code as an explanation support (jsfiddle): var ta_count = document.getElementById(‘ta_count’); var ta_result = document.getElementById(‘ta_result’); var threshold = 3; function emits ( who, who_ ) {return function ( x … Read more
In many cases, you are doing some computation or calling a service and you expect exactly one result (or maybe zero or one result), and not a collection that contains possibly multiple results. In such cases, it’s more convenient to have a Mono. Compare it to “regular” Java: you would not use List as the … Read more
Reactive programming is the general paradigm behind easily propagating changes in a data stream through the execution of a program. It’s not a specific pattern or entity per-se, it’s an idea, or style of programming (such as object oriented progamming, functional programming, etc.) Loosely speaking, it’s the concept that when x changes or updates in … Read more
About promise composition vs. Rxjs, as this is a frequently asked question, you can refer to a number of previously asked questions on SO, among which : How to do the chain sequence in rxjs RxJS Promise Composition (passing data) RxJS sequence equvalent to promise.then()? Basically, flatMap is the equivalent of Promise.then. For your second … Read more
That’s because an error means completion, so the callback associated to onCompleted never gets called. You can review here Rxjs contract for observables (http://reactivex.io/documentation/contract.html) : An Observable may make zero or more OnNext notifications, each representing a single emitted item, and it may then follow those emission notifications by either an OnCompleted or an OnError … Read more
No, RestTemplate will continue to exist (at least for now). You don’t have to replace it with WebClient. One of the main differences is RestTemplate is synchronous and blocking i.e. when you do a rest call you need to wait till the response comes back to proceed further. But WebClient is complete opposite of this. … Read more
Both Observables and node.js’s Streams allow you to solve the same underlying problem: asynchronously process a sequence of values. The main difference between the two, I believe, is related to the context that motivated its appearance. That context is reflected in the terminology and API. On the Observables side you have an extension to EcmaScript … Read more