Spring WebFlux reactivo

Spring WebFlux representa la evolución natural del desarrollo de aplicaciones web en el ecosistema Spring, introduciendo un paradigma completamente nuevo basado en programación reactiva.

Esta tecnología surge como respuesta a las limitaciones del modelo tradicional de programación imperativa, especialmente cuando se trata de manejar grandes volúmenes de peticiones concurrentes y operaciones de entrada/salida intensivas.

Fundamentos de la programación reactiva

La programación reactiva se basa en el concepto de flujos de datos asincrónicos y la propagación de cambios. A diferencia del modelo tradicional donde el código se ejecuta de forma secuencial y bloqueante, el paradigma reactivo permite que las operaciones se ejecuten de manera no bloqueante, liberando recursos del sistema para atender otras peticiones mientras se esperan respuestas de operaciones lentas como consultas a bases de datos o llamadas a servicios externos.

Spring WebFlux implementa la especificación Reactive Streams, que define un estándar para el procesamiento asíncrono de flujos de datos con contrapresión (backpressure). Esta característica permite que los consumidores controlen la velocidad a la que reciben datos, evitando problemas de memoria y garantizando un comportamiento predecible del sistema bajo carga.

// Ejemplo básico de flujo reactivo
Flux<String> nombres = Flux.just("Ana", "Carlos", "María")
    .map(String::toUpperCase)
    .filter(nombre -> nombre.length() > 3);

nombres.subscribe(System.out::println);

Arquitectura y componentes principales

Spring WebFlux se construye sobre Project Reactor, la implementación de referencia de Reactive Streams para la JVM. Los tipos fundamentales son Mono y Flux, que representan flujos de 0-1 y 0-N elementos respectivamente. Estos tipos proporcionan una API rica para transformar, combinar y procesar datos de forma asíncrona.

La arquitectura de WebFlux soporta dos modelos de programación distintos. El modelo basado en anotaciones mantiene la familiaridad con Spring MVC, permitiendo a los desarrolladores utilizar anotaciones como @RestController y @RequestMapping mientras aprovechan las capacidades reactivas. El modelo funcional ofrece un enfoque más declarativo utilizando funciones lambda y un DSL específico para definir rutas y manejadores.

// Modelo basado en anotaciones
@RestController
public class UsuarioController {
    
    @GetMapping("/usuarios")
    public Flux<Usuario> obtenerUsuarios() {
        return usuarioService.findAll();
    }
    
    @GetMapping("/usuarios/{id}")
    public Mono<Usuario> obtenerUsuario(@PathVariable String id) {
        return usuarioService.findById(id);
    }
}

Integración con bases de datos reactivas

La persistencia de datos en aplicaciones reactivas requiere un enfoque diferente al tradicional. Spring Data R2DBC (Reactive Relational Database Connectivity) proporciona acceso no bloqueante a bases de datos relacionales, manteniendo la naturaleza asíncrona de toda la cadena de procesamiento. R2DBC utiliza un protocolo completamente nuevo que permite operaciones de base de datos verdaderamente asíncronas.

Los repositorios reactivos extienden las interfaces ReactiveCrudRepository o ReactiveRepository, devolviendo tipos Mono y Flux en lugar de objetos o colecciones tradicionales. Esta integración permite que las consultas a la base de datos se ejecuten de forma no bloqueante, liberando hilos para atender otras peticiones.

public interface UsuarioRepository extends ReactiveCrudRepository<Usuario, String> {
    
    Flux<Usuario> findByNombreContaining(String nombre);
    
    Mono<Usuario> findByEmail(String email);
    
    @Query("SELECT * FROM usuarios WHERE activo = true")
    Flux<Usuario> findUsuariosActivos();
}

Operadores y transformaciones de flujos

Los operadores reactivos constituyen el corazón de la programación con WebFlux. Estos operadores permiten transformar, filtrar, combinar y procesar flujos de datos de manera declarativa. Los operadores básicos como map, filter, flatMap y merge proporcionan las herramientas fundamentales para manipular datos, mientras que operadores más avanzados como window, buffer, retry y timeout ofrecen capacidades sofisticadas para casos de uso complejos.

La composición de operadores permite crear pipelines de procesamiento complejos de forma legible y mantenible. Cada operador devuelve un nuevo flujo, permitiendo el encadenamiento de operaciones sin efectos secundarios.

// Pipeline de procesamiento complejo
Flux<PedidoDTO> procesarPedidos = pedidoRepository.findAll()
    .filter(pedido -> pedido.getEstado() == Estado.PENDIENTE)
    .flatMap(this::validarPedido)
    .map(this::convertirADTO)
    .onErrorContinue((error, pedido) -> 
        log.error("Error procesando pedido: {}", pedido, error))
    .delayElements(Duration.ofMillis(100));

Cliente HTTP reactivo

WebClient representa el cliente HTTP reactivo de Spring, diseñado para reemplazar RestTemplate en aplicaciones reactivas. WebClient mantiene la naturaleza no bloqueante de las operaciones, permitiendo realizar múltiples llamadas HTTP concurrentes sin bloquear hilos. Su API fluida facilita la configuración de peticiones complejas, manejo de errores y transformación de respuestas.

La integración con el ecosistema reactivo permite combinar múltiples llamadas a servicios externos de forma eficiente, utilizando operadores como zip, merge o flatMap para coordinar operaciones asíncronas.

WebClient client = WebClient.builder()
    .baseUrl("https://api.ejemplo.com")
    .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
    .build();

Mono<Usuario> usuario = client.get()
    .uri("/usuarios/{id}", userId)
    .retrieve()
    .bodyToMono(Usuario.class)
    .timeout(Duration.ofSeconds(5))
    .retry(3);