This is just a little bit of a learning from my previous post, where I had tried out Spring's native support for reactive programming.

Just to quickly recap, my objective was to develop a reactive service that takes in a request that looks like this:

{
    "id":1,
    "delay_by": 2000,
    "payload": "Hello",
    "throw_exception": false
}

And returns a response along these lines:

{
    "id": "1",
    "received": "Hello",
    "payload": "Response Message"
}

I had demonstrated this in two ways that the upcoming Spring's reactive model supports — using the Rector-Core Flux type as a return type and using Rx-java Observable type.

However, the catch with these types is that the response would look something like this:

[{"id":"1","received":"Hello","payload":"From RxJavaService"}]

Essentially an array, and the reason is obvious — Flux and Observable represent zero or more asynchronous emissions, and so Spring Reactive Web has to represent such a result as an array. 

The fix to return the expected JSON is to essentially return a type which represents 1 value — such a type is the Mono in Reactor-Core OR a Single in Rx-Java. Both these types are as capable as their multi-valued counterparts in providing functions which combine and transform their elements.

So with this change, the controller signature with Mono looks like this:

@RequestMapping(path = "/handleMessageReactor", method = RequestMethod.POST)
public Mono<MessageAcknowledgement> handleMessage(@RequestBody Message message) {
    return this.aService.handleMessageMono(message);
}

And with Single like this:

@RequestMapping(path = "/handleMessageRxJava", method = RequestMethod.POST)
public Single<MessageAcknowledgement> handleMessage(@RequestBody Message message) {
    return this.aService.handleMessageSingle(message);
}

I have the sample code in my GitHub repo.