Também será possível conhecer alguns dos principais operadores do RxJava, como combinar Observables, como ter controle sobre os erros e entender o que são Subscriptions.
A partir desse conteúdo o leitor terá uma boa fundamentação para iniciar nesta nova opção que vem ganhando cada vez mais atenção de profissionais que atuam com Java.
A linguagem Java é imperativa e orientada a objetos. Sua versão 8 e a inserção, dentre outros recursos, das expressões lambda e dos streams, trouxe características da programação reativa funcional, abrindo o leque de possibilidades de se programar.
Dentre essas possibilidades, destaca-se a facilidade de se trabalhar e estruturar aplicações de forma menos verbosa e mais eficiente.
Programação reativa pode ser definida como um paradigma de desenvolvimento baseado em fluxos assíncronos de dados e na propagação de mudanças nesse fluxo.
Isso significa que uma determinada fonte de dados dinâmica ou estática é definida e, posteriormente ou mesmo imediatamente, executada propagando seus resultados através de um fluxo de dados e notificando todos os receptores.
Pode-se definir a programação reativa como um paradigma de programação baseado em eventos que podem ser aguardados em diferentes pontos do código servindo como gatilhos para a execução de lógicas específicas.
A programação reativa funcional surgiu como uma ideia no final dos anos 90 e inspirou Erik Meijer, então funcionário da Microsoft, a criar uma forma de se utilizar este paradigma dentro do mundo .NET. Surgiu assim a biblioteca Microsoft Rx (de Reactive eXtension), que permite ao desenvolvedor criar aplicações assíncronas e baseadas em eventos de forma simplificada.
Com a Microsoft Rx, pode-se criar Observables, realizar queries utilizando LINQ e gerenciar a concorrência facilmente com Schedulers.
Esta abordagem modifica a forma síncrona utilizada para a programação que visa o resultado através de chamadas a métodos e seu retorno. De maneira diferente, utilizando-se a Microsoft Rx, ao solicitar determinado recurso, assim que este estiver pronto, o objeto solicitante é notificado.
Em 2012, a Netflix constatou a necessidade de melhorias em seu sistema, o qual apresentava problemas de escalabilidade, devido à enorme expansão do serviço. A Netflix então optou por refazer a arquitetura do sistema, visando reduzir a quantidade de chamadas REST realizadas. Assim, em vez de realizar várias chamadas, seria preciso apenas uma, baseada na necessidade do cliente, o que possibilita a melhora do desempenho do sistema.
Para atingir este objetivo foi adotado o paradigma reativo e foi feita a portabilidade do sistema de Reactive Extensions da Microsoft para a Java Virtual Machine.
Nesse processo de troca de paradigmas, optou-se por focar não na linguagem Java, mas na JVM, buscando desenvolver uma ferramenta para possibilitar a programação reativa que pudesse ser utilizada por qualquer linguagem baseada na mesma JVM, como Scala, Groovy e, claro, Java.
Em fevereiro de 2013, Ben Christensen e Jafar Husain, engenheiros da Netflix, mostraram a biblioteca RxJava ao mundo em um post publicado no blog técnico da empresa (veja a seção Links).
Desde então, a RxJava vem recebendo muita atenção e sendo mantida pela comunidade de forma efetiva. Inclusive, após algum tempo de desenvolvimento, foi criada uma organização para manter os diversos ports das RXs para as mais diversas plataformas e linguagens, hoje mantida sobre o nome de Reactive Extensions (veja a seção Links).
A RxJava possui características interessantes como facilidade de controlar concorrência, de forma a melhorar o uso do poder de processamento dos seus servidores; facilidade na execução condicional de tarefas assíncronas; melhoria quanto a evitar o problema de uso de vários callbacks (evitar o uso excessivo do padrão Observer) e abordagem reativa.
Principais componentes da RxJava
Para fazer um bom uso da biblioteca RxJava, é necessário entender o que são e quais os papéis dos principais componentes que a compõem. Nesta seção, vamos conhecer os Observables, produtores de dados, e os Observers e Subjects, que possuem o papel de consumir e responder a esses dados.
Observable
Vamos imaginar o seguinte cenário: quando precisamos executar alguma tarefa assíncrona no Java, de baixa complexidade, quais saídas temos? Podemos utilizar Threads, Future ou algo do tipo. Porém, quando o nível de complexidade da tarefa aumenta, essas saídas tendem a se tornar complexas, confusas e difíceis de gerenciar.
Os Observables do RxJava foram projetados para suprir essa demanda. Algumas das suas principais características são flexibilidade e facilidade de uso, podendo ser encadeados, trabalhar com dados isolados ou com sequências de dados. Tanto para os casos onde a necessidade é de se emitir um valor isoladamente, quanto para uma série ou mesmo para um fluxo infinito de valores, o Observable pode ser utilizado.
O ciclo de vida de um Observable é composto de três eventos:
1. onNext(): disparado para notificar o Observer sobre um novo dado no fluxo do Observable;
2. onCompleted(): disparado para notificar o Observer de que não há mais dados a serem enviados do Observable;
3. onError(): disparado para notificar o Observer de que um erro ocorreu.
Para melhor entendimento do Observable, podemos dizer que ele é um tipo de Iterator assíncrono. Neste contexto, o método onNext() poderia ser o método next() do Iterator, enquanto o onCompleted() seria análogo ao !hasNext() e o onError() corresponderia ao caso onde o Iterator lança uma exceção, indicando que o fluxo foi interrompido e não há novos dados.
Do ponto de vista da emissão de dados, os Observables podem ser de dois tipos diferentes, “quentes” ou “frios”. Os Observables “quentes” (ou hot), são aqueles que começam o fluxo de emissão de itens imediatamente após serem criados.
Desta forma, qualquer Observer que comece a observar este Observable pode começar a receber dados desse fluxo a partir de qualquer ponto. Em contrapartida, os Observables “frios” (ou cold) aguardam até que haja uma assinatura, através do método subscribe(), para que ele comece a produzir seu fluxo de dados.
Observers e Subjects
No RxJava, um Observer se inscreve através do método subscribe() para receber eventos de um Observable. A partir desta inscrição, o Observer reage a qualquer item ou sequência de itens emitida pelo Observable.
No contexto do RxJava, o Observer é uma interface que pode ser implementada por qualquer classe que precise receber eventos de um Observable.
Um Subject é um objeto coringa dentro da API do RxJava, já que pode ser um Observable e um Observer ao mesmo tempo. O Subject age como uma espécie de funil, podendo se inscrever em um Observable, agindo dessa forma como um Observer e, ao mesmo tempo, pode emitir novos itens ou simplesmente emitir os itens recebidos do Observable. Sendo também um Observable, outros Observers podem se inscrever para receber seus elementos.
Integrando a RxJava
Podemos facilmente integrar o RxJava, atualmente na versão 1.0.14, ao nosso projeto. Utilizando-se o Maven para gerenciar nossas dependências, basta modificar o arquivo pom.xml, conforme có ...
