org.springframework.web.reactive.function.server

Interface RouterFunctions.Builder

Enclosing class:

RouterFunctions

public static interface RouterFunctions.Builder

Represents a discoverable builder for router functions. Obtained via RouterFunctions.route().

Since:

5.1

Method Summary

Modifier and Type	Method and Description
RouterFunctions.Builder	add(RouterFunction<ServerResponse> routerFunction) Adds the given route to this builder.
RouterFunctions.Builder	after(BiFunction<ServerRequest,ServerResponse,ServerResponse> responseProcessor) Filter the response object for all routes created by this builder with the given response processing function.
RouterFunctions.Builder	before(Function<ServerRequest,ServerRequest> requestProcessor) Filter the request object for all routes created by this builder with the given request processing function.
RouterFunction<ServerResponse>	build() Builds the RouterFunction.
RouterFunctions.Builder	DELETE(String pattern, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP DELETE requests that match the given pattern.
RouterFunctions.Builder	DELETE(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP DELETE requests that match the given pattern and predicate.
RouterFunctions.Builder	filter(HandlerFilterFunction<ServerResponse,ServerResponse> filterFunction) Filters all routes created by this builder with the given filter function.
RouterFunctions.Builder	GET(String pattern, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP GET requests that match the given pattern.
RouterFunctions.Builder	GET(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP GET requests that match the given pattern and predicate.
RouterFunctions.Builder	HEAD(String pattern, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP HEAD requests that match the given pattern.
RouterFunctions.Builder	HEAD(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP HEAD requests that match the given pattern and predicate.
RouterFunctions.Builder	nest(RequestPredicate predicate, Consumer<RouterFunctions.Builder> builderConsumer) Route to a built router function if the given request predicate applies.
RouterFunctions.Builder	nest(RequestPredicate predicate, Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier) Route to the supplied router function if the given request predicate applies.
<T extends Throwable> RouterFunctions.Builder	onError(Class<T> exceptionType, BiFunction<? super T,ServerRequest,reactor.core.publisher.Mono<ServerResponse>> responseProvider) Filters all exceptions of the given type by applying the given response provider function.
RouterFunctions.Builder	onError(Predicate<? super Throwable> predicate, BiFunction<? super Throwable,ServerRequest,reactor.core.publisher.Mono<ServerResponse>> responseProvider) Filters all exceptions that match the predicate by applying the given response provider function.
RouterFunctions.Builder	OPTIONS(String pattern, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP OPTIONS requests that match the given pattern.
RouterFunctions.Builder	OPTIONS(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP OPTIONS requests that match the given pattern and predicate.
RouterFunctions.Builder	PATCH(String pattern, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP PATCH requests that match the given pattern.
RouterFunctions.Builder	PATCH(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP PATCH requests that match the given pattern and predicate.
RouterFunctions.Builder	path(String pattern, Consumer<RouterFunctions.Builder> builderConsumer) Route to a built router function if the given path prefix pattern applies.
RouterFunctions.Builder	path(String pattern, Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier) Route to the supplied router function if the given path prefix pattern applies.
RouterFunctions.Builder	POST(String pattern, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP POST requests that match the given pattern.
RouterFunctions.Builder	POST(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP POST requests that match the given pattern and predicate.
RouterFunctions.Builder	PUT(String pattern, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP PUT requests that match the given pattern.
RouterFunctions.Builder	PUT(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) Adds a route to the given handler function that handles all HTTP PUT requests that match the given pattern and predicate.
RouterFunctions.Builder	resources(Function<ServerRequest,reactor.core.publisher.Mono<org.springframework.core.io.Resource>> lookupFunction) Route to resources using the provided lookup function.
RouterFunctions.Builder	resources(String pattern, org.springframework.core.io.Resource location) Route requests that match the given pattern to resources relative to the given root location.

Method Detail

GET

RouterFunctions.Builder GET(String pattern,
                            HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP GET requests that match the given pattern.

Parameters:

pattern - the pattern to match to

handlerFunction - the handler function to handle all GET requests that match pattern

Returns:

this builder

GET

RouterFunctions.Builder GET(String pattern,
                            RequestPredicate predicate,
                            HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP GET requests that match the given pattern and predicate.

For instance, the following example routes GET requests for "/user" that accept JSON to the listUsers method in userController:

 RouterFunction<ServerResponse> route =
   RouterFunctions.route()
     .GET("/user", RequestPredicates.accept(MediaType.APPLICATION_JSON), userController::listUsers)
     .build();
 

Parameters:

pattern - the pattern to match to

predicate - additional predicate to match

handlerFunction - the handler function to handle all GET requests that match pattern

Returns:

this builder

See Also:

RequestPredicates

HEAD

RouterFunctions.Builder HEAD(String pattern,
                             HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP HEAD requests that match the given pattern.

Parameters:

pattern - the pattern to match to

handlerFunction - the handler function to handle all HEAD requests that match pattern

Returns:

this builder

HEAD

RouterFunctions.Builder HEAD(String pattern,
                             RequestPredicate predicate,
                             HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP HEAD requests that match the given pattern and predicate.

Parameters:

pattern - the pattern to match to

predicate - additional predicate to match

handlerFunction - the handler function to handle all HEAD requests that match pattern

Returns:

this builder

POST

RouterFunctions.Builder POST(String pattern,
                             HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP POST requests that match the given pattern.

Parameters:

pattern - the pattern to match to

handlerFunction - the handler function to handle all POST requests that match pattern

Returns:

this builder

POST

RouterFunctions.Builder POST(String pattern,
                             RequestPredicate predicate,
                             HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP POST requests that match the given pattern and predicate.

For instance, the following example routes POST requests for "/user" that contain JSON to the addUser method in userController:

 RouterFunction<ServerResponse> route =
   RouterFunctions.route()
     .POST("/user", RequestPredicates.contentType(MediaType.APPLICATION_JSON), userController::addUser)
     .build();
 

Parameters:

pattern - the pattern to match to

predicate - additional predicate to match

handlerFunction - the handler function to handle all POST requests that match pattern

Returns:

this builder

PUT

RouterFunctions.Builder PUT(String pattern,
                            HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP PUT requests that match the given pattern.

Parameters:

pattern - the pattern to match to

handlerFunction - the handler function to handle all PUT requests that match pattern

Returns:

this builder

PUT

RouterFunctions.Builder PUT(String pattern,
                            RequestPredicate predicate,
                            HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP PUT requests that match the given pattern and predicate.

For instance, the following example routes PUT requests for "/user" that contain JSON to the editUser method in userController:

 RouterFunction<ServerResponse> route =
   RouterFunctions.route()
     .PUT("/user", RequestPredicates.contentType(MediaType.APPLICATION_JSON), userController::editUser)
     .build();
 

Parameters:

pattern - the pattern to match to

predicate - additional predicate to match

handlerFunction - the handler function to handle all PUT requests that match pattern

Returns:

this builder

PATCH

RouterFunctions.Builder PATCH(String pattern,
                              HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP PATCH requests that match the given pattern.

Parameters:

pattern - the pattern to match to

handlerFunction - the handler function to handle all PATCH requests that match pattern

Returns:

this builder

PATCH

RouterFunctions.Builder PATCH(String pattern,
                              RequestPredicate predicate,
                              HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP PATCH requests that match the given pattern and predicate.

For instance, the following example routes PATCH requests for "/user" that contain JSON to the editUser method in userController:

 RouterFunction<ServerResponse> route =
   RouterFunctions.route()
     .PATCH("/user", RequestPredicates.contentType(MediaType.APPLICATION_JSON), userController::editUser)
     .build();
 

Parameters:

pattern - the pattern to match to

predicate - additional predicate to match

handlerFunction - the handler function to handle all PATCH requests that match pattern

Returns:

this builder

DELETE

RouterFunctions.Builder DELETE(String pattern,
                               HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP DELETE requests that match the given pattern.

Parameters:

pattern - the pattern to match to

handlerFunction - the handler function to handle all DELETE requests that match pattern

Returns:

this builder

DELETE

RouterFunctions.Builder DELETE(String pattern,
                               RequestPredicate predicate,
                               HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP DELETE requests that match the given pattern and predicate.

Parameters:

pattern - the pattern to match to

predicate - additional predicate to match

handlerFunction - the handler function to handle all DELETE requests that match pattern

Returns:

this builder

OPTIONS

RouterFunctions.Builder OPTIONS(String pattern,
                                HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP OPTIONS requests that match the given pattern.

Parameters:

pattern - the pattern to match to

handlerFunction - the handler function to handle all OPTIONS requests that match pattern

Returns:

this builder

OPTIONS

RouterFunctions.Builder OPTIONS(String pattern,
                                RequestPredicate predicate,
                                HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all HTTP OPTIONS requests that match the given pattern and predicate.

Parameters:

pattern - the pattern to match to

predicate - additional predicate to match

handlerFunction - the handler function to handle all OPTIONS requests that match pattern

Returns:

this builder

add

RouterFunctions.Builder add(RouterFunction<ServerResponse> routerFunction)

Adds the given route to this builder. Can be used to merge externally defined router functions into this builder, or can be combined with RouterFunctions.route(RequestPredicate, HandlerFunction) to allow for more flexible predicate matching.

For instance, the following example adds the router function returned from OrderController.routerFunction(). to the changeUser method in userController:

 RouterFunctionlt;ServerResponsegt; route =
   RouterFunctions.route()
     .GET("/users", userController::listUsers)
     .add(orderController.routerFunction());
     .build();
 

Parameters:

routerFunction - the router function to be added

Returns:

this builder

See Also:

RequestPredicates

resources

RouterFunctions.Builder resources(String pattern,
                                  org.springframework.core.io.Resource location)

Route requests that match the given pattern to resources relative to the given root location. For instance

 Resource location = new FileSystemResource("public-resources/");
 RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
 

Parameters:

pattern - the pattern to match

location - the location directory relative to which resources should be resolved

Returns:

this builder

resources

RouterFunctions.Builder resources(Function<ServerRequest,reactor.core.publisher.Mono<org.springframework.core.io.Resource>> lookupFunction)

Route to resources using the provided lookup function. If the lookup function provides a Resource for the given request, it will be it will be exposed using a HandlerFunction that handles GET, HEAD, and OPTIONS requests.

Parameters:

lookupFunction - the function to provide a Resource given the ServerRequest

Returns:

this builder

nest

RouterFunctions.Builder nest(RequestPredicate predicate,
                             Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier)

Route to the supplied router function if the given request predicate applies. This method can be used to create nested routes, where a group of routes share a common path (prefix), header, or other request predicate.

For instance, the following example creates a nested route with a "/user" path predicate, so that GET requests for "/user" will list users, and POST request for "/user" will create a new user.

 RouterFunction<ServerResponse> nestedRoute =
   RouterFunctions.route()
     .nest(RequestPredicates.path("/user"), () ->
       RouterFunctions.route()
         .GET(this::listUsers)
         .POST(this::createUser)
         .build())
     .build();
 

Parameters:

predicate - the predicate to test

routerFunctionSupplier - supplier for the nested router function to delegate to if the predicate applies

Returns:

this builder

See Also:

RequestPredicates

nest

RouterFunctions.Builder nest(RequestPredicate predicate,
                             Consumer<RouterFunctions.Builder> builderConsumer)

Route to a built router function if the given request predicate applies. This method can be used to create nested routes, where a group of routes share a common path (prefix), header, or other request predicate.

For instance, the following example creates a nested route with a "/user" path predicate, so that GET requests for "/user" will list users, and POST request for "/user" will create a new user.

 RouterFunction<ServerResponse> nestedRoute =
   RouterFunctions.route()
     .nest(RequestPredicates.path("/user"), builder ->
       builder.GET(this::listUsers)
              .POST(this::createUser))
     .build();
 

Parameters:

predicate - the predicate to test

builderConsumer - consumer for a Builder that provides the nested router function

Returns:

this builder

See Also:

RequestPredicates

path

RouterFunctions.Builder path(String pattern,
                             Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier)

Route to the supplied router function if the given path prefix pattern applies. This method can be used to create nested routes, where a group of routes share a common path prefix. Specifically, this method can be used to merge externally defined router functions under a path prefix.

For instance, the following example creates a nested route with a "/user" path predicate that delegates to the router function defined in userController, and with a "/order" path that delegates to orderController.

 RouterFunction<ServerResponse> nestedRoute =
   RouterFunctions.route()
     .path("/user", userController::routerFunction)
     .path("/order", orderController::routerFunction)
     .build();
 

Parameters:

pattern - the pattern to match to

routerFunctionSupplier - supplier for the nested router function to delegate to if the pattern matches

Returns:

this builder

path

RouterFunctions.Builder path(String pattern,
                             Consumer<RouterFunctions.Builder> builderConsumer)

Route to a built router function if the given path prefix pattern applies. This method can be used to create nested routes, where a group of routes share a common path prefix.

For instance, the following example creates a nested route with a "/user" path predicate, so that GET requests for "/user" will list users, and POST request for "/user" will create a new user.

 RouterFunction<ServerResponse> nestedRoute =
   RouterFunctions.route()
     .path("/user", builder ->
       builder.GET(this::listUsers)
              .POST(this::createUser))
     .build();
 

Parameters:

pattern - the pattern to match to

builderConsumer - consumer for a Builder that provides the nested router function

Returns:

this builder

filter

RouterFunctions.Builder filter(HandlerFilterFunction<ServerResponse,ServerResponse> filterFunction)

Filters all routes created by this builder with the given filter function. Filter functions are typically used to address cross-cutting concerns, such as logging, security, etc.

For instance, the following example creates a filter that returns a 401 Unauthorized response if the request does not contain the necessary authentication headers.

 RouterFunction<ServerResponse> filteredRoute =
   RouterFunctions.route()
     .GET("/user", this::listUsers)
     .filter((request, next) -> {
       // check for authentication headers
       if (isAuthenticated(request)) {
         return next.handle(request);
       }
       else {
         return ServerResponse.status(HttpStatus.UNAUTHORIZED).build();
       }
     })
     .build();
 

Parameters:

filterFunction - the function to filter all routes built by this builder

Returns:

this builder

before

RouterFunctions.Builder before(Function<ServerRequest,ServerRequest> requestProcessor)

Filter the request object for all routes created by this builder with the given request processing function. Filters are typically used to address cross-cutting concerns, such as logging, security, etc.

For instance, the following example creates a filter that logs the request before the handler function executes.

 RouterFunction<ServerResponse> filteredRoute =
   RouterFunctions.route()
     .GET("/user", this::listUsers)
     .before(request -> {
       log(request);
       return request;
     })
     .build();
 

Parameters:

requestProcessor - a function that transforms the request

Returns:

this builder

after

RouterFunctions.Builder after(BiFunction<ServerRequest,ServerResponse,ServerResponse> responseProcessor)

Filter the response object for all routes created by this builder with the given response processing function. Filters are typically used to address cross-cutting concerns, such as logging, security, etc.

For instance, the following example creates a filter that logs the response after the handler function executes.

 RouterFunction<ServerResponse> filteredRoute =
   RouterFunctions.route()
     .GET("/user", this::listUsers)
     .after((request, response) -> {
       log(response);
       return response;
     })
     .build();
 

Parameters:

responseProcessor - a function that transforms the response

Returns:

this builder

onError

RouterFunctions.Builder onError(Predicate<? super Throwable> predicate,
                                BiFunction<? super Throwable,ServerRequest,reactor.core.publisher.Mono<ServerResponse>> responseProvider)

Filters all exceptions that match the predicate by applying the given response provider function.

For instance, the following example creates a filter that returns a 500 response status when an IllegalStateException occurs.

 RouterFunction<ServerResponse> filteredRoute =
   RouterFunctions.route()
     .GET("/user", this::listUsers)
     .onError(e -> e instanceof IllegalStateException,
       (e, request) -> ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR).build())
     .build();
 

Parameters:

predicate - the type of exception to filter

responseProvider - a function that creates a response

Returns:

this builder

onError

<T extends Throwable> RouterFunctions.Builder onError(Class<T> exceptionType,
                                                      BiFunction<? super T,ServerRequest,reactor.core.publisher.Mono<ServerResponse>> responseProvider)

Filters all exceptions of the given type by applying the given response provider function.

For instance, the following example creates a filter that returns a 500 response status when an IllegalStateException occurs.

 RouterFunction<ServerResponse> filteredRoute =
   RouterFunctions.route()
     .GET("/user", this::listUsers)
     .onError(IllegalStateException.class,
       (e, request) -> ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR).build())
     .build();
 

Parameters:

exceptionType - the type of exception to filter

responseProvider - a function that creates a response

Returns:

this builder

build

RouterFunction<ServerResponse> build()

Builds the RouterFunction. All created routes are composed with one another, and filters (if any) are applied to the result.

Returns:

the built router function