public abstract class RouterFunctions extends Object
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.
Modifier and Type | Class and Description |
---|---|
static interface |
RouterFunctions.Builder
Represents a discoverable builder for router functions.
|
static interface |
RouterFunctions.Visitor
Receives notifications from the logical structure of router functions.
|
Modifier and Type | Field and Description |
---|---|
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 and Description |
---|
RouterFunctions() |
Modifier and Type | Method and Description |
---|---|
static <T extends ServerResponse> |
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<Resource>> |
resourceLookupFunction(String pattern,
Resource location)
Returns the resource lookup function used by
resources(String, Resource) . |
static RouterFunction<ServerResponse> |
resources(Function<ServerRequest,reactor.core.publisher.Mono<Resource>> lookupFunction)
Route to resources using the provided lookup function.
|
static RouterFunction<ServerResponse> |
resources(String pattern,
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> |
route(RequestPredicate predicate,
HandlerFunction<T> handlerFunction)
Route to the given handler function if the given request predicate applies.
|
static HttpHandler |
toHttpHandler(RouterFunction<?> routerFunction)
Convert the given router function into a
HttpHandler . |
static HttpHandler |
toHttpHandler(RouterFunction<?> routerFunction,
HandlerStrategies strategies)
Convert the given router function into a
HttpHandler ,
using the given strategies. |
static WebHandler |
toWebHandler(RouterFunction<?> routerFunction)
Convert the given router function into a
WebHandler . |
static WebHandler |
toWebHandler(RouterFunction<?> routerFunction,
HandlerStrategies strategies)
Convert the given router function into a
WebHandler ,
using the given strategies. |
public static final String REQUEST_ATTRIBUTE
ServerWebExchange
attribute that contains the ServerRequest
.public static final String URI_TEMPLATE_VARIABLES_ATTRIBUTE
ServerWebExchange
attribute that contains the URI
templates map, mapping variable names to values.public static final String MATCHING_PATTERN_ATTRIBUTE
attribute
that
contains the matching pattern, as a PathPattern
.public static RouterFunctions.Builder route()
public static <T extends ServerResponse> RouterFunction<T> route(RequestPredicate predicate, HandlerFunction<T> handlerFunction)
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);
T
- the type of response returned by the handler functionpredicate
- the predicate to testhandlerFunction
- the handler function to route to if the predicate applieshandlerFunction
if
predicate
evaluates to true
RequestPredicates
public static <T extends ServerResponse> RouterFunction<T> nest(RequestPredicate predicate, RouterFunction<T> routerFunction)
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);
T
- the type of response returned by the handler functionpredicate
- the predicate to testrouterFunction
- the nested router function to delegate to if the predicate appliesrouterFunction
if
predicate
evaluates to true
RequestPredicates
public static RouterFunction<ServerResponse> resources(String pattern, Resource location)
Resource location = new FileSystemResource("public-resources/"); RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
pattern
- the pattern to matchlocation
- the location directory relative to which resources should be resolvedresourceLookupFunction(String, Resource)
public static Function<ServerRequest,reactor.core.publisher.Mono<Resource>> resourceLookupFunction(String pattern, Resource location)
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);
pattern
- the pattern to matchlocation
- the location directory relative to which resources should be resolvedpublic static RouterFunction<ServerResponse> resources(Function<ServerRequest,reactor.core.publisher.Mono<Resource>> lookupFunction)
Resource
for the given request, it will be it will be exposed using a
HandlerFunction
that handles GET, HEAD, and OPTIONS requests.lookupFunction
- the function to provide a Resource
given the ServerRequest
public static HttpHandler toHttpHandler(RouterFunction<?> routerFunction)
HttpHandler
.
This conversion uses default strategies.
The returned handler can be adapted to run in
ServletHttpHandlerAdapter
,ReactorHttpHandlerAdapter
,UndertowHttpHandlerAdapter
.Note that HttpWebHandlerAdapter
also implements WebHandler
, allowing
for additional filter and exception handler registration through
WebHttpHandlerBuilder
.
routerFunction
- the router function to convertpublic static HttpHandler toHttpHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies)
HttpHandler
,
using the given strategies.
The returned HttpHandler
can be adapted to run in
ServletHttpHandlerAdapter
,ReactorHttpHandlerAdapter
,UndertowHttpHandlerAdapter
.routerFunction
- the router function to convertstrategies
- the strategies to usepublic static WebHandler toWebHandler(RouterFunction<?> routerFunction)
routerFunction
- the router function to convertpublic static WebHandler toWebHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies)
WebHandler
,
using the given strategies.routerFunction
- the router function to convertstrategies
- the strategies to use