or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

annotation-controllers.md configuration.md error-handling.md functional-routing.md index.md server-configuration.md testing.md webclient.md

tile.json

tessl/maven-org-springframework-boot--spring-boot-starter-webflux

Starter for building WebFlux applications using Spring Framework's Reactive Web support

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:maven/org.springframework.boot/spring-boot-starter-webflux@3.5.x

To install, run

npx @tessl/cli install tessl/maven-org-springframework-boot--spring-boot-starter-webflux@3.5.0

Spring Boot WebFlux Starter

Spring Boot WebFlux Starter provides a comprehensive foundation for building reactive, non-blocking web applications using Spring Framework's reactive web support. It automatically configures Spring WebFlux with Reactor Netty, includes reactive JSON processing, and integrates seamlessly with the reactive ecosystem for building scalable microservices and real-time applications.

Package Information

Package Name: org.springframework.boot:spring-boot-starter-webflux
Package Type: maven
Language: Java
Installation: Add to your pom.xml dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
    <version>3.5.3</version>
</dependency>

For Gradle:

implementation 'org.springframework.boot:spring-boot-starter-webflux:3.5.3'

Core Imports

Spring Boot WebFlux provides two programming models through standard Spring imports:

// Annotation-based controllers
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.PathVariable;

// Reactive types
import reactor.core.publisher.Mono;
import reactor.core.publisher.Flux;

// Functional routing
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;

// WebClient for reactive HTTP calls
import org.springframework.web.reactive.function.client.WebClient;

Basic Usage

Annotated Controller Example

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @GetMapping("/{id}")
    public Mono<User> getUser(@PathVariable String id) {
        return userService.findById(id);
    }
    
    @GetMapping
    public Flux<User> getAllUsers() {
        return userService.findAll();
    }
    
    @PostMapping
    public Mono<User> createUser(@RequestBody Mono<User> user) {
        return user.flatMap(userService::save);
    }
}

Functional Routing Example

@Configuration
public class RouterConfiguration {
    
    @Bean
    public RouterFunction<ServerResponse> apiRoutes(UserHandler handler) {
        return RouterFunctions.route()
            .GET("/api/users/{id}", handler::getUser)
            .GET("/api/users", handler::listUsers)
            .POST("/api/users", handler::createUser)
            .build();
    }
}

WebClient Example

@Service
public class ExternalApiService {
    
    private final WebClient webClient;
    
    public ExternalApiService(WebClient.Builder builder) {
        this.webClient = builder.baseUrl("https://api.example.com").build();
    }
    
    public Mono<ApiResponse> fetchData(String id) {
        return webClient.get()
            .uri("/data/{id}", id)
            .retrieve()
            .bodyToMono(ApiResponse.class);
    }
}

Architecture

Spring Boot WebFlux Starter brings together several key components:

Reactive Web Framework: Spring WebFlux with annotation-based and functional programming models
Embedded Server: Reactor Netty (default), with support for Tomcat, Jetty, and Undertow
Reactive Streams: Built on Project Reactor (Mono/Flux) for non-blocking operations
HTTP Client: WebClient for reactive HTTP communication
JSON Processing: Jackson integration for reactive JSON serialization/deserialization
Error Handling: Reactive exception handlers with customizable error responses
AutoConfiguration: Automatic configuration of reactive web components

Capabilities

Annotation-Based Controllers

Traditional Spring MVC-style controllers enhanced with reactive return types. Perfect for developers familiar with Spring MVC who want to adopt reactive programming.

@RestController
public class ReactiveController {
    @GetMapping("/resource/{id}")
    public Mono<Resource> getResource(@PathVariable String id) { }
    
    @PostMapping("/resource")
    public Mono<Resource> createResource(@RequestBody Mono<Resource> resource) { }
}

Annotation-Based Controllers

Functional Routing

Modern functional approach using router functions and handler functions. Ideal for building lightweight, composable APIs with explicit request routing.

public interface RouterFunction<T extends ServerResponse> {
    Mono<HandlerFunction<T>> route(ServerRequest request);
}

