org.springframework.web.servlet.function

## Interface RouterFunctions.Builder

- Enclosing class:
    RouterFunctions

      public static interface RouterFunctions.Builder

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

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    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(HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles HTTP `DELETE` requests.
    `RouterFunctions.Builder` | `DELETE(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles all HTTP `DELETE` requests that match the given predicate.
    `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(HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles HTTP `GET` requests.
    `RouterFunctions.Builder` | `GET(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles all HTTP `GET` requests that match the given predicate.
    `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(HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles HTTP `HEAD` requests.
    `RouterFunctions.Builder` | `HEAD(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles all HTTP `HEAD` requests that match the given 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.
    `RouterFunctions.Builder` | `onError(Class<? extends Throwable> exceptionType, BiFunction<Throwable,ServerRequest,ServerResponse> responseProvider)` Filters all exceptions of the given type by applying the given response provider function.
    `RouterFunctions.Builder` | `onError(Predicate<Throwable> predicate, BiFunction<Throwable,ServerRequest,ServerResponse> responseProvider)` Filters all exceptions that match the predicate by applying the given response provider function.
    `RouterFunctions.Builder` | `OPTIONS(HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles HTTP `OPTIONS` requests.
    `RouterFunctions.Builder` | `OPTIONS(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles all HTTP `OPTIONS` requests that match the given predicate.
    `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(HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles HTTP `PATCH` requests.
    `RouterFunctions.Builder` | `PATCH(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles all HTTP `PATCH` requests that match the given 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(HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles HTTP `POST` requests.
    `RouterFunctions.Builder` | `POST(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles all HTTP `POST` requests that match the given predicate.
    `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(HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles HTTP `PUT` requests.
    `RouterFunctions.Builder` | `PUT(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction)` Adds a route to the given handler function that handles all HTTP `PUT` requests that match the given 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,Optional<Resource>> lookupFunction)` Route to resources using the provided lookup function.
    `RouterFunctions.Builder` | `resources(String pattern, 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.
    `RouterFunctions.Builder` | `withAttribute(String name, Object value)` Add an attribute with the given name and value to the last route built with this builder.
    `RouterFunctions.Builder` | `withAttributes(Consumer<Map<String,Object>> attributesConsumer)` Manipulate the attributes of the last route built with the given consumer.

- - ### Method Detail

    - #### GET

          RouterFunctions.Builder GET(HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles HTTP `GET` requests.
      Parameters:
        `handlerFunction` - the handler function to handle all `GET` requests
      Returns:
        this builder
      Since:
        5.3

    - #### 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(RequestPredicate predicate,
                                      HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles all HTTP `GET` requests that match the given predicate.
      Parameters:
        `predicate` - predicate to match
        `handlerFunction` - the handler function to handle all `GET` requests that match `predicate`
      Returns:
        this builder
      Since:
        5.3
      See Also:
        `RequestPredicates`

    - #### 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` and the predicate
      Returns:
        this builder
      See Also:
        `RequestPredicates`

    - #### HEAD

          RouterFunctions.Builder HEAD(HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles HTTP `HEAD` requests.
      Parameters:
        `handlerFunction` - the handler function to handle all `HEAD` requests
      Returns:
        this builder
      Since:
        5.3

    - #### 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(RequestPredicate predicate,
                                       HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles all HTTP `HEAD` requests that match the given predicate.
      Parameters:
        `predicate` - predicate to match
        `handlerFunction` - the handler function to handle all `HEAD` requests that match `predicate`
      Returns:
        this builder
      Since:
        5.3
      See Also:
        `RequestPredicates`

    - #### 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(HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles HTTP `POST` requests.
      Parameters:
        `handlerFunction` - the handler function to handle all `POST` requests
      Returns:
        this builder
      Since:
        5.3

    - #### 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(RequestPredicate predicate,
                                       HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles all HTTP `POST` requests that match the given predicate.
      Parameters:
        `predicate` - predicate to match
        `handlerFunction` - the handler function to handle all `POST` requests that match `predicate`
      Returns:
        this builder
      Since:
        5.3
      See Also:
        `RequestPredicates`

    - #### 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(HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles HTTP `PUT` requests.
      Parameters:
        `handlerFunction` - the handler function to handle all `PUT` requests
      Returns:
        this builder
      Since:
        5.3

    - #### 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(RequestPredicate predicate,
                                      HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles all HTTP `PUT` requests that match the given predicate.
      Parameters:
        `predicate` - predicate to match
        `handlerFunction` - the handler function to handle all `PUT` requests that match `predicate`
      Returns:
        this builder
      Since:
        5.3
      See Also:
        `RequestPredicates`

    - #### 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(HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles HTTP `PATCH` requests.
      Parameters:
        `handlerFunction` - the handler function to handle all `PATCH` requests
      Returns:
        this builder
      Since:
        5.3

    - #### 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(RequestPredicate predicate,
                                        HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles all HTTP `PATCH` requests that match the given predicate.
      Parameters:
        `predicate` - predicate to match
        `handlerFunction` - the handler function to handle all `PATCH` requests that match `predicate`
      Returns:
        this builder
      Since:
        5.3
      See Also:
        `RequestPredicates`

    - #### 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(HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles HTTP `DELETE` requests.
      Parameters:
        `handlerFunction` - the handler function to handle all `DELETE` requests
      Returns:
        this builder
      Since:
        5.3

    - #### 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(RequestPredicate predicate,
                                         HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles all HTTP `DELETE` requests that match the given predicate.
      Parameters:
        `predicate` - predicate to match
        `handlerFunction` - the handler function to handle all `DELETE` requests that match `predicate`
      Returns:
        this builder
      Since:
        5.3
      See Also:
        `RequestPredicates`

    - #### 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(HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles HTTP `OPTIONS` requests.
      Parameters:
        `handlerFunction` - the handler function to handle all `OPTIONS` requests
      Returns:
        this builder
      Since:
        5.3

    - #### 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(RequestPredicate predicate,
                                          HandlerFunction<ServerResponse> handlerFunction)

      Adds a route to the given handler function that handles all HTTP `OPTIONS` requests that match the given predicate.
      Parameters:
        `predicate` - predicate to match
        `handlerFunction` - the handler function to handle all `OPTIONS` requests that match `predicate`
      Returns:
        this builder
      Since:
        5.3
      See Also:
        `RequestPredicates`

    - #### 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
      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,
                                            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,Optional<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<Throwable> predicate,
                                          BiFunction<Throwable,ServerRequest,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

          RouterFunctions.Builder onError(Class<? extends Throwable> exceptionType,
                                          BiFunction<Throwable,ServerRequest,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

    - #### withAttribute

          RouterFunctions.Builder withAttribute(String name,
                                                Object value)

      Add an attribute with the given name and value to the last route built with this builder.
      Parameters:
        `name` - the attribute name
        `value` - the attribute value
      Returns:
        this builder
      Since:
        5.3

    - #### withAttributes

          RouterFunctions.Builder withAttributes(Consumer<Map<String,Object>> attributesConsumer)

      Manipulate the attributes of the last route built with the given consumer.

      The map provided to the consumer is "live", so that the consumer can be used to overwrite existing attributes, remove attributes, or use any of the other `Map` methods.

      Parameters:
        `attributesConsumer` - a function that consumes the attributes map
      Returns:
        this builder
      Since:
        5.3

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