RxJava para Java: guía completa de programación reactiva

1. ¿Qué es y para qué sirve?

RxJava es una biblioteca de programación reactiva para Java que implementa el patrón Observable (observable) y Observer (observador). Permite manejar flujos de datos asíncronos y eventos mediante operadores componibles (composable). A diferencia de los callbacks tradicionales o Future/Promise, RxJava ofrece un potente conjunto de herramientas para transformar, filtrar y combinar flujos de datos, haciendo que el código sea más legible, predecible y menos propenso a errores relacionados con la concurrencia.

¿Para qué sirve RxJava? En el desarrollo moderno de aplicaciones Java (especialmente Android, aplicaciones de servidor con Spring WebFlux, microservicios), surgen constantemente tareas asíncronas: carga de datos desde la red, trabajo con bases de datos, procesamiento de eventos de usuario. RxJava resuelve estos problemas proporcionando una API unificada para trabajar con cualquier tipo de secuencia asíncrona. Evita el "callback hell" (infierno de callbacks), simplifica el manejo de errores en cadenas asíncronas y ofrece potentes herramientas para la gestión de hilos (Schedulers).

Principales ventajas de RxJava: declaratividad (describes qué hacer, no cómo), componibilidad (los operadores se combinan fácilmente), soporte de contrapresión (backpressure) para controlar la velocidad de consumo de datos, y un ecosistema rico (RxAndroid, RxJava2Extensions, RxRelay). La biblioteca tiene mantenimiento activo y se usa ampliamente en la industria, especialmente en desarrollo Android (Retrofit + RxJava, Room + RxJava).

2. Instalación

RxJava se distribuye a través de Maven Central. Para agregarlo a tu proyecto, añade la dependencia en tu archivo build.gradle (para Gradle) o pom.xml (para Maven).

Gradle (proyecto 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 proyectos Android, a menudo se agrega también RxAndroid para trabajar con el hilo principal:

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

3. Inicio rápido — ejemplo mínimo funcional

Creemos un Observable simple que genera las cadenas "Hola" y "Mundo", y suscribámonos a él:

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

public class RxJavaInicioRapido {
    public static void main(String[] args) {
        // Creamos un Observable que emite dos elementos
        Observable<String> observable = Observable.just("Hola", "Mundo");

        // Creamos un Observer
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("Suscripción establecida");
            }

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

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

            @Override
            public void onComplete() {
                System.out.println("Flujo completado");
            }
        };

        // Nos suscribimos
        observable.subscribe(observer);
    }
}

Salida:

Suscripción establecida
Recibido: Hola
Recibido: Mundo
Flujo completado

4. Métodos y clases principales

4.1 Observable.just()

Firma: public