public class RouterFunctions {
    public static <T extends ServerResponse> RouterFunction<T> route(
        RequestPredicate predicate, 
        HandlerFunction<T> handlerFunction
    ) { }
}

Functional Routing

Reactive HTTP Client

WebClient provides a modern, reactive HTTP client for making non-blocking HTTP requests with full integration into the reactive ecosystem.

public interface WebClient {
    RequestHeadersUriSpec<?> get();
    RequestBodyUriSpec post();
    RequestBodyUriSpec put();
    RequestHeadersUriSpec<?> delete();
    
    interface Builder {
        Builder baseUrl(String baseUrl);
        Builder defaultHeader(String header, String... values);
        WebClient build();
    }
}

WebClient

Server Configuration

Comprehensive server configuration supporting multiple embedded servers with extensive customization options for production deployments.

public interface ReactiveWebServerFactory {
    WebServer getWebServer(HttpHandler httpHandler);
}

public interface ConfigurableReactiveWebServerFactory extends ReactiveWebServerFactory {
    void setPort(int port);
    void setAddress(InetAddress address);
    void setSsl(Ssl ssl);
}

Server Configuration

Error Handling

Reactive error handling with customizable exception handlers, providing consistent error responses across different content types.

public interface ErrorWebExceptionHandler extends WebExceptionHandler {
    Mono<Void> handle(ServerWebExchange exchange, Throwable ex);
}

public abstract class AbstractErrorWebExceptionHandler implements ErrorWebExceptionHandler {
    protected abstract RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes);
}

Error Handling

Configuration Properties

Comprehensive configuration options through Spring Boot properties for customizing WebFlux behavior, static resources, and server settings.

@ConfigurationProperties("spring.webflux")
public class WebFluxProperties {
    private String basePath;
    private String staticPathPattern = "/**";
    private String webjarsPathPattern = "/webjars/**";
    private boolean hiddenMethodFilter = true;
    private final Format format = new Format();
    private final Problemdetails problemdetails = new Problemdetails();
}

Configuration

Testing Support

Reactive testing utilities and WebTestClient for comprehensive testing of WebFlux applications with full integration testing capabilities.

public interface WebTestClient {
    RequestHeadersUriSpec<?> get();
    RequestBodyUriSpec post();
    RequestBodyUriSpec put();
    RequestBodyUriSpec patch();
    RequestHeadersUriSpec<?> delete();
    
    static Builder bindToServer();
    static Builder bindToController(Object... controllers);
    static Builder bindToApplicationContext(ApplicationContext applicationContext);
    static Builder bindToRouterFunction(RouterFunction<?> routerFunction);
    static Builder bindToWebHandler(WebHandler webHandler);
}

Testing

Common Integration Patterns

Spring Data Reactive Repositories

@Repository
public interface UserRepository extends ReactiveCrudRepository<User, String> {
    Flux<User> findByStatus(String status);
    Mono<User> findByEmail(String email);
}

Reactive Security Integration

@EnableWebFluxSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityWebFilterChain securitygWebFilterChain(ServerHttpSecurity http) {
        return http
            .authorizeExchange(exchanges -> exchanges
                .pathMatchers("/public/**").permitAll()
                .anyExchange().authenticated()
            )
            .oauth2ResourceServer(ServerHttpSecurity.OAuth2ResourceServerSpec::jwt)
            .build();
    }
}

Server-Sent Events

@GetMapping(value = "/events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> streamEvents() {
    return Flux.interval(Duration.ofSeconds(1))
        .map(sequence -> "Event " + sequence);
}

Version

Tile

Files

tessl/maven-org-springframework-boot--spring-boot-starter-webflux

To install, run

index.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

Spring Boot WebFlux Starter

Package Information

Core Imports

Basic Usage

Annotated Controller Example

Functional Routing Example

WebClient Example

Architecture

Capabilities

Annotation-Based Controllers

Functional Routing

Reactive HTTP Client

Server Configuration

Error Handling

Configuration Properties

Testing Support

Common Integration Patterns

Spring Data Reactive Repositories

Reactive Security Integration

Server-Sent Events

index.mddocs/