org.springframework.web.reactive.function.server

## Class RouterFunctions

- java.lang.Object
- - org.springframework.web.reactive.function.server.RouterFunctions

    public abstract class RouterFunctions
    extends Object

Central entry point to Spring's functional web framework. Exposes routing functionality, such as to create a `RouterFunction` using a discoverable builder-style API, to create a `RouterFunction` given a `RequestPredicate` and `HandlerFunction`, and to do further subrouting on an existing routing function.

Additionally, this class can transform a `RouterFunction` into an `HttpHandler`, which can be run in Servlet 3.1+, Reactor, or Undertow.

Since:
  5.0
Author:
  Arjen Poutsma

### Nested Class Summary

Nested Classes
`static interface` `RouterFunctions.Builder` Represents a discoverable builder for router functions.
`static interface` `RouterFunctions.Visitor` Receives notifications from the logical structure of router functions.

### Field Summary

Fields
`static String` `MATCHING_PATTERN_ATTRIBUTE` Name of the `attribute` that contains the matching pattern, as a `PathPattern`.
`static String` `REQUEST_ATTRIBUTE` Name of the `ServerWebExchange` attribute that contains the `ServerRequest`.
`static String` `URI_TEMPLATE_VARIABLES_ATTRIBUTE` Name of the `ServerWebExchange` attribute that contains the URI templates map, mapping variable names to values.

### Constructor Summary

Constructors
Constructor and Description
`RouterFunctions()`

### Method Summary

All Methods Static Methods Concrete Methods
`static <T extends ServerResponse> RouterFunction<T>` `nest(RequestPredicate predicate, RouterFunction<T> routerFunction)` Route to the given router function if the given request predicate applies.
`static Function<ServerRequest,reactor.core.publisher.Mono<org.springframework.core.io.Resource>>` `resourceLookupFunction(String pattern, org.springframework.core.io.Resource location)` Returns the resource lookup function used by `resources(String, Resource)`.
`static RouterFunction<ServerResponse>` `resources(Function<ServerRequest,reactor.core.publisher.Mono<org.springframework.core.io.Resource>> lookupFunction)` Route to resources using the provided lookup function.
`static RouterFunction<ServerResponse>` `resources(String pattern, org.springframework.core.io.Resource location)` Route requests that match the given pattern to resources relative to the given root location.
`static RouterFunctions.Builder` `route()` Offers a discoverable way to create router functions through a builder-style interface.
`static <T extends ServerResponse> RouterFunction<T>` `route(RequestPredicate predicate, HandlerFunction<T> handlerFunction)` Route to the given handler function if the given request predicate applies.
`static org.springframework.http.server.reactive.HttpHandler` `toHttpHandler(RouterFunction<?> routerFunction)` Convert the given router function into a `HttpHandler`.
`static org.springframework.http.server.reactive.HttpHandler` `toHttpHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies)` Convert the given router function into a `HttpHandler`, using the given strategies.
`static org.springframework.web.server.WebHandler` `toWebHandler(RouterFunction<?> routerFunction)` Convert the given router function into a `WebHandler`.
`static org.springframework.web.server.WebHandler` `toWebHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies)` Convert the given router function into a `WebHandler`, using the given strategies.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### REQUEST_ATTRIBUTE

    public static final String REQUEST_ATTRIBUTE

Name of the `ServerWebExchange` attribute that contains the `ServerRequest`.

#### URI_TEMPLATE_VARIABLES_ATTRIBUTE

    public static final String URI_TEMPLATE_VARIABLES_ATTRIBUTE

Name of the `ServerWebExchange` attribute that contains the URI templates map, mapping variable names to values.

#### MATCHING_PATTERN_ATTRIBUTE

    public static final String MATCHING_PATTERN_ATTRIBUTE

Name of the `attribute` that contains the matching pattern, as a `PathPattern`.

### Constructor Detail

#### RouterFunctions

    public RouterFunctions()

### Method Detail

#### route

    public static RouterFunctions.Builder route()

Offers a discoverable way to create router functions through a builder-style interface.

Returns:
  a router function builder
Since:
  5.1

#### route

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

Route to the given handler function if the given request predicate applies.

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

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

Type Parameters:
  `T` - the type of response returned by the handler function
Parameters:
  `predicate` - the predicate to test
  `handlerFunction` - the handler function to route to if the predicate applies
