RxJava (2.x)

RxJava é a implementação Java do Reactive Extensions, uma poderosa API para programação reativa.

O java-restify fornece suporte para as versões 1.x e 2.x do RxJava, e os principais objetos podem ser utilizados como retorno de método.

Instalação

O suporte para o RxJava 2.x está na dependência java-restify-rxjava-2. Uma vez presente no classpath, os handlers serão automaticamente registrados.

Maven

<dependency>
  <groupId>com.github.ljtfreitas</groupId>
  <artifactId>java-restify-rxjava-2</artifactId>
  <version>{version}</version>
</dependency>

Gradle

dependencies {
  compile("com.github.ljtfreitas:java-restify-rxjava-2:{version}")
}

Utilização

Tipos suportados

• Observable

Observable é um objeto reativo que representa a emissão de uma sequência de valores.

Ao utilizar o Observable como retorno de método, o java-restify irá assumir que a resposta da requisição representa uma coleção.

Por exemplo, digamos que o endpoint a ser consumido retorne um JSON; se a resposta for um array (uma coleção), você pode utilizar o Observable; se a resposta for um único objeto, utilize um Single ou um Maybe (ver abaixo).

import io.reactivex;

public interface MyApi {

    @Path("/customers") @Get
    Observable<Customer> getAllCustomers();
}

• Flowable

Flowable é um novo objeto reativo introduzido na versão 2.x do RxJava, que implementa a interface Publisher, da especificação Reactive Streams. Assim como o Observable, o Flowable representa a emissão de uma sequência de valores com suporte a back-pressure.

Ao utilizar o Flowable como retorno de método, o java-restify irá assumir que a resposta da requisição representa uma coleção.

import io.reactivex.Flowable;

public interface MyApi {

    @Path("/customers") @Get
    Flowable<Customer> getAllCustomers();
}

• Single

Single é um objeto reativo que representa a emissão de um único valor.

O Single é um tipo de retorno adequado caso a resposta da requisição represente um único objeto (assim como o Observable ou Flowable são mais adequados para uma sequência/coleção de objetos); outra possibilidade para esse cenário é o Maybe (detalhado mais abaixo).

import io.reactivex.Single;

public interface MyApi {

    @Path("/customers/{id}") @Get
    Single<Customer> getCustomerById(@PathParameter String id);
}

• Maybe

Maybe é um objeto reativo que representa a emissão de um único valor ou nenhum valor.

O Maybe é um tipo de retorno adequado caso a resposta da requisição represente um único objeto; uma diferença em relação ao Single é o fato do Maybe permitir valores nulos (por exemplo, uma resposta vazia).

import io.reactivex.Maybe;

public interface MyApi {

    @Path("/customers/{id}") @Get
    Maybe<Customer> getCustomerById(@PathParameter String id);
}

• Completable

Completable é um objeto reativo que não emite valores, podendo apenas ser completado sem erros ou emitir um erro.

O uso desse objeto como retorno de método é adequado quando não é necessário obter o corpo da resposta, mas o seu código deve reagir quando a requisição for concluída sem erros ou em caso de problemas.

import rx.Completable;

public interface MyApi {

    @Path("/customers") @Post
    Completable createCustomer(@BodyParameter Customer customer);
}

Configuração

Em todos os casos acima, o java-restify irá executar a requisição em uma thread separada usando o suporte do RxJava para processamento assíncrono, através do objeto Scheduler.

Por padrão, o Scheduler será criado a partir do método Schedulers.io, que é o mais adequado para requisições HTTP.

Caso essa configuração não atenda às necessidades da sua aplicação, desligue a descoberta automática de handlers e registre-os manualmente:

import io.reactivex.Scheduler;
import io.reactivex.schedulers.Schedulers;
import com.github.ljtfreitas.restify.http.client.call.handler.rxjava2.RxJava2CompletableEndpointCallHandlerFactory;
import com.github.ljtfreitas.restify.http.client.call.handler.rxjava2.RxJava2FlowableEndpointCallHandlerAdapter;
import com.github.ljtfreitas.restify.http.client.call.handler.rxjava2.RxJava2MaybeEndpointCallHandlerAdapter;
import com.github.ljtfreitas.restify.http.client.call.handler.rxjava2.RxJava2ObservableEndpointCallHandlerAdapter;
import com.github.ljtfreitas.restify.http.client.call.handler.rxjava2.RxJava2SingleEndpointCallHandlerAdapter;

Scheduler myScheduler = Schedulers.from(Executors.newFixedThreadPool(10));

MyApi myApi = new RestifyProxyBuilder()
  .handlers()
    .discovery()
        .disabled()
    .add(new RxJava2CompletableEndpointCallHandlerFactory(myScheduler))
    .add(new RxJava2FlowableEndpointCallHandlerAdapter<>(myScheduler))
    .add(new RxJava2MaybeEndpointCallHandlerAdapter<>(myScheduler))
    .add(new RxJava2ObservableEndpointCallHandlerAdapter<>(myScheduler))
    .add(new RxJava2SingleEndpointCallHandlerAdapter<>(myScheduler))
    .and()
  .target(MyApi.class)
    .build();