Using a ReturnValueHandler to adapt RxJava Observables to Deferredresult in a SpringBoot micro service

If you look at my previous blog posts related to RxJava and Spring Boot microservices you may notice that all the subscriptions to the RxJava Observables are made in each and every controller method and controller method is responsible for the transformation between RxJava Observables and Spring aware DeferredResults. This is obvious one to one mapping that you can do between RxJava and Spring. In fact you can go further and generalize this behaviour. This will eliminate lots of boilerplate code in your application and make your code much more simple and readable. Also this brings a good software engineering practice called generalization and reuse into our code. Take a look at the following controller code before adding the return value handler.

	@Controller
	@RequestMapping("/api/currencyconverter")
	public class CurrencyResource {
	private static final Logger log = LoggerFactory.getLogger(CurrencyConverter.class);
	private final CurrencyConverterService currencyConverterService;
	public CurrencyResource(CurrencyConverterService currencyConverterService) {
	super();
	this.currencyConverterService = currencyConverterService;
	}
	@GetMapping(value = "/rates", produces = { MediaType.APPLICATION_JSON_UTF8_VALUE })
	public DeferredResult<?> getCurrencyRates(@RequestParam("symbol") Set<String> currencyRates) {
	DeferredResult<ResponseEntity<CurrencyRatesDTO>> deferredResult = new DeferredResult<>();
	log.debug("Retrieving currency rates.");
	currencyConverterService.getCurrencyRates(currencyRates).subscribeOn(Schedulers.io()).subscribe(
	sub -> deferredResult.setResult(ResponseEntity.ok(sub)), e -> deferredResult.setErrorResult(e));
	return deferredResult;
	}
	}

view raw CurrencyResource.java hosted with ❤ by GitHub

We can use a simple ReturnValueHandler that calls an adapter[Gamma95] that will adapt Observables to DeferredResults. By registering this value handler with Spring, all the methods that return an Observable will be reworked into returning a DeferredResult. When you use DeferredResults as a return type you are instructing Spring that your REST service is asynchronous. By doing this you get the benefits of asynchronous programming, having more efficient usage of your resources. Our first step is to write code for the return value handler which is given below.

	package com.example.handlers;
	import org.springframework.core.MethodParameter;
	import org.springframework.web.context.request.NativeWebRequest;
	import org.springframework.web.context.request.async.DeferredResult;
	import org.springframework.web.context.request.async.WebAsyncUtils;
	import org.springframework.web.method.support.AsyncHandlerMethodReturnValueHandler;
	import org.springframework.web.method.support.ModelAndViewContainer;
	import rx.Observable;
	public class ObservableReturnValueHandler implements AsyncHandlerMethodReturnValueHandler {
	@Override
	public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) {
	return returnValue != null && supportsReturnType(returnType);
	}
	@Override
	public boolean supportsReturnType(MethodParameter returnType) {
	return Observable.class.isAssignableFrom(returnType.getParameterType());
	}
	@Override
	public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer,
	NativeWebRequest webRequest) throws Exception {
	if (returnValue == null) {
	mavContainer.setRequestHandled(true);
	return;
	}
	final Observable<?> observable = Observable.class.cast(returnValue);
	WebAsyncUtils.getAsyncManager(webRequest)
	.startDeferredResultProcessing(new ObservableAdapter<>(observable), mavContainer);
	}
	private static class ObservableAdapter<T> extends DeferredResult<T> {
	public ObservableAdapter(Observable<T> observable) {
	observable.subscribe(this::setResult, this::setErrorResult);
	}
	}
	}

view raw ObservableReturnValueHandler.java hosted with ❤ by GitHub

Incidentally, note the use of the static nested class to avoid any memory leaks. Next this value handler should be registered with Spring. For that we need to have following configuration class in place.

	package com.example.config;
	import java.util.List;
	import org.springframework.context.annotation.ComponentScan;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
	import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
	import com.example.handlers.ObservableReturnValueHandler;
	@Configuration
	@ComponentScan(basePackages = { "com.example.*" })
	public class WebConfig extends WebMvcConfigurerAdapter {
	@Override
	public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
	returnValueHandlers.add(new ObservableReturnValueHandler());
	}
	}

view raw WebConfig.java hosted with ❤ by GitHub

Then we can get back to our Controller or Resource classes and dispense with all the boilerplate code used to subscribe to the Observables and adapt them to DeferredResults. Now our controller classes merely return RxJava Observables. Here’s how it looks in practice. For brevity’s sake, import statements are omitted.

	@RestController
	@RequestMapping("/api/currencyconverter")
	public class CurrencyResource {
	private static final Logger log = LoggerFactory.getLogger(CurrencyConverter.class);
	private final CurrencyConverterService currencyConverterService;
	public CurrencyResource(CurrencyConverterService currencyConverterService) {
	super();
	this.currencyConverterService = currencyConverterService;
	}
	@GetMapping(value = "/rates", produces = { MediaType.APPLICATION_JSON_UTF8_VALUE })
	public Observable<?> getCurrencyRates(@RequestParam("symbol") Set<String> currencyRates) {
	log.debug("Retrieving currency rates.");
	return currencyConverterService.getCurrencyRates(currencyRates);
	}
	}

view raw CurrencyResource.java hosted with ❤ by GitHub

Notice how simple and readable this code is compared to the previous counterpart of our Resource class. You may find the source code of the project here [1].

Conclusion

Well, today we kept a step beyond the previous incarnation of our RxJava spring boot microservice by enhancing it to use a return value handler to adapt RxJava Observables into spring aware DeferedResults. We generalized asynchronous response handling code while making it more simple and readable. When it comes to code, clarity and simplicity are of paramount importance.

References

[Gamma95] https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8
[1] https://github.com/ravindraranwala/SpringBootRxJava