Spring WebFlux

Spring WebFlux is Spring’s reactive web framework for non-blocking applications.

To support asynchronous, non-blocking I/O and efficient resource usage under high concurrency.

MVC is traditionally blocking/servlet-based; WebFlux is reactive/non-blocking.

Programming model based on asynchronous data streams and event propagation.

Source that emits items asynchronously to subscribers.

Consumer that receives stream signals (onNext, onError, onComplete).

Link between publisher/subscriber that controls demand/cancellation.

Mechanism where subscriber controls how much data it can handle.

Project Reactor.

Reactive type representing zero or one item.

Reactive type representing zero to many items.

Mono for single/optional result; Flux for sequences/multiple results.

I/O operations that do not block threads while waiting for responses.

Small number of threads handling many connections via async callbacks/events.

Reactor Netty (commonly in Spring Boot setups).

Yes, with compatible adapters, though model remains reactive.

Reactive HTTP client in Spring for non-blocking outbound calls.

WebClient is preferred for reactive use cases.

Works similarly, but handler methods return Mono/Flux or reactive-compatible types.

Routing/handler functions instead of annotation-based controllers.

Defines request routing rules in functional WebFlux API.

Function handling matched requests and returning reactive ServerResponse.

Reactive abstraction of HTTP request in functional style.

Reactive abstraction for building HTTP response in functional style.

Streaming responses (e.g., Server-Sent Events).

Server-Sent Events: server pushes one-way event stream over HTTP.

Chain of operators transforming and controlling data flow.

map, filter, flatMap, doOnNext.

Transforms each emitted item synchronously.

Transforms each item into async publisher and merges results.

Composes async operations without blocking.

Starts stream execution by attaching a subscriber.

Usually lazy; execution starts on subscription.

Starts producing data separately for each subscriber.

Can emit independently of individual subscriber start times.

Terminal signal representing failure (onError).

Terminal signal indicating successful end (onComplete).

No, terminal signals are mutually exclusive.

Data access returning Mono/Flux for non-blocking composition.

Generally no; it defeats non-blocking model and may cause issues.

Can stall event-loop threads and reduce scalability.

Abstraction controlling execution threads for operators/subscriptions.

Scheduler intended for blocking/longer tasks with bounded thread growth.

Scheduler optimized for CPU-bound parallel work.

Executes tasks on current thread immediately.

Supports reactive exception handling similarly to MVC with reactive return types.

Global reactive error handling component at web layer.

Bean Validation on request bodies/params with reactive controller support.

Triggers validation for bound request objects.

Mixing reactive types with hidden blocking calls.

Using reactive return types without understanding backpressure/error semantics.

Not always; benefits depend on workload and I/O patterns.

High-concurrency I/O-bound services with many waiting external calls.

Simple CRUD apps with mostly blocking dependencies and low concurrency needs.

Standardized async stream semantics with backpressure interoperability.

Passing request metadata across async/reactive boundaries.

Per-subscriber key-value context propagated through reactive chain.

Structured logs, latency/error metrics, trace IDs in context.

StepVerifier for publishers + WebTestClient for HTTP endpoints.

Stay non-blocking end-to-end and keep pipelines simple/readable.

Reactive HTTP test client for testing WebFlux endpoints.

Works with live server or application context and supports reactive assertions.

Reactor test utility to verify sequence emissions and terminal signals.

Simulates time passage for deterministic testing of delays/timeouts/retries.

Avoids slow/flaky time-based tests.

flatMap merges async outputs (unordered); concatMap preserves order sequentially.

Switches to latest inner publisher and cancels previous one.

merge interleaves emissions; zip pairs items by index from sources.

Fallback to alternative publisher when error occurs.

Return static fallback value on error.

Resubscribes on failure according to policy.

Can amplify load and duplicate side effects.

Advanced retry with custom backoff/filters.

Fails sequence if signal not received within duration.

Side-effect logging/metrics on error without handling it.

Runs cleanup logic on completion, error, or cancellation.

Subscriber stops demand and terminates upstream processing.

Prevents wasted work/resource leaks after client disconnects/timeouts.

onBackpressureBuffer, onBackpressureDrop, onBackpressureLatest.

Memory growth and potential OOM.

Switches execution context downstream of operator.

Influences where subscription/upstream source runs.

subscribeOn affects source subscription; publishOn affects downstream execution point.

Adds/modifies Reactor Context entries in pipeline.

Thread-local MDC does not naturally follow async/reactive thread hops.

Use Reactor Context + instrumentation bridges for MDC propagation.

Explicit composable route definitions, often good for modular APIs.

Team preference/use case; both supported and can coexist.

Decode HTTP response body to reactive types.

exchangeToMono gives full response control; retrieve is simpler for common flows.

Interceptor-like hook for request/response cross-cutting logic.

