Neste artigo vou explicar o básico de RxJava através de exemplos. Este artigo é para iniciantes em RxJava. Por outro lado, se você já sabe algo sobre RxJava, este artigo é bom para rever seus conhecimentos.
RxJava é uma implementação Java VM de ReactiveX uma biblioteca para compor programas assíncronos e baseados em eventos usando sequências observáveis.
Os blocos de construção de RxJava são Observables e Subscribers. Observable é usado para emitir itens e Subscriber é usado para consumir esses itens. Talvez alguns de vocês pensem: “Hmmm isto é tão similar ao padrão Observável”. E sim é, mas RxJava faz isso muito melhor e tem mais opções. Por exemplo, os Observables frequentemente não começam a emitir itens até que alguém os subscreva. Esta é uma ótima funcionalidade porque desta forma você deve salvar suas performances.
RxJava funciona desta forma. Assinante assina Observable, então Observable chama Subscriber.onNext() para qualquer número de itens, se algo der errado aqui é Subsciber.onError() e se tudo terminar bem, aqui é Subscriber.onCompleted(). Você vê que isso é fácil!
Cala a boca! Dá-me alguns códigos chiques!
Exemplo 1
Neste exemplo vamos criar Observável e Assinante básicos, e depois vamos ligá-los, e ver o que vai acontecer. Alerta de Spoiler! Algo impressionante…
Vamos criar um Observável básico:
O Observável criado emite a String “Blue Factory” e depois completa. “Blue Factory” String será recebido no método Subscribers onNext(). Agora vamos criar o método Subscriber.
Subscriber recebe o valor String no método onNext() e imprime-o, também o método String “I’m done” imprime quando os métodos onCompleted() são chamados.
Agora ligue-os.
Resultado:
I/System.out: Blue Factory:
I/System.out: Estou feito
Quando a assinatura acontece, myObservable chama os métodos mySubscription onNext() e onComplited(). Os resultados são outputs “Blue factory” e “I’m done”, depois disso tudo pára e termina.
Posso fazer mais simples?
Of course! Você pode fazer isso!
Você pode notar que uma criação do myObservable tem muito código e parece confuso. RxJava nos dá alguns atalhos extravagantes.
Alguns desses atalhos são métodos como Observable.just() e Observable.from();
Observable.just() emite apenas um único item e Observable.from() emite um item por um da lista de itens.
Cala a boca! Dá-me algum código chique!
Exemplo 2
Neste exemplo vamos fazer a mesma coisa como no Exemplo 1, mas agora com menos código.
Vamos criar a nossa nova fantasia, observável com bom aspecto:
Wow! Parece que o nosso Observável perdeu algum peso!
Vamos criar Assinante:
Subscritor é o mesmo!
Agora ligue-os, e espere que a magia aconteça!
Resultado:
I/System.out: Blue Factory
I/System.out: Estou feito
Como você vê, nós conseguimos completar nossa tarefa, e fazemos exatamente a mesma coisa com menos código.
Cala-te! Dê-me algum código chique!
Exemplo 3
Neste exemplo vamos fazer algo um pouco diferente com o Observable.from(). A idéia é imprimir strings “Blue”, “Factory”, “Blog”, “Post”.
Lembramos o que é Observable.from(). Observable.from() recebe lista de itens e emite item por item, então Observable.from() é exatamente o que precisamos!
Primeiro vamos criar ArrayList com Strings:
Vamos criar esse Observable.from().de(), devemos?
Como pode ver, Observable.from() recebe como argumento a ArrayList carregada com Strings. Agora, vamos criar Assinante e ligá-los, e esperar pela magia.
Resultado:
I/System.out: Azul:
I/System.out: Factory
I/System.out: Blog
I/System.out: Post
Como você vê, nós fizemos nossa tarefa novamente com sucesso!
Tudo o que você aprendeu até agora são puros truques básicos, mas agora vamos fazer alguns truques “mais difíceis”!
O que são Operadores em Rx?
Operadores são métodos criados para resolver transformações e lidar com problemas de chamadas API. Eu vou mostrar um exemplo simples de transformação com Map, e talvez em alguns outros artigos exemplos de como lidar com chamadas API com Retrofit, RxJava no padrão arquitetônico MVP.
Por exemplo vamos anexar nossa String “Blue Factory” com ” Blog Post”. Podemos fazê-lo de várias maneiras.
Primeira maneira:
Podemos fazê-lo em Observable, mas Observable é suposto emitir itens, não alterá-los.
Segundo modo:
A mesma história, Assinante não era suposto alterar itens.
A solução é adicionar mais um passo, adicionando Operador. Operador é um passo adicional entre Observável e Assinante, onde o objeto pode ser transformado.
Então vamos fazer da maneira certa!
Calar a boca! Dê-me algum código chique!
Exemplo 4
Primeiro vamos criar o Observável:
Nota que o myObservable emite apenas um item inalterado.
Agora vamos criar o Operador, pois este exemplo a melhor solução é usar o Operador de Mapa. O operador do Mapa pode transformar nosso objeto de uma maneira que gostamos e devolvê-lo ao Assinante.
No método de chamada de operadores (String s) a transformação do método String “Blue Factory” é feita.
E aqui é Assinante:
Resultado:
I/System.out: Blue Factory Blog Post:
Este exemplo representa uma pequena fração do que os Operadores podem fazer. Por exemplo, o operador do mapa pode ser empilhado várias vezes como no exemplo abaixo:
Calar a boca! Dê-me algum código chique!
Exemplo 5
Os Operadores também podem mudar o tipo de item emitido como no exemplo abaixo:
Calar a boca! Dê-me algum código chique!
Exemplo 6
Neste exemplo o Observable emitirá String “5” e o Operador irá transformá-lo para o Inteiro 5. Vamos engradar Observável.
Nota que o tipo myObservable é Observável e o Observável emite String.
Criemos o operador do Mapa!
Notificar que o operador do Mapa chama o método String (String s) e retorna o Integer.
Vamos o assinante da caixa e ligá-los.
O tipo de subscritor é o mesmo tipo Observável, e o tipo Operadores que retornam (Integer).
Aqui eu mostro apenas uma pequena fração da imagem. Com os operadores você pode fazer tudo o que você quiser! E a melhor parte disto é que o RxJava tem abundância de Operadores diferentes. Aqui você pode verificar todos os operadores: https://github.com/ReactiveX/RxJava/wiki/Alphabetical-List-of-Observable-Operators.
Em conclusão os operadores são poderosos para transformação de objectos e polimento de dados, e depois de tudo isto, o seu código vai ficar bonito e limpo!
O que posso fazer com o RXJava?
Pode fazer tudo o que quiser porque o seu Observável pode ser tudo, pode ser: String, Integer, chamada API, clique, etc. À medida que você avança como desenvolvedor Android você vai usar RxJava principalmente para chamadas de API e para widgets andróide. O RxJava oferece fácil manuseio de API, porque você não precisa se preocupar com threading e você pode encadear poucas solicitações e obter resultado em um único Assinante. Com o RxJava você pode lidar com algum comportamento de widget, por exemplo, o que o widget fará após cinco vezes ser pressionado, ou você pode criar o Observable que emitirá String a cada 4 segundos a partir da entrada do EditText, e tantas outras coisas extravagantes. Espero que este artigo lhe dê o básico do RxJava e espero que você continue explorando o RxJava no futuro.