org.jooby.rx

Class Rx

java.lang.Object

org.jooby.exec.Exec

org.jooby.rx.Rx

All Implemented Interfaces:

org.jooby.Jooby.Module

public class Rx
extends Exec

rxjava

Reactive programming via RxJava library.

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.

exports

• Route mapper that converts Observable (and family) into Deferred API.
• manage the lifecycle of schedulers and make sure they go down on application shutdown time.

usage

 ...
 import org.jooby.rx.Rx;
 ...

 {
   use(new Rx());

   get("/", req -> Observable.from("reactive programming in jooby!"));
 }
 

how it works?

Previous example is translated to:

 {
   use(new Rx());

   get("/", req -> {

    return new Deferred(deferred -> {
      Observable.from("reactive programming in jooby!")
        .subscribe(deferred::resolve, deferred::reject);
    });

   });
 }
 

Translation is done via rx() route mapper. If you are a rxjava programmer then you don't need to worry for learning a new API and semantic. The rx() route mapper deal and take cares of the Deferred API.

rx mapper

Advanced observable configuration is allowed via function adapter:

 ...
 import org.jooby.rx.Rx;
 ...

 {
   use(new Rx()
     .withObservable(observable -> observable.observeOn(Scheduler.io()),
     .withSingle(single -> single.observeOn(Scheduler.io()),
     .withCompletable(completable -> completable.observeOn(Scheduler.io()));

   get("/observable", req -> Observable...);

   get("/single", req -> Single...);

   ....

   get("/completable", req -> Completable...);

 }
 

Here every Observable/Single/Completable from a route handler will observe on the io scheduler.

schedulers

This module provides the default Scheduler from rxjava. But also let you define your own scheduler using the Exec module.

 rx.schedulers.io = forkjoin
 rx.schedulers.computation = fixed
 rx.schedulers.newThread = "fixed = 10"
 

The previous example defines a:

• forkjoin pool for Schedulers.io()
• fixed thread pool equals to the number of available processors for Schedulers.computation()
• fixed thread pool with a max of 10 for Schedulers.newThread()

Of course, you can define/override all, some or none of them. In any case the Scheduler will be shutdown at application shutdown time.

Since:

1.0.0.CR3

Author:

edgar

Constructor Summary

Constructors

Constructor and Description
Rx() Creates a new Rx module.

Method Summary

Modifier and Type	Method and Description
com.typesafe.config.Config	config()
void	configure(org.jooby.Env env, com.typesafe.config.Config conf, com.google.inject.Binder binder)
static org.jooby.Route.Mapper<Object>	rx() Map a rx object like Observable, Single or Completable into a Deferred object.
static org.jooby.Route.Mapper<Object>	rx(Function<rx.Observable,rx.Observable> observable, Function<rx.Single,rx.Single> single) Map a rx object like Observable, Single or Completable into a Deferred object.
static org.jooby.Route.Mapper<Object>	rx(Function<rx.Observable,rx.Observable> observable, Function<rx.Single,rx.Single> single, Function<rx.Completable,rx.Completable> completable) Map a rx object like Observable, Single or Completable into a Deferred object.
Rx	withCompletable(Function<rx.Completable,rx.Completable> adapter) Apply the given function adapter to completable returned by routes:
Rx	withObservable(Function<rx.Observable,rx.Observable> adapter) Apply the given function adapter to observables returned by routes:
Rx	withSingle(Function<rx.Single,rx.Single> adapter) Apply the given function adapter to single returned by routes:

Methods inherited from class org.jooby.exec.Exec

daemon, priority

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Rx

public Rx()

Creates a new Rx module.

Method Detail

rx

public static org.jooby.Route.Mapper<Object> rx()

Map a rx object like Observable, Single or Completable into a Deferred object.

 ...
 import org.jooby.rx.Rx;
 ...

 {
   with(() -> {
     get("/1", req -> Observable...);

     get("/2", req -> Single...);

     ....

     get("/N", req -> Completable...);

   }).map(Rx.rx());
 }
 

Returns:

A new mapper.

rx

public static org.jooby.Route.Mapper<Object> rx(Function<rx.Observable,rx.Observable> observable,
                                                Function<rx.Single,rx.Single> single)

Map a rx object like Observable, Single or Completable into a Deferred object.

 ...
 import org.jooby.rx.Rx;
 ...

 {
   use(new Rx());

   with(() -> {
     get("/1", req -> Observable...);

     get("/2", req -> Observable...);

     ....

     get("/N", req -> Observable...);

   }).map(Rx.rx(
       observable -> observable.observeOn(Scheduler.io()),
       single -> single.observeOn(Scheduler.io()),
       completable -> completable.observeOn(Scheduler.io())));
 }
 

Parameters:

observable - Observable adapter.

single - Single adapter.

Returns:

A new mapper.

rx

public static org.jooby.Route.Mapper<Object> rx(Function<rx.Observable,rx.Observable> observable,
                                                Function<rx.Single,rx.Single> single,
                                                Function<rx.Completable,rx.Completable> completable)

Map a rx object like Observable, Single or Completable into a Deferred object.

 ...
 import org.jooby.rx.Rx;
 ...

 {
   use(new Rx());

   with(() -> {
     get("/1", req -> Observable...);

     get("/2", req -> Observable...);

     ....

     get("/N", req -> Observable...);

   }).map(Rx.rx(
       observable -> observable.observeOn(Scheduler.io()),
       single -> single.observeOn(Scheduler.io()),
       completable -> completable.observeOn(Scheduler.io())));
 }
 

Parameters:

observable - Observable adapter.

single - Single adapter.

completable - Completable adapter.

Returns:

A new mapper.

withObservable

public Rx withObservable(Function<rx.Observable,rx.Observable> adapter)

Apply the given function adapter to observables returned by routes:

 {
   use(new Rx().withObservable(observable -> observable.observeOn(Schedulers.io())));

   get("observable", -> {
     return Observable...
   });
 }
 

Parameters:

adapter - Observable adapter.

Returns:

This module.

withSingle

public Rx withSingle(Function<rx.Single,rx.Single> adapter)

Apply the given function adapter to single returned by routes:

 {
   use(new Rx().withSingle(observable -> observable.observeOn(Schedulers.io())));

   get("single", -> {
     return Single...
   });
 }
 

Parameters:

adapter - Single adapter.

Returns:

This module.

withCompletable

public Rx withCompletable(Function<rx.Completable,rx.Completable> adapter)

Apply the given function adapter to completable returned by routes:

 {
   use(new Rx().withObservable(observable -> observable.observeOn(Schedulers.io())));

   get("completable", -> {
     return Completable...
   });
 }
 

Parameters:

adapter - Completable adapter.

Returns:

This module.

configure

public void configure(org.jooby.Env env,
                      com.typesafe.config.Config conf,
                      com.google.inject.Binder binder)

Specified by:

configure in interface org.jooby.Jooby.Module

Overrides:

configure in class Exec

config

public com.typesafe.config.Config config()

Specified by:

config in interface org.jooby.Jooby.Module

Overrides:

config in class Exec