RxJava: Operadores — Parte 1

5 min readMar 30, 2018

Nos dias de hoje, os utilizadores exigem aplicações responsivas, com dados em tempo real e que estejam preparadas para gerir situações de erros.

A Rx (Reactivex) vem com objectivo de fornecer as ferramentas necessárias para que tal comodidade seja fornecida aos nossos utilizadores.

No último artigo, fizemos uma breve introdução ao conceito da programação reactiva e ao RxJava. Se ainda não tiveste a oportunidade de ler, podes fazer aqui.

Este é o segundo artigo da série e vamos conhecer alguns operadores do RxJava. Este artigo será tanto teórico como prático, contudo, peço que te foques apenas em perceber os conceitos que serão aqui introduzidos, eles serão bastante importantes para os próximos artigos. (SIM!!!… teremos código 😁).

Olá RxJava

Como havia explicado no artigo anterior, o RxJava tem dois componentes principais que são: Observable e o Subscriber. Onde, o Observable emite fluxos dados e o Subscriber responde aos dados emitidos, caso esteja subscrito à um Observable.

Basicamente, o Subscriber será notificado assim que o Observable emitir qualquer evento ou dados. No RxJava a lógica é assim tão simples (não tão simples assim 🌚), o Subscriber subscreve à um Observable, o Observable chama o Subscriber.OnNext() para qualquer item/dado, caso algo de errado aconteça o Subscriber.OnError() entra em acção, e para finalizar, o Subscriber.onComplete() é chamado e dá por encerrado o ciclo de vida.

fonte: https://giphy.com/

Requisitos

Podes adicionar o RxJava ao seu projecto através das dependências:

Gradle:

implementation 'io.reactivex.rxjava2:rxjava:x.y.z'

Maven:

<dependency>
    <groupId>io.reactivex.rxjava2</groupId>
    <artifactId>rxjava</artifactId>
    <version>x.y.z</version>
</dependency>

Onde x.y.z representa a versão do RxJava. Até então, a versão mais recente é 2.0.4.

Como criar um Observable?

Podemos criar um Observable de várias maneiras. Uma das formas mais simples de o fazer é a seguinte:

Output:

Hello GDG Maputo

No exemplo acima, nós criamos um Observable que emite uma String (Hello GDG Maputo) e de seguida um assinante recebe essa String e a imprime.

Podemos deixar o código acima um bocado mais interessante usando lambda:

Contudo, dessa forma não temos muito controle dos diferente estados do nosso Observable, não sabemos na verdade o que se está a passar. Para ter mais controle, podemos criar o nosso Observable da seguinte forma:

Output:

Hello GDG Maputo

Terminado

Onde, o método onNext() emite os dados do Observer, neste caso uma String (Hello GDG Maputo), o método onError() dá-nos a notificação de algum erro (não temos nenhum) e por fim o metodo onComplete() é chamando quando nao temos mais nenhum dado a ser emitido.

Se és uma pessoa curiosa, já deves ter-te perguntado: o que faz aquele just do Observable?

Bom, o just é um dos vários operadores do RxJava. Esses operadores são responsáveis por criar, filtrar, combinar e transformar os dados a serem emitidos pelo Observable.

Neste e no próximo artigo irei explicar como funcionam os operadores mais comuns do RxJava. Infelizmente não poderei cobrir todos eles porque realmente são muitos, mas caso tenhas curiosidade de saber mais, aqui vai a lista de todos os operadores RxJava.

Operadores RxJava

Os operadores RxJava estão divididos em várias categorias, existem operadores que:

Criam Observables
Transformam Observables
Fazem filtragem em Observables
Combinam Observables
E muito mais…

Neste artigo irei explicar apenas quatro operadores: dois para a criação de Observables e dois para a transformação de Observables. E no próximo artigo irei explicar mais quatro, dois para filtragem em Observables e dois para combinação de Observables.

Criação de Observable

1. Just()

fonte: http://reactivex.io/documentation/operators/just.html

Este operador faz nada mais e nada menos que emitir o valor recebido como argumento. Por exemplo:

Este Observable irá emitir: 3 6 9

2. From()/FromArray()

fonte: http://reactivex.io/documentation/operators/from.html

Assim como o operador just, este emite o valor recebido como argumento, a diferença é que este recebe um array de objectos e emite cada um sequencialmente. Por Exemplo:

Este Observable irá emitir: a b c

Transformação de Observable

1. Map()

fonte: http://reactivex.io/documentation/operators/map.html

O operador Map() transforma os items emitidos pelo Observable. Por exemplo:

O Map() leva cada item emitido pelo Observable e multiplica-os por 10. Portanto, o output será: 30 60 90

2. FlatMap()

fonte: http://reactivex.io/documentation/operators/flatmap.html

O FlatMap() e o Map() são bastante parecidos, pois ambos realizam transformacoes nos items emitidos pelo Observable. O que difere um do outro é que o Map() apenas emite um valor, enquanto que o FlatMap() emite um ou mais valores. Confuso? Sim, eu sei!

O Map() transforma itens emitidos por um Observable aplicando uma função para cada item enquanto que o FlatMap() :

Aplica uma função específica para cada item emitido e essa função, por sua vez, retorna um Observável para cada item;
FlatMap(), em seguida, junta todas essas sequências para fazer uma nova sequência.

Continua confuso, eu sei. Mas espero ao durante dos próximos artigos essa explicação fique mais clara para ti.

Podemos usar o FlatMap() da seguinte forma:

Output :

HelloGDGMaputo

É isso!

Chegamos ao fim de mais um artigo, espero que tenha sido util para ti. Os operadores RxJava são um bocado complicados de entender assim de primeira, por isso que é importante repetir varias e varias vezes até perceber.

No próximo artigo iremos continuar com os operadores. Veremos os operadores de filtragem e combinação.

Se tiver alguma questão ou sugestão deixe aí nos comentários e não hesite em contactar-me pelo email: edilsonngulele@gmail.com ou twitter: @edilson_ngulele.

Obrigado e até a próxima!