org.springframework.web.reactive.function.server

Interface RouterFunction<T extends ServerResponse>

Type Parameters:

T - the type of the handler function to route to

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface RouterFunction<T extends ServerResponse>

Represents a function that routes to a handler function.

Since:

5.0

Author:

Arjen Poutsma

See Also:

RouterFunctions

Method Summary

Modifier and Type	Method and Description
default void	accept(RouterFunctions.Visitor visitor) Accept the given visitor.
default RouterFunction<T>	and(RouterFunction<T> other) Return a composed routing function that first invokes this function, and then invokes the other function (of the same response type T) if this route had no result.
default RouterFunction<T>	andNest(RequestPredicate predicate, RouterFunction<T> routerFunction) Return a composed routing function that routes to the given router function if this route does not match and the given request predicate applies.
default RouterFunction<?>	andOther(RouterFunction<?> other) Return a composed routing function that first invokes this function, and then invokes the other function (of a different response type) if this route had no result.
default RouterFunction<T>	andRoute(RequestPredicate predicate, HandlerFunction<T> handlerFunction) Return a composed routing function that routes to the given handler function if this route does not match and the given request predicate applies.
default <S extends ServerResponse> RouterFunction<S>	filter(HandlerFilterFunction<T,S> filterFunction) Filter all handler functions routed by this function with the given filter function.
reactor.core.publisher.Mono<HandlerFunction<T>>	route(ServerRequest request) Return the handler function that matches the given request.

Method Detail

route

reactor.core.publisher.Mono<HandlerFunction<T>> route(ServerRequest request)

Return the handler function that matches the given request.

Parameters:

request - the request to route

Returns:

an Mono describing the HandlerFunction that matches this request, or an empty Mono if there is no match

and

default RouterFunction<T> and(RouterFunction<T> other)

Return a composed routing function that first invokes this function, and then invokes the other function (of the same response type T) if this route had no result.

Parameters:

other - the function of type T to apply when this function has no result

Returns:

a composed function that first routes with this function and then the other function if this function has no result

See Also:

andOther(RouterFunction)

andOther

default RouterFunction<?> andOther(RouterFunction<?> other)

Return a composed routing function that first invokes this function, and then invokes the other function (of a different response type) if this route had no result.

Parameters:

other - the function to apply when this function has no result

Returns:

a composed function that first routes with this function and then the other function if this function has no result

See Also:

and(RouterFunction)

andRoute

default RouterFunction<T> andRoute(RequestPredicate predicate,
                                   HandlerFunction<T> handlerFunction)

Return a composed routing function that routes to the given handler function if this route does not match and the given request predicate applies. This method is a convenient combination of and(RouterFunction) and RouterFunctions.route(RequestPredicate, HandlerFunction).

Parameters:

predicate - the predicate to test if this route does not match

handlerFunction - the handler function to route to if this route does not match and the predicate applies

Returns:

a composed function that route to handlerFunction if this route does not match and if predicate applies

andNest

default RouterFunction<T> andNest(RequestPredicate predicate,
                                  RouterFunction<T> routerFunction)

Return a composed routing function that routes to the given router function if this route does not match and the given request predicate applies. This method is a convenient combination of and(RouterFunction) and RouterFunctions.nest(RequestPredicate, RouterFunction).

Parameters:

predicate - the predicate to test if this route does not match

routerFunction - the router function to route to if this route does not match and the predicate applies

Returns:

a composed function that route to routerFunction if this route does not match and if predicate applies

filter

default <S extends ServerResponse> RouterFunction<S> filter(HandlerFilterFunction<T,S> filterFunction)

Filter all handler functions routed by this function with the given filter function.

Type Parameters:

S - the filter return type

Parameters:

filterFunction - the filter to apply

Returns:

the filtered routing function

accept

default void accept(RouterFunctions.Visitor visitor)

Accept the given visitor. Default implementation calls RouterFunctions.Visitor.unknown(RouterFunction); composed RouterFunction implementations are expected to call accept for all components that make up this router function

Parameters:

visitor - the visitor to accept