Auth headers, correlation IDs, logging, metrics, retries.

Reuse HTTP connections for performance and resource efficiency.

Prevent hanging calls and protect event-loop capacity.

Limit for buffering decoded content to avoid excessive memory use.

Abstraction for byte buffers in reactive I/O processing.

Improper handling in low-level code can leak memory.

Reactive handling of multipart/form-data uploads.

Return Flux<DataBuffer> or Resource-based reactive response.

Spring Security supports WebFlux with dedicated reactive filter chain APIs.

Reactive counterpart to servlet SecurityFilterChain.

Authorization checks on reactive methods with non-blocking support.

Reactive relational database connectivity API for non-blocking SQL access.

Would block event loops and undermine reactive scalability.

Isolate calls on boundedElastic and limit usage carefully.

Concurrency isolation limits per downstream dependency.

Controlling request throughput to protect resources.

Calling block()/toIterable() inside request pipelines.

Complex unreadable operator chains without clear error semantics.

Small composed functions, clear naming, documented error/retry behavior.

Adds assembly trace markers for easier debugging.

Helpful for debugging but can add overhead/noise.

Global debug mode for assembly tracing (expensive, mostly non-prod).

Unit test operators/services + integration test HTTP and dependency behavior.

StepVerifier request control and bounded demand assertions.

Cancel subscriptions in tests and verify cleanup side effects.

Validate payload/status/stream semantics between services.

Per-endpoint latency, errors, saturation, event-loop health, downstream timings.

Rising latency/timeouts despite low CPU due to blocked loop threads.

Thread analysis, instrumentation, and tools that flag blocking operations.

Timeouts + retries with backoff + circuit breakers + fallbacks.

Avoid synchronized retry spikes.

Team can trace thread/scheduler/backpressure behavior for critical flows.

Prefer end-to-end reactive dependencies and explicit resilience policies.

Use reactive where it adds clear concurrency/latency benefits.

Non-blocking boundaries across web, client, data, and messaging layers.

Blocking bottlenecks still dominate throughput/latency.

Slow downstream calls propagate and multiply latency across composed async hops.

Tight timeout budgets, hedging/cancellation strategies, bulkheads, caching.

Allocate per-hop deadlines under global request SLA.

Passing remaining time budget downstream via headers/context.

Managing lifecycles/cancellation of related async tasks coherently.

Parallel downstream calls combined into single response.

Explosive concurrency/load against dependencies.

Bound concurrency and short-circuit on partial failure where appropriate.

Limits concurrent inner subscriptions to control resource usage.

Controls upstream request batch sizes for operators.

Memory pressure and unfair resource use.

Lower throughput due to frequent demand signaling.

Internal operator optimization reducing overhead between compatible stages.

Operator choices can impact performance characteristics.

Pipeline declared at assembly; execution behavior materializes at subscription.

Context not automatically propagated through non-reactive adapters/threads.

Use explicit context propagation utilities/instrumentation hooks.

Codec limits, buffer management, streaming over buffering, controlled concurrency.

Can improve large file response efficiency depending server/runtime capabilities.

Non-blocking transactional boundaries with reactive-capable drivers (e.g., R2DBC).

JDBC is blocking and thread-bound.

Async retries/cancellations can duplicate side effects without idempotent design.

Idempotency keys, dedup stores, transactional outbox/inbox patterns.

Context propagation for auth across async boundaries and downstream calls.

Propagating OAuth tokens non-blockingly via filters/context.

Consistent trace/span/log context across operator chains and thread hops.

Unbounded labels can overwhelm monitoring systems.

Early rejecting low-priority requests under saturation.

Fallback partial responses when dependencies fail or time out.

Wrap downstream boundaries, not internal pure transformations.

Retrying too high in stack can repeat expensive upstream work.

Closest safe boundary around transient failing dependency calls.

Some dependencies ignore reactive demand and still overwhelm consumers.

Adapters with buffering limits, rate limits, and concurrency caps.

Inject latency/errors/cancellations to verify resilience and recovery behavior.

Measure throughput, p95/p99 latency, GC, event-loop utilization, queue depths.

Serialization and buffer behavior depend heavily on payload shape/size.

Startup/memory gains possible, but verify compatibility and runtime behavior.

Using reactive APIs with hidden blocking dependencies everywhere.

Strong understanding of async flows, debugging tools, and backpressure semantics.

Incremental edge/service migration where reactive benefits are clear.

Use MVC for simple blocking domains and WebFlux for high-concurrency I/O services.

Measure, don’t assume—reactive gains are workload-dependent.

Assume cancellation, retries, and partial failures are normal.

Preserve auth context and validate every downstream boundary.

Invest in tracing/metrics/debuggability before scaling traffic.

Keep reactive pipelines explicit, bounded, and domain-focused.

WebFlux excellence is disciplined non-blocking design plus operational rigor.