git.gumartinm.name Git - JavaForFun/blob

   1 package de.spring.webservices.rest.controller.adapters;
   2
   3 import org.slf4j.Logger;
   4 import org.slf4j.LoggerFactory;
   5 import org.springframework.web.context.request.async.DeferredResult;
   6
   7 import rx.Observable;
   8 import rx.Single;
   9
  10 /**
  11  *
  12  * Instead of using this class, you could create you own implementation of
  13  * org.springframework.web.servlet.mvc.method.annotation.DeferredResultAdapter
  14  * for Observable and Single.
  15  *
  16  * spring netflix is already doing this stuff for me.
  17  *
  18  */
  19 public class RxJavaAdapter {
  20         private static final Logger LOGGER = LoggerFactory.getLogger(RxJavaAdapter.class);
  21
  22         // With no value, we depend on the Tomcat/Jboss/Jetty/etc timeout value for asynchronous requests.
  23         // Spring will answer after 60 secs with an empty response (by default) and HTTP 503 status (by default) when timeout.
  24
  25         // You'd rather better rely on the server values. IMHO this is something to be controlled
  26         // by the server administrator no the developer.
  27         // private static final long ASYNC_TIMEOUT = 60000;  /* milliseconds */
  28
  29         private RxJavaAdapter() {
  30
  31         }
  32
  33         public static final <T> DeferredResult<T> deferredAdapter(Observable<T> observable) {
  34
  35         DeferredResult<T> deferredResult = new DeferredResult<>(/** ASYNC_TIMEOUT **/);
  36
  37         observable
  38                 .subscribe(deferredResult::setResult, exception -> {
  39                         Throwable realException = launderException(exception);
  40
  41                         LOGGER.error("error: ", realException);
  42
  43                         deferredResult.setErrorResult(realException);
  44                         });
  45
  46         return deferredResult;
  47         }
  48
  49         public static final <T> DeferredResult<T> deferredAdapter(Single<T> single) {
  50
  51         DeferredResult<T> deferredResult = new DeferredResult<>(/** ASYNC_TIMEOUT **/);
  52
  53         single
  54                 .subscribe(deferredResult::setResult, exception -> {
  55                                 Throwable realException = launderException(exception);
  56
  57                                 LOGGER.error("error: ", realException);
  58
  59                         deferredResult.setErrorResult(realException);
  60                 });
  61
  62         return deferredResult;
  63         }
  64
  65         private static final Throwable launderException(Throwable exception) {
  66                 return exception.getCause() != null
  67                            ? exception.getCause()
  68                            : exception;
  69         }
  70 }