Filters, Codecs, Errors & Streaming

Add a method annotated with @ExceptionHandler in the same controller to handle it locally. To handle exceptions from many controllers in one place, put @ExceptionHandler methods in a class annotated with @ControllerAdvice (or @RestControllerAdvice).

Return a Flux from the controller and set produces=MediaType.TEXT_EVENT_STREAM_VALUE ("text/event-stream"). Spring keeps the HTTP response open and writes each emitted item to the client as a Server-Sent Event, instead of buffering one JSON array.

WebFilter is WebFlux's reactive interface for intercepting every request/response, the non-blocking equivalent of a servlet Filter. Its filter(exchange, chain) method returns Mono<Void>, and you call chain.filter(exchange) to continue to the next filter or handler.

WebFluxConfigurer is an interface with optional callback methods. You implement it on a @Configuration class to customize the reactive web setup — CORS, formatters, argument resolvers, codecs, content negotiation — without replacing Spring's defaults.

WebSocketHandler is the reactive interface you implement to handle a WebSocket connection. Its single method handle(WebSocketSession) returns Mono<Void>, a reactive signal that completes when your handling of the session is done (which closes it).

It's a limit on how many bytes a codec will buffer in memory when it must read the whole body before parsing. Default is 256 KB. Exceeding it throws DataBufferLimitException. You raise it via CodecConfigurer.defaultCodecs().maxInMemorySize(...).

To continue, return chain.filter(exchange). To short-circuit, do NOT call the chain: set the response status/headers on exchange.getResponse() and return exchange.getResponse().setComplete() (a Mono<Void> that finishes the exchange), so no downstream filter or handler runs.

@EnableWebFlux bootstraps Spring's reactive web infrastructure by importing DelegatingWebFluxConfiguration. In Spring Boot it also turns OFF Boot's WebFlux auto-configuration, so you take full manual control. In plain Spring you need it to enable WebFlux at all.

session.receive() returns a Flux<WebSocketMessage> of inbound frames; session.send(Publisher<WebSocketMessage>) takes an outbound stream and returns Mono<Void>. You transform the inbound Flux (or a separate source) into outbound WebSocketMessages and pass it to send(), returning that Mono.

The reactive stack writes and flushes each emitted item as bytes become sendable, keeping the connection open. Backpressure flows from the TCP write buffer up through Reactor: the encoder only requests the next item when the socket can accept more, so a slow client naturally slows the producer.

Register a SimpleUrlHandlerMapping bean that maps URL paths to your WebSocketHandler instances (with a high order so it wins over annotated controllers), plus a WebSocketHandlerAdapter bean. The adapter uses a WebSocketService — by default HandshakeWebSocketService — to perform the HTTP-to-WebSocket upgrade handshake.

WebFlux uses Jackson under the hood. Jackson2JsonEncoder turns your objects into JSON bytes for the response; Jackson2JsonDecoder turns request JSON bytes back into objects. They use a Jackson ObjectMapper, like MVC does.

ErrorAttributes is an interface that produces the map of fields (status, error, message, path, timestamp...) used to build the error response body. DefaultErrorAttributes is Boot's implementation; it also stores the exception so the error handler can read it. Extend it to customize the fields.

WebExceptionHandler is a functional interface with one method: Mono<Void> handle(ServerWebExchange exchange, Throwable ex). Beans of this type form an ordered chain that catches exceptions not handled inside controllers. The first one to complete the exchange wins.

Use Flux<ServerSentEvent<T>> when you need to set SSE metadata: the event name, an id (so clients can resume after reconnecting), the retry/reconnect delay, or comment lines. A plain Flux<T> only gives you the data field.

Give each filter an order via the @Order annotation or by implementing Ordered. Spring sorts WebFilter beans by that value — lower value = higher precedence = runs earlier (and, because filters wrap each other, later on the way back out).

Override addCorsMappings(CorsRegistry) in a WebFluxConfigurer bean. Use registry.addMapping(pathPattern) and chain allowedOrigins, allowedMethods, allowedHeaders, allowCredentials, and maxAge to define which cross-origin requests are permitted.

HttpMessageConverter is blocking — it reads/writes the whole body via InputStream/OutputStream. WebFlux is non-blocking, so it uses Encoder/Decoder over reactive streams of DataBuffer, letting it process bodies in chunks without tying up a thread.

It is Spring Boot's global fallback error handler for WebFlux. It renders a JSON (or Whitelabel HTML) error response for any unhandled exception, using ErrorAttributes for the body. Customize it by supplying your own ErrorAttributes or by subclassing AbstractErrorWebExceptionHandler.

Both stream a Flux incrementally. NDJSON (application/x-ndjson) sends each item as one JSON object per line — a plain data stream, easy for API/service-to-service clients. SSE (text/event-stream) adds event names, ids, retry, and browser EventSource support.

ServerWebExchange (and its request/response) are effectively immutable, so you can't set fields directly. Call exchange.mutate() to get a builder, apply changes (e.g. .request(r -> r.header(...))), call .build() to get a new exchange, and pass THAT to chain.filter(...).

configureHttpMessageCodecs tunes body serialization/deserialization (via ServerCodecConfigurer). addFormatters registers Converter/Formatter for turning strings into types (path vars, params). addArgumentResolvers adds custom HandlerMethodArgumentResolvers for controller parameters the framework doesn't handle natively.

WebFlux picks the response media type using a RequestedContentTypeResolver, which by default reads the Accept header. You customize it by overriding configureContentTypeResolver(RequestedContentTypeResolverBuilder) — e.g. enable a query parameter strategy or set a default media type.

The session stays open while the Mono<Void> you return is unterminated. When that Mono completes, the framework closes the session normally; when it errors, the session closes with an error status. The client disconnecting completes receive(), which typically completes your Mono.

A controller error is offered first to @ExceptionHandler (local then @ControllerAdvice). If unhandled — or if it came from a filter/functional endpoint — it propagates to the ordered WebExceptionHandler chain, ending in Boot's DefaultErrorWebExceptionHandler (order -1) which renders from ErrorAttributes.

Long-lived connections tie up sockets and cross proxies/load balancers that may buffer or time out idle streams. Address with heartbeats, sensible timeouts, disconnect cleanup (doOnCancel), non-blocking pipelines, resumption via Last-Event-ID, and disabling proxy response buffering.

Never use a ThreadLocal/MDC set imperatively — reactive work hops threads, so the value won't be there downstream. Measure latency by timing around the returned Mono (record start, then .doFinally on chain.filter). Propagate the correlation ID via the Reactor Context using .contextWrite(...), not a thread-local.

A session supports a single ordered write stream, so never call send() concurrently or write from multiple threads. For broadcast, use a shared Sinks.many() and let each session subscribe with its own send(), applying backpressure strategy (buffer/drop) per slow client, and mind pooled DataBuffer retain/release when reusing payloads.

Implement Encoder/Decoder (or HttpMessageReader/Writer), then register it in CodecConfigurer via customCodecs().register(...). Use defaultCodecs() to tweak built-ins (like maxInMemorySize or the Jackson mapper). Do this in WebFluxConfigurer.configureHttpMessageCodecs on the server or WebClient.Builder.codecs.