RxJava para Java: guia completo de programação reativa

1. O que é e para que serve

RxJava é uma biblioteca para programação reativa em Java, que implementa os conceitos de Observable (observável) e Observer (observador). Ela permite processar fluxos de dados assíncronos e eventos usando operadores combináveis (composable). Diferente de callbacks tradicionais ou Future/Promise, o RxJava oferece um conjunto poderoso de ferramentas para transformar, filtrar e combinar fluxos de dados, tornando o código mais legível, previsível e menos propenso a erros relacionados a concorrência.

Para que serve o RxJava? No desenvolvimento moderno de aplicações Java (especialmente Android, aplicações server-side com Spring WebFlux, microsserviços), surgem constantemente desafios relacionados à assincronicidade: carregar dados da rede, trabalhar com bancos de dados, processar eventos do usuário. O RxJava resolve esses problemas fornecendo uma API unificada para trabalhar com qualquer tipo de sequência assíncrona. Ele ajuda a evitar o "callback hell" (inferno de callbacks), simplifica o tratamento de erros em cadeias assíncronas e oferece ferramentas poderosas para gerenciamento de threads (Schedulers).

Principais vantagens do RxJava: declaratividade (você descreve o que precisa ser feito, não como), combinabilidade (operadores se combinam facilmente), suporte a backpressure (contrapressão) para controlar a velocidade de consumo de dados e um ecossistema rico (RxAndroid, RxJava2Extensions, RxRelay). A biblioteca é ativamente mantida e amplamente utilizada na indústria, especialmente no desenvolvimento Android (Retrofit + RxJava, Room + RxJava).

2. Instalação

O RxJava é distribuído via Maven Central. Para adicioná-lo ao seu projeto, inclua a dependência no arquivo build.gradle (para Gradle) ou pom.xml (para Maven).

Gradle (projeto Android / Java)

dependencies {
    implementation 'io.reactivex.rxjava3:rxjava:3.1.8'
}

Maven

<dependency>
    <groupId>io.reactivex.rxjava3</groupId>
    <artifactId>rxjava</artifactId>
    <version>3.1.8</version>
</dependency>

Para projetos Android, é comum adicionar também o RxAndroid para trabalhar com a thread principal:

implementation 'io.reactivex.rxjava3:rxandroid:3.0.2'

3. Início rápido — exemplo mínimo funcional

Vamos criar um Observable simples que emite as strings "Olá" e "Mundo", e nos inscrever nele:

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.Observer;
import io.reactivex.rxjava3.disposables.Disposable;

public class RxJavaQuickStart {
    public static void main(String[] args) {
        // Cria um Observable que emite dois elementos
        Observable<String> observable = Observable.just("Olá", "Mundo");

        // Cria um Observer
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("Inscrição realizada");
            }

            @Override
            public void onNext(String s) {
                System.out.println("Recebido: " + s);
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Erro: " + e.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("Fluxo concluído");
            }
        };

        // Inscreve-se
        observable.subscribe(observer);
    }
}

Saída:

Inscrição realizada
Recebido: Olá
Recebido: Mundo
Fluxo concluído

4. Principais métodos/classes

4.1 Observable.just()

Assinatura: public