org.springframework.web.reactive.function.server

Class RouterFunctions

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


  • public abstract class RouterFunctions
    extends java.lang.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
    • Field Detail

      • URI_TEMPLATE_VARIABLES_ATTRIBUTE

        public static final java.lang.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 java.lang.String MATCHING_PATTERN_ATTRIBUTE
        Name of the attribute that contains the matching pattern.
    • 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 ServerResponseRouterFunction<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 ServerResponseRouterFunction<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(java.lang.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:
        a router function that routes to resources
        See Also:
        resourceLookupFunction(String, Resource)
      • resourceLookupFunction

        public static java.util.function.Function<ServerRequest,reactor.core.publisher.Mono<Resource>> resourceLookupFunction(java.lang.String pattern,
                                                                                                                              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.php"));
         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(java.util.function.Function<ServerRequest,reactor.core.publisher.Mono<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
      • toWebHandler

        public static 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