Conceptos básicos de Mono y Flux

Reactive programming is about building non-blocking, asynchronous applications that handle streams of data.

Instead of returning a value directly, a reactive method returns a publisher that emits data over time. The caller subscribes to receive it.

• Threads are not blocked waiting for I/O
• Great for high-concurrency, low-latency services

Spring WebFlux is built on Project Reactor, which provides two core publisher types:

• Mono<T> — emits 0 or 1 item
• Flux<T> — emits 0 to N items

Both implement the Reactive Streams Publisher interface.

A Mono represents a single (or empty) async result. Use Mono.just() for a known value and Mono.empty() for none.

A Flux emits many items. Build one from values, an iterable, or a range.

Publishers are lazy. The pipeline does nothing until something subscribes.

Calling map() or filter() only describes work. The data flows only when subscribe() is invoked.

map applies a synchronous function to each emitted item, transforming it one-to-one.

filter keeps only items that match a predicate.

Use Mono.fromSupplier() to defer execution of a value-producing function until subscription time.

Reactive pipelines signal errors as a terminal event. Use onErrorReturn to supply a fallback value.

The full subscribe form accepts three callbacks: onNext, onError, and onComplete.

In tests or simple mains you can convert reactive types to blocking ones with block() or blockFirst().

Avoid block() in production reactive code — it defeats the non-blocking model.

You learned the foundations of reactive programming with Project Reactor:

• Mono emits 0 or 1 item; Flux emits 0 to N
• Publishers are lazy — nothing runs until subscribe()
• map and filter describe transformations
• onErrorReturn provides fallbacks