Returns:
  a router function that routes to `handlerFunction` if `predicate` evaluates to `true`
See Also:
  `RequestPredicates`

#### nest

    public static <T extends ServerResponse> RouterFunction<T> nest(RequestPredicate predicate,
                                                                    RouterFunction<T> routerFunction)

Route to the given 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 first creates a composed route that resolves to `listUsers` for a GET, and `createUser` for a POST. This composed route then gets nested 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> userRoutes =
       RouterFunctions.route(RequestPredicates.method(HttpMethod.GET), this::listUsers)
         .andRoute(RequestPredicates.method(HttpMethod.POST), this::createUser);
     RouterFunction<ServerResponse> nestedRoute =
       RouterFunctions.nest(RequestPredicates.path("/user"), userRoutes);

Type Parameters:
  `T` - the type of response returned by the handler function
Parameters:
  `predicate` - the predicate to test
  `routerFunction` - the nested router function to delegate to if the predicate applies
Returns:
  a router function that routes to `routerFunction` if `predicate` evaluates to `true`
See Also:
  `RequestPredicates`

#### resources

    public static RouterFunction<ServerResponse> 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:
  a router function that routes to resources
See Also:
  `resourceLookupFunction(String, Resource)`

#### resourceLookupFunction

    public static Function<ServerRequest,reactor.core.publisher.Mono<org.springframework.core.io.Resource>> resourceLookupFunction(String pattern,
                                                                                                                                   org.springframework.core.io.Resource location)

Returns the resource lookup function used by `resources(String, Resource)`. The returned function can be composed on, for instance to return a default resource when the lookup function does not match:

     Mono<Resource> defaultResource = Mono.just(new ClassPathResource("index.html"));
     Function<ServerRequest, Mono<Resource>> lookupFunction =
       RouterFunctions.resourceLookupFunction("/resources/**", new FileSystemResource("public-resources/"))
         .andThen(resourceMono -> resourceMono.switchIfEmpty(defaultResource));
     RouterFunction<ServerResponse> resources = RouterFunctions.resources(lookupFunction);

Parameters:
  `pattern` - the pattern to match
  `location` - the location directory relative to which resources should be resolved
Returns:
  the default resource lookup function for the given parameters.

#### resources

    public static RouterFunction<ServerResponse> 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:
  a router function that routes to resources

#### toHttpHandler

    public static org.springframework.http.server.reactive.HttpHandler toHttpHandler(RouterFunction<?> routerFunction)

Convert the given router function into a `HttpHandler`. This conversion uses default strategies.

The returned handler can be adapted to run in

- Servlet 3.1+ using the `ServletHttpHandlerAdapter`,
- Reactor using the `ReactorHttpHandlerAdapter`,
- Undertow using the `UndertowHttpHandlerAdapter`.

Note that `HttpWebHandlerAdapter` also implements `WebHandler`, allowing for additional filter and exception handler registration through `WebHttpHandlerBuilder`.

Parameters:
  `routerFunction` - the router function to convert
Returns:
  an http handler that handles HTTP request using the given router function

#### toHttpHandler

    public static org.springframework.http.server.reactive.HttpHandler toHttpHandler(RouterFunction<?> routerFunction,
                                                                                     HandlerStrategies strategies)

Convert the given router function into a `HttpHandler`, using the given strategies.

The returned `HttpHandler` can be adapted to run in

- Servlet 3.1+ using the `ServletHttpHandlerAdapter`,
- Reactor using the `ReactorHttpHandlerAdapter`,
- Undertow using the `UndertowHttpHandlerAdapter`.

Parameters:
  `routerFunction` - the router function to convert
  `strategies` - the strategies to use
Returns:
  an http handler that handles HTTP request using the given router function

#### toWebHandler

    public static org.springframework.web.server.WebHandler toWebHandler(RouterFunction<?> routerFunction)

Convert the given router function into a `WebHandler`. This conversion uses default strategies.

Parameters:
  `routerFunction` - the router function to convert
Returns:
  a web handler that handles web request using the given router function

#### toWebHandler

    public static org.springframework.web.server.WebHandler toWebHandler(RouterFunction<?> routerFunction,
                                                                         HandlerStrategies strategies)

Convert the given router function into a `WebHandler`, using the given strategies.

Parameters:
  `routerFunction` - the router function to convert
  `strategies` - the strategies to use
Returns:
  a web handler that handles web request using the given router function