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

All Methods Instance Methods Abstract Methods
`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.
`RouterFunctions.Builder` `route(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles all requests that match the given predicate.

### 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

#### route

    RouterFunctions.Builder route(RequestPredicate predicate,
                                  HandlerFunction<ServerResponse> handlerFunction)

Adds a route to the given handler function that handles all requests that match the given predicate.

Parameters:
  `predicate` - the request predicate to match
  `handlerFunction` - the handler function to handle all requests that match the predicate
Returns:
  this builder
Since:
  5.2
See Also:
  `RequestPredicates`

#### 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`:

     RouterFunction<ServerResponse> 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